aboutsummaryrefslogtreecommitdiff
path: root/lib/chibios/os/common/ext/ST/STM32F7xx
diff options
context:
space:
mode:
Diffstat (limited to 'lib/chibios/os/common/ext/ST/STM32F7xx')
-rw-r--r--lib/chibios/os/common/ext/ST/STM32F7xx/stm32f722xx.h15165
-rw-r--r--lib/chibios/os/common/ext/ST/STM32F7xx/stm32f723xx.h15244
-rw-r--r--lib/chibios/os/common/ext/ST/STM32F7xx/stm32f732xx.h15390
-rw-r--r--lib/chibios/os/common/ext/ST/STM32F7xx/stm32f733xx.h15469
-rw-r--r--lib/chibios/os/common/ext/ST/STM32F7xx/stm32f745xx.h17219
-rw-r--r--lib/chibios/os/common/ext/ST/STM32F7xx/stm32f746xx.h17569
-rw-r--r--lib/chibios/os/common/ext/ST/STM32F7xx/stm32f756xx.h17856
-rw-r--r--lib/chibios/os/common/ext/ST/STM32F7xx/stm32f765xx.h17938
-rw-r--r--lib/chibios/os/common/ext/ST/STM32F7xx/stm32f767xx.h18599
-rw-r--r--lib/chibios/os/common/ext/ST/STM32F7xx/stm32f769xx.h21769
-rw-r--r--lib/chibios/os/common/ext/ST/STM32F7xx/stm32f777xx.h18886
-rw-r--r--lib/chibios/os/common/ext/ST/STM32F7xx/stm32f779xx.h22056
-rw-r--r--lib/chibios/os/common/ext/ST/STM32F7xx/stm32f7xx.h230
-rw-r--r--lib/chibios/os/common/ext/ST/STM32F7xx/system_stm32f7xx.h125
14 files changed, 213515 insertions, 0 deletions
diff --git a/lib/chibios/os/common/ext/ST/STM32F7xx/stm32f722xx.h b/lib/chibios/os/common/ext/ST/STM32F7xx/stm32f722xx.h
new file mode 100644
index 000000000..927428406
--- /dev/null
+++ b/lib/chibios/os/common/ext/ST/STM32F7xx/stm32f722xx.h
@@ -0,0 +1,15165 @@
1/**
2 ******************************************************************************
3 * @file stm32f722xx.h
4 * @author MCD Application Team
5 * @version V1.2.0
6 * @date 30-December-2016
7 * @brief CMSIS Cortex-M7 Device Peripheral Access Layer Header File.
8 *
9 * This file contains:
10 * - Data structures and the address mapping for all peripherals
11 * - Peripheral's registers declarations and bits definition
12 * - Macros to access peripheral�s registers hardware
13 *
14 ******************************************************************************
15 * @attention
16 *
17 * <h2><center>&copy; COPYRIGHT(c) 2016 STMicroelectronics</center></h2>
18 *
19 * Redistribution and use in source and binary forms, with or without modification,
20 * are permitted provided that the following conditions are met:
21 * 1. Redistributions of source code must retain the above copyright notice,
22 * this list of conditions and the following disclaimer.
23 * 2. Redistributions in binary form must reproduce the above copyright notice,
24 * this list of conditions and the following disclaimer in the documentation
25 * and/or other materials provided with the distribution.
26 * 3. Neither the name of STMicroelectronics nor the names of its contributors
27 * may be used to endorse or promote products derived from this software
28 * without specific prior written permission.
29 *
30 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
31 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
32 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
33 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
34 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
35 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
36 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
37 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
38 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
39 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
40 *
41 ******************************************************************************
42 */
43
44/** @addtogroup CMSIS_Device
45 * @{
46 */
47
48/** @addtogroup stm32f722xx
49 * @{
50 */
51
52#ifndef __STM32F722xx_H
53#define __STM32F722xx_H
54
55#ifdef __cplusplus
56 extern "C" {
57#endif /* __cplusplus */
58
59/** @addtogroup Configuration_section_for_CMSIS
60 * @{
61 */
62
63/**
64 * @brief STM32F7xx Interrupt Number Definition, according to the selected device
65 * in @ref Library_configuration_section
66 */
67typedef enum
68{
69/****** Cortex-M7 Processor Exceptions Numbers ****************************************************************/
70 NonMaskableInt_IRQn = -14, /*!< 2 Non Maskable Interrupt */
71 MemoryManagement_IRQn = -12, /*!< 4 Cortex-M7 Memory Management Interrupt */
72 BusFault_IRQn = -11, /*!< 5 Cortex-M7 Bus Fault Interrupt */
73 UsageFault_IRQn = -10, /*!< 6 Cortex-M7 Usage Fault Interrupt */
74 SVCall_IRQn = -5, /*!< 11 Cortex-M7 SV Call Interrupt */
75 DebugMonitor_IRQn = -4, /*!< 12 Cortex-M7 Debug Monitor Interrupt */
76 PendSV_IRQn = -2, /*!< 14 Cortex-M7 Pend SV Interrupt */
77 SysTick_IRQn = -1, /*!< 15 Cortex-M7 System Tick Interrupt */
78/****** STM32 specific Interrupt Numbers **********************************************************************/
79 WWDG_IRQn = 0, /*!< Window WatchDog Interrupt */
80 PVD_IRQn = 1, /*!< PVD through EXTI Line detection Interrupt */
81 TAMP_STAMP_IRQn = 2, /*!< Tamper and TimeStamp interrupts through the EXTI line */
82 RTC_WKUP_IRQn = 3, /*!< RTC Wakeup interrupt through the EXTI line */
83 FLASH_IRQn = 4, /*!< FLASH global Interrupt */
84 RCC_IRQn = 5, /*!< RCC global Interrupt */
85 EXTI0_IRQn = 6, /*!< EXTI Line0 Interrupt */
86 EXTI1_IRQn = 7, /*!< EXTI Line1 Interrupt */
87 EXTI2_IRQn = 8, /*!< EXTI Line2 Interrupt */
88 EXTI3_IRQn = 9, /*!< EXTI Line3 Interrupt */
89 EXTI4_IRQn = 10, /*!< EXTI Line4 Interrupt */
90 DMA1_Stream0_IRQn = 11, /*!< DMA1 Stream 0 global Interrupt */
91 DMA1_Stream1_IRQn = 12, /*!< DMA1 Stream 1 global Interrupt */
92 DMA1_Stream2_IRQn = 13, /*!< DMA1 Stream 2 global Interrupt */
93 DMA1_Stream3_IRQn = 14, /*!< DMA1 Stream 3 global Interrupt */
94 DMA1_Stream4_IRQn = 15, /*!< DMA1 Stream 4 global Interrupt */
95 DMA1_Stream5_IRQn = 16, /*!< DMA1 Stream 5 global Interrupt */
96 DMA1_Stream6_IRQn = 17, /*!< DMA1 Stream 6 global Interrupt */
97 ADC_IRQn = 18, /*!< ADC1, ADC2 and ADC3 global Interrupts */
98 CAN1_TX_IRQn = 19, /*!< CAN1 TX Interrupt */
99 CAN1_RX0_IRQn = 20, /*!< CAN1 RX0 Interrupt */
100 CAN1_RX1_IRQn = 21, /*!< CAN1 RX1 Interrupt */
101 CAN1_SCE_IRQn = 22, /*!< CAN1 SCE Interrupt */
102 EXTI9_5_IRQn = 23, /*!< External Line[9:5] Interrupts */
103 TIM1_BRK_TIM9_IRQn = 24, /*!< TIM1 Break interrupt and TIM9 global interrupt */
104 TIM1_UP_TIM10_IRQn = 25, /*!< TIM1 Update Interrupt and TIM10 global interrupt */
105 TIM1_TRG_COM_TIM11_IRQn = 26, /*!< TIM1 Trigger and Commutation Interrupt and TIM11 global interrupt */
106 TIM1_CC_IRQn = 27, /*!< TIM1 Capture Compare Interrupt */
107 TIM2_IRQn = 28, /*!< TIM2 global Interrupt */
108 TIM3_IRQn = 29, /*!< TIM3 global Interrupt */
109 TIM4_IRQn = 30, /*!< TIM4 global Interrupt */
110 I2C1_EV_IRQn = 31, /*!< I2C1 Event Interrupt */
111 I2C1_ER_IRQn = 32, /*!< I2C1 Error Interrupt */
112 I2C2_EV_IRQn = 33, /*!< I2C2 Event Interrupt */
113 I2C2_ER_IRQn = 34, /*!< I2C2 Error Interrupt */
114 SPI1_IRQn = 35, /*!< SPI1 global Interrupt */
115 SPI2_IRQn = 36, /*!< SPI2 global Interrupt */
116 USART1_IRQn = 37, /*!< USART1 global Interrupt */
117 USART2_IRQn = 38, /*!< USART2 global Interrupt */
118 USART3_IRQn = 39, /*!< USART3 global Interrupt */
119 EXTI15_10_IRQn = 40, /*!< External Line[15:10] Interrupts */
120 RTC_Alarm_IRQn = 41, /*!< RTC Alarm (A and B) through EXTI Line Interrupt */
121 OTG_FS_WKUP_IRQn = 42, /*!< USB OTG FS Wakeup through EXTI line interrupt */
122 TIM8_BRK_TIM12_IRQn = 43, /*!< TIM8 Break Interrupt and TIM12 global interrupt */
123 TIM8_UP_TIM13_IRQn = 44, /*!< TIM8 Update Interrupt and TIM13 global interrupt */
124 TIM8_TRG_COM_TIM14_IRQn = 45, /*!< TIM8 Trigger and Commutation Interrupt and TIM14 global interrupt */
125 TIM8_CC_IRQn = 46, /*!< TIM8 Capture Compare Interrupt */
126 DMA1_Stream7_IRQn = 47, /*!< DMA1 Stream7 Interrupt */
127 FMC_IRQn = 48, /*!< FMC global Interrupt */
128 SDMMC1_IRQn = 49, /*!< SDMMC1 global Interrupt */
129 TIM5_IRQn = 50, /*!< TIM5 global Interrupt */
130 SPI3_IRQn = 51, /*!< SPI3 global Interrupt */
131 UART4_IRQn = 52, /*!< UART4 global Interrupt */
132 UART5_IRQn = 53, /*!< UART5 global Interrupt */
133 TIM6_DAC_IRQn = 54, /*!< TIM6 global and DAC1&2 underrun error interrupts */
134 TIM7_IRQn = 55, /*!< TIM7 global interrupt */
135 DMA2_Stream0_IRQn = 56, /*!< DMA2 Stream 0 global Interrupt */
136 DMA2_Stream1_IRQn = 57, /*!< DMA2 Stream 1 global Interrupt */
137 DMA2_Stream2_IRQn = 58, /*!< DMA2 Stream 2 global Interrupt */
138 DMA2_Stream3_IRQn = 59, /*!< DMA2 Stream 3 global Interrupt */
139 DMA2_Stream4_IRQn = 60, /*!< DMA2 Stream 4 global Interrupt */
140 ETH_IRQn = 61, /*!< Ethernet global Interrupt */
141 ETH_WKUP_IRQn = 62, /*!< Ethernet Wakeup through EXTI line Interrupt */
142 OTG_FS_IRQn = 67, /*!< USB OTG FS global Interrupt */
143 DMA2_Stream5_IRQn = 68, /*!< DMA2 Stream 5 global interrupt */
144 DMA2_Stream6_IRQn = 69, /*!< DMA2 Stream 6 global interrupt */
145 DMA2_Stream7_IRQn = 70, /*!< DMA2 Stream 7 global interrupt */
146 USART6_IRQn = 71, /*!< USART6 global interrupt */
147 I2C3_EV_IRQn = 72, /*!< I2C3 event interrupt */
148 I2C3_ER_IRQn = 73, /*!< I2C3 error interrupt */
149 OTG_HS_EP1_OUT_IRQn = 74, /*!< USB OTG HS End Point 1 Out global interrupt */
150 OTG_HS_EP1_IN_IRQn = 75, /*!< USB OTG HS End Point 1 In global interrupt */
151 OTG_HS_WKUP_IRQn = 76, /*!< USB OTG HS Wakeup through EXTI interrupt */
152 OTG_HS_IRQn = 77, /*!< USB OTG HS global interrupt */
153 RNG_IRQn = 80, /*!< RNG global interrupt */
154 FPU_IRQn = 81, /*!< FPU global interrupt */
155 UART7_IRQn = 82, /*!< UART7 global interrupt */
156 UART8_IRQn = 83, /*!< UART8 global interrupt */
157 SPI4_IRQn = 84, /*!< SPI4 global Interrupt */
158 SPI5_IRQn = 85, /*!< SPI5 global Interrupt */
159 SAI1_IRQn = 87, /*!< SAI1 global Interrupt */
160 SAI2_IRQn = 91, /*!< SAI2 global Interrupt */
161 QUADSPI_IRQn = 92, /*!< Quad SPI global interrupt */
162 LPTIM1_IRQn = 93, /*!< LP TIM1 interrupt */
163 SDMMC2_IRQn = 103, /*!< SDMMC2 global Interrupt */
164} IRQn_Type;
165
166/**
167 * @}
168 */
169
170/**
171 * @brief Configuration of the Cortex-M7 Processor and Core Peripherals
172 */
173#define __CM7_REV 0x0100U /*!< Cortex-M7 revision r1p0 */
174#define __MPU_PRESENT 1 /*!< CM7 provides an MPU */
175#define __NVIC_PRIO_BITS 4 /*!< CM7 uses 4 Bits for the Priority Levels */
176#define __Vendor_SysTickConfig 0 /*!< Set to 1 if different SysTick Config is used */
177#define __FPU_PRESENT 1 /*!< FPU present */
178#define __ICACHE_PRESENT 1 /*!< CM7 instruction cache present */
179#define __DCACHE_PRESENT 1 /*!< CM7 data cache present */
180#include "core_cm7.h" /*!< Cortex-M7 processor and core peripherals */
181
182
183#include "system_stm32f7xx.h"
184#include <stdint.h>
185
186/** @addtogroup Peripheral_registers_structures
187 * @{
188 */
189
190/**
191 * @brief Analog to Digital Converter
192 */
193
194typedef struct
195{
196 __IO uint32_t SR; /*!< ADC status register, Address offset: 0x00 */
197 __IO uint32_t CR1; /*!< ADC control register 1, Address offset: 0x04 */
198 __IO uint32_t CR2; /*!< ADC control register 2, Address offset: 0x08 */
199 __IO uint32_t SMPR1; /*!< ADC sample time register 1, Address offset: 0x0C */
200 __IO uint32_t SMPR2; /*!< ADC sample time register 2, Address offset: 0x10 */
201 __IO uint32_t JOFR1; /*!< ADC injected channel data offset register 1, Address offset: 0x14 */
202 __IO uint32_t JOFR2; /*!< ADC injected channel data offset register 2, Address offset: 0x18 */
203 __IO uint32_t JOFR3; /*!< ADC injected channel data offset register 3, Address offset: 0x1C */
204 __IO uint32_t JOFR4; /*!< ADC injected channel data offset register 4, Address offset: 0x20 */
205 __IO uint32_t HTR; /*!< ADC watchdog higher threshold register, Address offset: 0x24 */
206 __IO uint32_t LTR; /*!< ADC watchdog lower threshold register, Address offset: 0x28 */
207 __IO uint32_t SQR1; /*!< ADC regular sequence register 1, Address offset: 0x2C */
208 __IO uint32_t SQR2; /*!< ADC regular sequence register 2, Address offset: 0x30 */
209 __IO uint32_t SQR3; /*!< ADC regular sequence register 3, Address offset: 0x34 */
210 __IO uint32_t JSQR; /*!< ADC injected sequence register, Address offset: 0x38*/
211 __IO uint32_t JDR1; /*!< ADC injected data register 1, Address offset: 0x3C */
212 __IO uint32_t JDR2; /*!< ADC injected data register 2, Address offset: 0x40 */
213 __IO uint32_t JDR3; /*!< ADC injected data register 3, Address offset: 0x44 */
214 __IO uint32_t JDR4; /*!< ADC injected data register 4, Address offset: 0x48 */
215 __IO uint32_t DR; /*!< ADC regular data register, Address offset: 0x4C */
216} ADC_TypeDef;
217
218typedef struct
219{
220 __IO uint32_t CSR; /*!< ADC Common status register, Address offset: ADC1 base address + 0x300 */
221 __IO uint32_t CCR; /*!< ADC common control register, Address offset: ADC1 base address + 0x304 */
222 __IO uint32_t CDR; /*!< ADC common regular data register for dual
223 AND triple modes, Address offset: ADC1 base address + 0x308 */
224} ADC_Common_TypeDef;
225
226
227/**
228 * @brief Controller Area Network TxMailBox
229 */
230
231typedef struct
232{
233 __IO uint32_t TIR; /*!< CAN TX mailbox identifier register */
234 __IO uint32_t TDTR; /*!< CAN mailbox data length control and time stamp register */
235 __IO uint32_t TDLR; /*!< CAN mailbox data low register */
236 __IO uint32_t TDHR; /*!< CAN mailbox data high register */
237} CAN_TxMailBox_TypeDef;
238
239/**
240 * @brief Controller Area Network FIFOMailBox
241 */
242
243typedef struct
244{
245 __IO uint32_t RIR; /*!< CAN receive FIFO mailbox identifier register */
246 __IO uint32_t RDTR; /*!< CAN receive FIFO mailbox data length control and time stamp register */
247 __IO uint32_t RDLR; /*!< CAN receive FIFO mailbox data low register */
248 __IO uint32_t RDHR; /*!< CAN receive FIFO mailbox data high register */
249} CAN_FIFOMailBox_TypeDef;
250
251/**
252 * @brief Controller Area Network FilterRegister
253 */
254
255typedef struct
256{
257 __IO uint32_t FR1; /*!< CAN Filter bank register 1 */
258 __IO uint32_t FR2; /*!< CAN Filter bank register 1 */
259} CAN_FilterRegister_TypeDef;
260
261/**
262 * @brief Controller Area Network
263 */
264
265typedef struct
266{
267 __IO uint32_t MCR; /*!< CAN master control register, Address offset: 0x00 */
268 __IO uint32_t MSR; /*!< CAN master status register, Address offset: 0x04 */
269 __IO uint32_t TSR; /*!< CAN transmit status register, Address offset: 0x08 */
270 __IO uint32_t RF0R; /*!< CAN receive FIFO 0 register, Address offset: 0x0C */
271 __IO uint32_t RF1R; /*!< CAN receive FIFO 1 register, Address offset: 0x10 */
272 __IO uint32_t IER; /*!< CAN interrupt enable register, Address offset: 0x14 */
273 __IO uint32_t ESR; /*!< CAN error status register, Address offset: 0x18 */
274 __IO uint32_t BTR; /*!< CAN bit timing register, Address offset: 0x1C */
275 uint32_t RESERVED0[88]; /*!< Reserved, 0x020 - 0x17F */
276 CAN_TxMailBox_TypeDef sTxMailBox[3]; /*!< CAN Tx MailBox, Address offset: 0x180 - 0x1AC */
277 CAN_FIFOMailBox_TypeDef sFIFOMailBox[2]; /*!< CAN FIFO MailBox, Address offset: 0x1B0 - 0x1CC */
278 uint32_t RESERVED1[12]; /*!< Reserved, 0x1D0 - 0x1FF */
279 __IO uint32_t FMR; /*!< CAN filter master register, Address offset: 0x200 */
280 __IO uint32_t FM1R; /*!< CAN filter mode register, Address offset: 0x204 */
281 uint32_t RESERVED2; /*!< Reserved, 0x208 */
282 __IO uint32_t FS1R; /*!< CAN filter scale register, Address offset: 0x20C */
283 uint32_t RESERVED3; /*!< Reserved, 0x210 */
284 __IO uint32_t FFA1R; /*!< CAN filter FIFO assignment register, Address offset: 0x214 */
285 uint32_t RESERVED4; /*!< Reserved, 0x218 */
286 __IO uint32_t FA1R; /*!< CAN filter activation register, Address offset: 0x21C */
287 uint32_t RESERVED5[8]; /*!< Reserved, 0x220-0x23F */
288 CAN_FilterRegister_TypeDef sFilterRegister[28]; /*!< CAN Filter Register, Address offset: 0x240-0x31C */
289} CAN_TypeDef;
290
291
292/**
293 * @brief CRC calculation unit
294 */
295
296typedef struct
297{
298 __IO uint32_t DR; /*!< CRC Data register, Address offset: 0x00 */
299 __IO uint8_t IDR; /*!< CRC Independent data register, Address offset: 0x04 */
300 uint8_t RESERVED0; /*!< Reserved, 0x05 */
301 uint16_t RESERVED1; /*!< Reserved, 0x06 */
302 __IO uint32_t CR; /*!< CRC Control register, Address offset: 0x08 */
303 uint32_t RESERVED2; /*!< Reserved, 0x0C */
304 __IO uint32_t INIT; /*!< Initial CRC value register, Address offset: 0x10 */
305 __IO uint32_t POL; /*!< CRC polynomial register, Address offset: 0x14 */
306} CRC_TypeDef;
307
308/**
309 * @brief Digital to Analog Converter
310 */
311
312typedef struct
313{
314 __IO uint32_t CR; /*!< DAC control register, Address offset: 0x00 */
315 __IO uint32_t SWTRIGR; /*!< DAC software trigger register, Address offset: 0x04 */
316 __IO uint32_t DHR12R1; /*!< DAC channel1 12-bit right-aligned data holding register, Address offset: 0x08 */
317 __IO uint32_t DHR12L1; /*!< DAC channel1 12-bit left aligned data holding register, Address offset: 0x0C */
318 __IO uint32_t DHR8R1; /*!< DAC channel1 8-bit right aligned data holding register, Address offset: 0x10 */
319 __IO uint32_t DHR12R2; /*!< DAC channel2 12-bit right aligned data holding register, Address offset: 0x14 */
320 __IO uint32_t DHR12L2; /*!< DAC channel2 12-bit left aligned data holding register, Address offset: 0x18 */
321 __IO uint32_t DHR8R2; /*!< DAC channel2 8-bit right-aligned data holding register, Address offset: 0x1C */
322 __IO uint32_t DHR12RD; /*!< Dual DAC 12-bit right-aligned data holding register, Address offset: 0x20 */
323 __IO uint32_t DHR12LD; /*!< DUAL DAC 12-bit left aligned data holding register, Address offset: 0x24 */
324 __IO uint32_t DHR8RD; /*!< DUAL DAC 8-bit right aligned data holding register, Address offset: 0x28 */
325 __IO uint32_t DOR1; /*!< DAC channel1 data output register, Address offset: 0x2C */
326 __IO uint32_t DOR2; /*!< DAC channel2 data output register, Address offset: 0x30 */
327 __IO uint32_t SR; /*!< DAC status register, Address offset: 0x34 */
328} DAC_TypeDef;
329
330
331/**
332 * @brief Debug MCU
333 */
334
335typedef struct
336{
337 __IO uint32_t IDCODE; /*!< MCU device ID code, Address offset: 0x00 */
338 __IO uint32_t CR; /*!< Debug MCU configuration register, Address offset: 0x04 */
339 __IO uint32_t APB1FZ; /*!< Debug MCU APB1 freeze register, Address offset: 0x08 */
340 __IO uint32_t APB2FZ; /*!< Debug MCU APB2 freeze register, Address offset: 0x0C */
341}DBGMCU_TypeDef;
342
343
344/**
345 * @brief DMA Controller
346 */
347
348typedef struct
349{
350 __IO uint32_t CR; /*!< DMA stream x configuration register */
351 __IO uint32_t NDTR; /*!< DMA stream x number of data register */
352 __IO uint32_t PAR; /*!< DMA stream x peripheral address register */
353 __IO uint32_t M0AR; /*!< DMA stream x memory 0 address register */
354 __IO uint32_t M1AR; /*!< DMA stream x memory 1 address register */
355 __IO uint32_t FCR; /*!< DMA stream x FIFO control register */
356} DMA_Stream_TypeDef;
357
358typedef struct
359{
360 __IO uint32_t LISR; /*!< DMA low interrupt status register, Address offset: 0x00 */
361 __IO uint32_t HISR; /*!< DMA high interrupt status register, Address offset: 0x04 */
362 __IO uint32_t LIFCR; /*!< DMA low interrupt flag clear register, Address offset: 0x08 */
363 __IO uint32_t HIFCR; /*!< DMA high interrupt flag clear register, Address offset: 0x0C */
364} DMA_TypeDef;
365
366
367/**
368 * @brief External Interrupt/Event Controller
369 */
370
371typedef struct
372{
373 __IO uint32_t IMR; /*!< EXTI Interrupt mask register, Address offset: 0x00 */
374 __IO uint32_t EMR; /*!< EXTI Event mask register, Address offset: 0x04 */
375 __IO uint32_t RTSR; /*!< EXTI Rising trigger selection register, Address offset: 0x08 */
376 __IO uint32_t FTSR; /*!< EXTI Falling trigger selection register, Address offset: 0x0C */
377 __IO uint32_t SWIER; /*!< EXTI Software interrupt event register, Address offset: 0x10 */
378 __IO uint32_t PR; /*!< EXTI Pending register, Address offset: 0x14 */
379} EXTI_TypeDef;
380
381/**
382 * @brief FLASH Registers
383 */
384
385typedef struct
386{
387 __IO uint32_t ACR; /*!< FLASH access control register, Address offset: 0x00 */
388 __IO uint32_t KEYR; /*!< FLASH key register, Address offset: 0x04 */
389 __IO uint32_t OPTKEYR; /*!< FLASH option key register, Address offset: 0x08 */
390 __IO uint32_t SR; /*!< FLASH status register, Address offset: 0x0C */
391 __IO uint32_t CR; /*!< FLASH control register, Address offset: 0x10 */
392 __IO uint32_t OPTCR; /*!< FLASH option control register , Address offset: 0x14 */
393 __IO uint32_t OPTCR1; /*!< FLASH option control register 1 , Address offset: 0x18 */
394 __IO uint32_t OPTCR2; /*!< FLASH option control register 2 , Address offset: 0x1C */
395} FLASH_TypeDef;
396
397
398
399/**
400 * @brief Flexible Memory Controller
401 */
402
403typedef struct
404{
405 __IO uint32_t BTCR[8]; /*!< NOR/PSRAM chip-select control register(BCR) and chip-select timing register(BTR), Address offset: 0x00-1C */
406} FMC_Bank1_TypeDef;
407
408/**
409 * @brief Flexible Memory Controller Bank1E
410 */
411
412typedef struct
413{
414 __IO uint32_t BWTR[7]; /*!< NOR/PSRAM write timing registers, Address offset: 0x104-0x11C */
415} FMC_Bank1E_TypeDef;
416
417/**
418 * @brief Flexible Memory Controller Bank3
419 */
420
421typedef struct
422{
423 __IO uint32_t PCR; /*!< NAND Flash control register, Address offset: 0x80 */
424 __IO uint32_t SR; /*!< NAND Flash FIFO status and interrupt register, Address offset: 0x84 */
425 __IO uint32_t PMEM; /*!< NAND Flash Common memory space timing register, Address offset: 0x88 */
426 __IO uint32_t PATT; /*!< NAND Flash Attribute memory space timing register, Address offset: 0x8C */
427 uint32_t RESERVED0; /*!< Reserved, 0x90 */
428 __IO uint32_t ECCR; /*!< NAND Flash ECC result registers, Address offset: 0x94 */
429} FMC_Bank3_TypeDef;
430
431/**
432 * @brief Flexible Memory Controller Bank5_6
433 */
434
435typedef struct
436{
437 __IO uint32_t SDCR[2]; /*!< SDRAM Control registers , Address offset: 0x140-0x144 */
438 __IO uint32_t SDTR[2]; /*!< SDRAM Timing registers , Address offset: 0x148-0x14C */
439 __IO uint32_t SDCMR; /*!< SDRAM Command Mode register, Address offset: 0x150 */
440 __IO uint32_t SDRTR; /*!< SDRAM Refresh Timer register, Address offset: 0x154 */
441 __IO uint32_t SDSR; /*!< SDRAM Status register, Address offset: 0x158 */
442} FMC_Bank5_6_TypeDef;
443
444
445/**
446 * @brief General Purpose I/O
447 */
448
449typedef struct
450{
451 __IO uint32_t MODER; /*!< GPIO port mode register, Address offset: 0x00 */
452 __IO uint32_t OTYPER; /*!< GPIO port output type register, Address offset: 0x04 */
453 __IO uint32_t OSPEEDR; /*!< GPIO port output speed register, Address offset: 0x08 */
454 __IO uint32_t PUPDR; /*!< GPIO port pull-up/pull-down register, Address offset: 0x0C */
455 __IO uint32_t IDR; /*!< GPIO port input data register, Address offset: 0x10 */
456 __IO uint32_t ODR; /*!< GPIO port output data register, Address offset: 0x14 */
457 __IO uint32_t BSRR; /*!< GPIO port bit set/reset register, Address offset: 0x18 */
458 __IO uint32_t LCKR; /*!< GPIO port configuration lock register, Address offset: 0x1C */
459 __IO uint32_t AFR[2]; /*!< GPIO alternate function registers, Address offset: 0x20-0x24 */
460} GPIO_TypeDef;
461
462/**
463 * @brief System configuration controller
464 */
465
466typedef struct
467{
468 __IO uint32_t MEMRMP; /*!< SYSCFG memory remap register, Address offset: 0x00 */
469 __IO uint32_t PMC; /*!< SYSCFG peripheral mode configuration register, Address offset: 0x04 */
470 __IO uint32_t EXTICR[4]; /*!< SYSCFG external interrupt configuration registers, Address offset: 0x08-0x14 */
471 uint32_t RESERVED[2]; /*!< Reserved, 0x18-0x1C */
472 __IO uint32_t CMPCR; /*!< SYSCFG Compensation cell control register, Address offset: 0x20 */
473} SYSCFG_TypeDef;
474
475/**
476 * @brief Inter-integrated Circuit Interface
477 */
478
479typedef struct
480{
481 __IO uint32_t CR1; /*!< I2C Control register 1, Address offset: 0x00 */
482 __IO uint32_t CR2; /*!< I2C Control register 2, Address offset: 0x04 */
483 __IO uint32_t OAR1; /*!< I2C Own address 1 register, Address offset: 0x08 */
484 __IO uint32_t OAR2; /*!< I2C Own address 2 register, Address offset: 0x0C */
485 __IO uint32_t TIMINGR; /*!< I2C Timing register, Address offset: 0x10 */
486 __IO uint32_t TIMEOUTR; /*!< I2C Timeout register, Address offset: 0x14 */
487 __IO uint32_t ISR; /*!< I2C Interrupt and status register, Address offset: 0x18 */
488 __IO uint32_t ICR; /*!< I2C Interrupt clear register, Address offset: 0x1C */
489 __IO uint32_t PECR; /*!< I2C PEC register, Address offset: 0x20 */
490 __IO uint32_t RXDR; /*!< I2C Receive data register, Address offset: 0x24 */
491 __IO uint32_t TXDR; /*!< I2C Transmit data register, Address offset: 0x28 */
492} I2C_TypeDef;
493
494/**
495 * @brief Independent WATCHDOG
496 */
497
498typedef struct
499{
500 __IO uint32_t KR; /*!< IWDG Key register, Address offset: 0x00 */
501 __IO uint32_t PR; /*!< IWDG Prescaler register, Address offset: 0x04 */
502 __IO uint32_t RLR; /*!< IWDG Reload register, Address offset: 0x08 */
503 __IO uint32_t SR; /*!< IWDG Status register, Address offset: 0x0C */
504 __IO uint32_t WINR; /*!< IWDG Window register, Address offset: 0x10 */
505} IWDG_TypeDef;
506
507
508
509/**
510 * @brief Power Control
511 */
512
513typedef struct
514{
515 __IO uint32_t CR1; /*!< PWR power control register 1, Address offset: 0x00 */
516 __IO uint32_t CSR1; /*!< PWR power control/status register 2, Address offset: 0x04 */
517 __IO uint32_t CR2; /*!< PWR power control register 2, Address offset: 0x08 */
518 __IO uint32_t CSR2; /*!< PWR power control/status register 2, Address offset: 0x0C */
519} PWR_TypeDef;
520
521
522/**
523 * @brief Reset and Clock Control
524 */
525
526typedef struct
527{
528 __IO uint32_t CR; /*!< RCC clock control register, Address offset: 0x00 */
529 __IO uint32_t PLLCFGR; /*!< RCC PLL configuration register, Address offset: 0x04 */
530 __IO uint32_t CFGR; /*!< RCC clock configuration register, Address offset: 0x08 */
531 __IO uint32_t CIR; /*!< RCC clock interrupt register, Address offset: 0x0C */
532 __IO uint32_t AHB1RSTR; /*!< RCC AHB1 peripheral reset register, Address offset: 0x10 */
533 __IO uint32_t AHB2RSTR; /*!< RCC AHB2 peripheral reset register, Address offset: 0x14 */
534 __IO uint32_t AHB3RSTR; /*!< RCC AHB3 peripheral reset register, Address offset: 0x18 */
535 uint32_t RESERVED0; /*!< Reserved, 0x1C */
536 __IO uint32_t APB1RSTR; /*!< RCC APB1 peripheral reset register, Address offset: 0x20 */
537 __IO uint32_t APB2RSTR; /*!< RCC APB2 peripheral reset register, Address offset: 0x24 */
538 uint32_t RESERVED1[2]; /*!< Reserved, 0x28-0x2C */
539 __IO uint32_t AHB1ENR; /*!< RCC AHB1 peripheral clock register, Address offset: 0x30 */
540 __IO uint32_t AHB2ENR; /*!< RCC AHB2 peripheral clock register, Address offset: 0x34 */
541 __IO uint32_t AHB3ENR; /*!< RCC AHB3 peripheral clock register, Address offset: 0x38 */
542 uint32_t RESERVED2; /*!< Reserved, 0x3C */
543 __IO uint32_t APB1ENR; /*!< RCC APB1 peripheral clock enable register, Address offset: 0x40 */
544 __IO uint32_t APB2ENR; /*!< RCC APB2 peripheral clock enable register, Address offset: 0x44 */
545 uint32_t RESERVED3[2]; /*!< Reserved, 0x48-0x4C */
546 __IO uint32_t AHB1LPENR; /*!< RCC AHB1 peripheral clock enable in low power mode register, Address offset: 0x50 */
547 __IO uint32_t AHB2LPENR; /*!< RCC AHB2 peripheral clock enable in low power mode register, Address offset: 0x54 */
548 __IO uint32_t AHB3LPENR; /*!< RCC AHB3 peripheral clock enable in low power mode register, Address offset: 0x58 */
549 uint32_t RESERVED4; /*!< Reserved, 0x5C */
550 __IO uint32_t APB1LPENR; /*!< RCC APB1 peripheral clock enable in low power mode register, Address offset: 0x60 */
551 __IO uint32_t APB2LPENR; /*!< RCC APB2 peripheral clock enable in low power mode register, Address offset: 0x64 */
552 uint32_t RESERVED5[2]; /*!< Reserved, 0x68-0x6C */
553 __IO uint32_t BDCR; /*!< RCC Backup domain control register, Address offset: 0x70 */
554 __IO uint32_t CSR; /*!< RCC clock control & status register, Address offset: 0x74 */
555 uint32_t RESERVED6[2]; /*!< Reserved, 0x78-0x7C */
556 __IO uint32_t SSCGR; /*!< RCC spread spectrum clock generation register, Address offset: 0x80 */
557 __IO uint32_t PLLI2SCFGR; /*!< RCC PLLI2S configuration register, Address offset: 0x84 */
558 __IO uint32_t PLLSAICFGR; /*!< RCC PLLSAI configuration register, Address offset: 0x88 */
559 __IO uint32_t DCKCFGR1; /*!< RCC Dedicated Clocks configuration register1, Address offset: 0x8C */
560 __IO uint32_t DCKCFGR2; /*!< RCC Dedicated Clocks configuration register 2, Address offset: 0x90 */
561
562} RCC_TypeDef;
563
564/**
565 * @brief Real-Time Clock
566 */
567
568typedef struct
569{
570 __IO uint32_t TR; /*!< RTC time register, Address offset: 0x00 */
571 __IO uint32_t DR; /*!< RTC date register, Address offset: 0x04 */
572 __IO uint32_t CR; /*!< RTC control register, Address offset: 0x08 */
573 __IO uint32_t ISR; /*!< RTC initialization and status register, Address offset: 0x0C */
574 __IO uint32_t PRER; /*!< RTC prescaler register, Address offset: 0x10 */
575 __IO uint32_t WUTR; /*!< RTC wakeup timer register, Address offset: 0x14 */
576 uint32_t reserved; /*!< Reserved */
577 __IO uint32_t ALRMAR; /*!< RTC alarm A register, Address offset: 0x1C */
578 __IO uint32_t ALRMBR; /*!< RTC alarm B register, Address offset: 0x20 */
579 __IO uint32_t WPR; /*!< RTC write protection register, Address offset: 0x24 */
580 __IO uint32_t SSR; /*!< RTC sub second register, Address offset: 0x28 */
581 __IO uint32_t SHIFTR; /*!< RTC shift control register, Address offset: 0x2C */
582 __IO uint32_t TSTR; /*!< RTC time stamp time register, Address offset: 0x30 */
583 __IO uint32_t TSDR; /*!< RTC time stamp date register, Address offset: 0x34 */
584 __IO uint32_t TSSSR; /*!< RTC time-stamp sub second register, Address offset: 0x38 */
585 __IO uint32_t CALR; /*!< RTC calibration register, Address offset: 0x3C */
586 __IO uint32_t TAMPCR; /*!< RTC tamper configuration register, Address offset: 0x40 */
587 __IO uint32_t ALRMASSR; /*!< RTC alarm A sub second register, Address offset: 0x44 */
588 __IO uint32_t ALRMBSSR; /*!< RTC alarm B sub second register, Address offset: 0x48 */
589 __IO uint32_t OR; /*!< RTC option register, Address offset: 0x4C */
590 __IO uint32_t BKP0R; /*!< RTC backup register 0, Address offset: 0x50 */
591 __IO uint32_t BKP1R; /*!< RTC backup register 1, Address offset: 0x54 */
592 __IO uint32_t BKP2R; /*!< RTC backup register 2, Address offset: 0x58 */
593 __IO uint32_t BKP3R; /*!< RTC backup register 3, Address offset: 0x5C */
594 __IO uint32_t BKP4R; /*!< RTC backup register 4, Address offset: 0x60 */
595 __IO uint32_t BKP5R; /*!< RTC backup register 5, Address offset: 0x64 */
596 __IO uint32_t BKP6R; /*!< RTC backup register 6, Address offset: 0x68 */
597 __IO uint32_t BKP7R; /*!< RTC backup register 7, Address offset: 0x6C */
598 __IO uint32_t BKP8R; /*!< RTC backup register 8, Address offset: 0x70 */
599 __IO uint32_t BKP9R; /*!< RTC backup register 9, Address offset: 0x74 */
600 __IO uint32_t BKP10R; /*!< RTC backup register 10, Address offset: 0x78 */
601 __IO uint32_t BKP11R; /*!< RTC backup register 11, Address offset: 0x7C */
602 __IO uint32_t BKP12R; /*!< RTC backup register 12, Address offset: 0x80 */
603 __IO uint32_t BKP13R; /*!< RTC backup register 13, Address offset: 0x84 */
604 __IO uint32_t BKP14R; /*!< RTC backup register 14, Address offset: 0x88 */
605 __IO uint32_t BKP15R; /*!< RTC backup register 15, Address offset: 0x8C */
606 __IO uint32_t BKP16R; /*!< RTC backup register 16, Address offset: 0x90 */
607 __IO uint32_t BKP17R; /*!< RTC backup register 17, Address offset: 0x94 */
608 __IO uint32_t BKP18R; /*!< RTC backup register 18, Address offset: 0x98 */
609 __IO uint32_t BKP19R; /*!< RTC backup register 19, Address offset: 0x9C */
610 __IO uint32_t BKP20R; /*!< RTC backup register 20, Address offset: 0xA0 */
611 __IO uint32_t BKP21R; /*!< RTC backup register 21, Address offset: 0xA4 */
612 __IO uint32_t BKP22R; /*!< RTC backup register 22, Address offset: 0xA8 */
613 __IO uint32_t BKP23R; /*!< RTC backup register 23, Address offset: 0xAC */
614 __IO uint32_t BKP24R; /*!< RTC backup register 24, Address offset: 0xB0 */
615 __IO uint32_t BKP25R; /*!< RTC backup register 25, Address offset: 0xB4 */
616 __IO uint32_t BKP26R; /*!< RTC backup register 26, Address offset: 0xB8 */
617 __IO uint32_t BKP27R; /*!< RTC backup register 27, Address offset: 0xBC */
618 __IO uint32_t BKP28R; /*!< RTC backup register 28, Address offset: 0xC0 */
619 __IO uint32_t BKP29R; /*!< RTC backup register 29, Address offset: 0xC4 */
620 __IO uint32_t BKP30R; /*!< RTC backup register 30, Address offset: 0xC8 */
621 __IO uint32_t BKP31R; /*!< RTC backup register 31, Address offset: 0xCC */
622} RTC_TypeDef;
623
624
625/**
626 * @brief Serial Audio Interface
627 */
628
629typedef struct
630{
631 __IO uint32_t GCR; /*!< SAI global configuration register, Address offset: 0x00 */
632} SAI_TypeDef;
633
634typedef struct
635{
636 __IO uint32_t CR1; /*!< SAI block x configuration register 1, Address offset: 0x04 */
637 __IO uint32_t CR2; /*!< SAI block x configuration register 2, Address offset: 0x08 */
638 __IO uint32_t FRCR; /*!< SAI block x frame configuration register, Address offset: 0x0C */
639 __IO uint32_t SLOTR; /*!< SAI block x slot register, Address offset: 0x10 */
640 __IO uint32_t IMR; /*!< SAI block x interrupt mask register, Address offset: 0x14 */
641 __IO uint32_t SR; /*!< SAI block x status register, Address offset: 0x18 */
642 __IO uint32_t CLRFR; /*!< SAI block x clear flag register, Address offset: 0x1C */
643 __IO uint32_t DR; /*!< SAI block x data register, Address offset: 0x20 */
644} SAI_Block_TypeDef;
645
646
647/**
648 * @brief SD host Interface
649 */
650
651typedef struct
652{
653 __IO uint32_t POWER; /*!< SDMMC power control register, Address offset: 0x00 */
654 __IO uint32_t CLKCR; /*!< SDMMClock control register, Address offset: 0x04 */
655 __IO uint32_t ARG; /*!< SDMMC argument register, Address offset: 0x08 */
656 __IO uint32_t CMD; /*!< SDMMC command register, Address offset: 0x0C */
657 __I uint32_t RESPCMD; /*!< SDMMC command response register, Address offset: 0x10 */
658 __I uint32_t RESP1; /*!< SDMMC response 1 register, Address offset: 0x14 */
659 __I uint32_t RESP2; /*!< SDMMC response 2 register, Address offset: 0x18 */
660 __I uint32_t RESP3; /*!< SDMMC response 3 register, Address offset: 0x1C */
661 __I uint32_t RESP4; /*!< SDMMC response 4 register, Address offset: 0x20 */
662 __IO uint32_t DTIMER; /*!< SDMMC data timer register, Address offset: 0x24 */
663 __IO uint32_t DLEN; /*!< SDMMC data length register, Address offset: 0x28 */
664 __IO uint32_t DCTRL; /*!< SDMMC data control register, Address offset: 0x2C */
665 __I uint32_t DCOUNT; /*!< SDMMC data counter register, Address offset: 0x30 */
666 __I uint32_t STA; /*!< SDMMC status register, Address offset: 0x34 */
667 __IO uint32_t ICR; /*!< SDMMC interrupt clear register, Address offset: 0x38 */
668 __IO uint32_t MASK; /*!< SDMMC mask register, Address offset: 0x3C */
669 uint32_t RESERVED0[2]; /*!< Reserved, 0x40-0x44 */
670 __I uint32_t FIFOCNT; /*!< SDMMC FIFO counter register, Address offset: 0x48 */
671 uint32_t RESERVED1[13]; /*!< Reserved, 0x4C-0x7C */
672 __IO uint32_t FIFO; /*!< SDMMC data FIFO register, Address offset: 0x80 */
673} SDMMC_TypeDef;
674
675/**
676 * @brief Serial Peripheral Interface
677 */
678
679typedef struct
680{
681 __IO uint32_t CR1; /*!< SPI control register 1 (not used in I2S mode), Address offset: 0x00 */
682 __IO uint32_t CR2; /*!< SPI control register 2, Address offset: 0x04 */
683 __IO uint32_t SR; /*!< SPI status register, Address offset: 0x08 */
684 __IO uint32_t DR; /*!< SPI data register, Address offset: 0x0C */
685 __IO uint32_t CRCPR; /*!< SPI CRC polynomial register (not used in I2S mode), Address offset: 0x10 */
686 __IO uint32_t RXCRCR; /*!< SPI RX CRC register (not used in I2S mode), Address offset: 0x14 */
687 __IO uint32_t TXCRCR; /*!< SPI TX CRC register (not used in I2S mode), Address offset: 0x18 */
688 __IO uint32_t I2SCFGR; /*!< SPI_I2S configuration register, Address offset: 0x1C */
689 __IO uint32_t I2SPR; /*!< SPI_I2S prescaler register, Address offset: 0x20 */
690} SPI_TypeDef;
691
692/**
693 * @brief QUAD Serial Peripheral Interface
694 */
695
696typedef struct
697{
698 __IO uint32_t CR; /*!< QUADSPI Control register, Address offset: 0x00 */
699 __IO uint32_t DCR; /*!< QUADSPI Device Configuration register, Address offset: 0x04 */
700 __IO uint32_t SR; /*!< QUADSPI Status register, Address offset: 0x08 */
701 __IO uint32_t FCR; /*!< QUADSPI Flag Clear register, Address offset: 0x0C */
702 __IO uint32_t DLR; /*!< QUADSPI Data Length register, Address offset: 0x10 */
703 __IO uint32_t CCR; /*!< QUADSPI Communication Configuration register, Address offset: 0x14 */
704 __IO uint32_t AR; /*!< QUADSPI Address register, Address offset: 0x18 */
705 __IO uint32_t ABR; /*!< QUADSPI Alternate Bytes register, Address offset: 0x1C */
706 __IO uint32_t DR; /*!< QUADSPI Data register, Address offset: 0x20 */
707 __IO uint32_t PSMKR; /*!< QUADSPI Polling Status Mask register, Address offset: 0x24 */
708 __IO uint32_t PSMAR; /*!< QUADSPI Polling Status Match register, Address offset: 0x28 */
709 __IO uint32_t PIR; /*!< QUADSPI Polling Interval register, Address offset: 0x2C */
710 __IO uint32_t LPTR; /*!< QUADSPI Low Power Timeout register, Address offset: 0x30 */
711} QUADSPI_TypeDef;
712
713/**
714 * @brief TIM
715 */
716
717typedef struct
718{
719 __IO uint32_t CR1; /*!< TIM control register 1, Address offset: 0x00 */
720 __IO uint32_t CR2; /*!< TIM control register 2, Address offset: 0x04 */
721 __IO uint32_t SMCR; /*!< TIM slave mode control register, Address offset: 0x08 */
722 __IO uint32_t DIER; /*!< TIM DMA/interrupt enable register, Address offset: 0x0C */
723 __IO uint32_t SR; /*!< TIM status register, Address offset: 0x10 */
724 __IO uint32_t EGR; /*!< TIM event generation register, Address offset: 0x14 */
725 __IO uint32_t CCMR1; /*!< TIM capture/compare mode register 1, Address offset: 0x18 */
726 __IO uint32_t CCMR2; /*!< TIM capture/compare mode register 2, Address offset: 0x1C */
727 __IO uint32_t CCER; /*!< TIM capture/compare enable register, Address offset: 0x20 */
728 __IO uint32_t CNT; /*!< TIM counter register, Address offset: 0x24 */
729 __IO uint32_t PSC; /*!< TIM prescaler, Address offset: 0x28 */
730 __IO uint32_t ARR; /*!< TIM auto-reload register, Address offset: 0x2C */
731 __IO uint32_t RCR; /*!< TIM repetition counter register, Address offset: 0x30 */
732 __IO uint32_t CCR1; /*!< TIM capture/compare register 1, Address offset: 0x34 */
733 __IO uint32_t CCR2; /*!< TIM capture/compare register 2, Address offset: 0x38 */
734 __IO uint32_t CCR3; /*!< TIM capture/compare register 3, Address offset: 0x3C */
735 __IO uint32_t CCR4; /*!< TIM capture/compare register 4, Address offset: 0x40 */
736 __IO uint32_t BDTR; /*!< TIM break and dead-time register, Address offset: 0x44 */
737 __IO uint32_t DCR; /*!< TIM DMA control register, Address offset: 0x48 */
738 __IO uint32_t DMAR; /*!< TIM DMA address for full transfer, Address offset: 0x4C */
739 __IO uint32_t OR; /*!< TIM option register, Address offset: 0x50 */
740 __IO uint32_t CCMR3; /*!< TIM capture/compare mode register 3, Address offset: 0x54 */
741 __IO uint32_t CCR5; /*!< TIM capture/compare mode register5, Address offset: 0x58 */
742 __IO uint32_t CCR6; /*!< TIM capture/compare mode register6, Address offset: 0x5C */
743
744} TIM_TypeDef;
745
746/**
747 * @brief LPTIMIMER
748 */
749typedef struct
750{
751 __IO uint32_t ISR; /*!< LPTIM Interrupt and Status register, Address offset: 0x00 */
752 __IO uint32_t ICR; /*!< LPTIM Interrupt Clear register, Address offset: 0x04 */
753 __IO uint32_t IER; /*!< LPTIM Interrupt Enable register, Address offset: 0x08 */
754 __IO uint32_t CFGR; /*!< LPTIM Configuration register, Address offset: 0x0C */
755 __IO uint32_t CR; /*!< LPTIM Control register, Address offset: 0x10 */
756 __IO uint32_t CMP; /*!< LPTIM Compare register, Address offset: 0x14 */
757 __IO uint32_t ARR; /*!< LPTIM Autoreload register, Address offset: 0x18 */
758 __IO uint32_t CNT; /*!< LPTIM Counter register, Address offset: 0x1C */
759} LPTIM_TypeDef;
760
761
762/**
763 * @brief Universal Synchronous Asynchronous Receiver Transmitter
764 */
765
766typedef struct
767{
768 __IO uint32_t CR1; /*!< USART Control register 1, Address offset: 0x00 */
769 __IO uint32_t CR2; /*!< USART Control register 2, Address offset: 0x04 */
770 __IO uint32_t CR3; /*!< USART Control register 3, Address offset: 0x08 */
771 __IO uint32_t BRR; /*!< USART Baud rate register, Address offset: 0x0C */
772 __IO uint32_t GTPR; /*!< USART Guard time and prescaler register, Address offset: 0x10 */
773 __IO uint32_t RTOR; /*!< USART Receiver Time Out register, Address offset: 0x14 */
774 __IO uint32_t RQR; /*!< USART Request register, Address offset: 0x18 */
775 __IO uint32_t ISR; /*!< USART Interrupt and status register, Address offset: 0x1C */
776 __IO uint32_t ICR; /*!< USART Interrupt flag Clear register, Address offset: 0x20 */
777 __IO uint32_t RDR; /*!< USART Receive Data register, Address offset: 0x24 */
778 __IO uint32_t TDR; /*!< USART Transmit Data register, Address offset: 0x28 */
779} USART_TypeDef;
780
781
782/**
783 * @brief Window WATCHDOG
784 */
785
786typedef struct
787{
788 __IO uint32_t CR; /*!< WWDG Control register, Address offset: 0x00 */
789 __IO uint32_t CFR; /*!< WWDG Configuration register, Address offset: 0x04 */
790 __IO uint32_t SR; /*!< WWDG Status register, Address offset: 0x08 */
791} WWDG_TypeDef;
792
793
794/**
795 * @brief RNG
796 */
797
798typedef struct
799{
800 __IO uint32_t CR; /*!< RNG control register, Address offset: 0x00 */
801 __IO uint32_t SR; /*!< RNG status register, Address offset: 0x04 */
802 __IO uint32_t DR; /*!< RNG data register, Address offset: 0x08 */
803} RNG_TypeDef;
804
805/**
806 * @}
807 */
808
809/**
810 * @brief USB_OTG_Core_Registers
811 */
812typedef struct
813{
814 __IO uint32_t GOTGCTL; /*!< USB_OTG Control and Status Register 000h */
815 __IO uint32_t GOTGINT; /*!< USB_OTG Interrupt Register 004h */
816 __IO uint32_t GAHBCFG; /*!< Core AHB Configuration Register 008h */
817 __IO uint32_t GUSBCFG; /*!< Core USB Configuration Register 00Ch */
818 __IO uint32_t GRSTCTL; /*!< Core Reset Register 010h */
819 __IO uint32_t GINTSTS; /*!< Core Interrupt Register 014h */
820 __IO uint32_t GINTMSK; /*!< Core Interrupt Mask Register 018h */
821 __IO uint32_t GRXSTSR; /*!< Receive Sts Q Read Register 01Ch */
822 __IO uint32_t GRXSTSP; /*!< Receive Sts Q Read & POP Register 020h */
823 __IO uint32_t GRXFSIZ; /*!< Receive FIFO Size Register 024h */
824 __IO uint32_t DIEPTXF0_HNPTXFSIZ; /*!< EP0 / Non Periodic Tx FIFO Size Register 028h */
825 __IO uint32_t HNPTXSTS; /*!< Non Periodic Tx FIFO/Queue Sts reg 02Ch */
826 uint32_t Reserved30[2]; /*!< Reserved 030h */
827 __IO uint32_t GCCFG; /*!< General Purpose IO Register 038h */
828 __IO uint32_t CID; /*!< User ID Register 03Ch */
829 uint32_t Reserved5[3]; /*!< Reserved 040h-048h */
830 __IO uint32_t GHWCFG3; /*!< User HW config3 04Ch */
831 uint32_t Reserved6; /*!< Reserved 050h */
832 __IO uint32_t GLPMCFG; /*!< LPM Register 054h */
833 __IO uint32_t GPWRDN; /*!< Power Down Register 058h */
834 __IO uint32_t GDFIFOCFG; /*!< DFIFO Software Config Register 05Ch */
835 __IO uint32_t GADPCTL; /*!< ADP Timer, Control and Status Register 60Ch */
836 uint32_t Reserved43[39]; /*!< Reserved 058h-0FFh */
837 __IO uint32_t HPTXFSIZ; /*!< Host Periodic Tx FIFO Size Reg 100h */
838 __IO uint32_t DIEPTXF[0x0F]; /*!< dev Periodic Transmit FIFO */
839} USB_OTG_GlobalTypeDef;
840
841
842/**
843 * @brief USB_OTG_device_Registers
844 */
845typedef struct
846{
847 __IO uint32_t DCFG; /*!< dev Configuration Register 800h */
848 __IO uint32_t DCTL; /*!< dev Control Register 804h */
849 __IO uint32_t DSTS; /*!< dev Status Register (RO) 808h */
850 uint32_t Reserved0C; /*!< Reserved 80Ch */
851 __IO uint32_t DIEPMSK; /*!< dev IN Endpoint Mask 810h */
852 __IO uint32_t DOEPMSK; /*!< dev OUT Endpoint Mask 814h */
853 __IO uint32_t DAINT; /*!< dev All Endpoints Itr Reg 818h */
854 __IO uint32_t DAINTMSK; /*!< dev All Endpoints Itr Mask 81Ch */
855 uint32_t Reserved20; /*!< Reserved 820h */
856 uint32_t Reserved9; /*!< Reserved 824h */
857 __IO uint32_t DVBUSDIS; /*!< dev VBUS discharge Register 828h */
858 __IO uint32_t DVBUSPULSE; /*!< dev VBUS Pulse Register 82Ch */
859 __IO uint32_t DTHRCTL; /*!< dev threshold 830h */
860 __IO uint32_t DIEPEMPMSK; /*!< dev empty msk 834h */
861 __IO uint32_t DEACHINT; /*!< dedicated EP interrupt 838h */
862 __IO uint32_t DEACHMSK; /*!< dedicated EP msk 83Ch */
863 uint32_t Reserved40; /*!< dedicated EP mask 840h */
864 __IO uint32_t DINEP1MSK; /*!< dedicated EP mask 844h */
865 uint32_t Reserved44[15]; /*!< Reserved 844-87Ch */
866 __IO uint32_t DOUTEP1MSK; /*!< dedicated EP msk 884h */
867} USB_OTG_DeviceTypeDef;
868
869
870/**
871 * @brief USB_OTG_IN_Endpoint-Specific_Register
872 */
873typedef struct
874{
875 __IO uint32_t DIEPCTL; /*!< dev IN Endpoint Control Reg 900h + (ep_num * 20h) + 00h */
876 uint32_t Reserved04; /*!< Reserved 900h + (ep_num * 20h) + 04h */
877 __IO uint32_t DIEPINT; /*!< dev IN Endpoint Itr Reg 900h + (ep_num * 20h) + 08h */
878 uint32_t Reserved0C; /*!< Reserved 900h + (ep_num * 20h) + 0Ch */
879 __IO uint32_t DIEPTSIZ; /*!< IN Endpoint Txfer Size 900h + (ep_num * 20h) + 10h */
880 __IO uint32_t DIEPDMA; /*!< IN Endpoint DMA Address Reg 900h + (ep_num * 20h) + 14h */
881 __IO uint32_t DTXFSTS; /*!< IN Endpoint Tx FIFO Status Reg 900h + (ep_num * 20h) + 18h */
882 uint32_t Reserved18; /*!< Reserved 900h+(ep_num*20h)+1Ch-900h+ (ep_num * 20h) + 1Ch */
883} USB_OTG_INEndpointTypeDef;
884
885
886/**
887 * @brief USB_OTG_OUT_Endpoint-Specific_Registers
888 */
889typedef struct
890{
891 __IO uint32_t DOEPCTL; /*!< dev OUT Endpoint Control Reg B00h + (ep_num * 20h) + 00h */
892 uint32_t Reserved04; /*!< Reserved B00h + (ep_num * 20h) + 04h */
893 __IO uint32_t DOEPINT; /*!< dev OUT Endpoint Itr Reg B00h + (ep_num * 20h) + 08h */
894 uint32_t Reserved0C; /*!< Reserved B00h + (ep_num * 20h) + 0Ch */
895 __IO uint32_t DOEPTSIZ; /*!< dev OUT Endpoint Txfer Size B00h + (ep_num * 20h) + 10h */
896 __IO uint32_t DOEPDMA; /*!< dev OUT Endpoint DMA Address B00h + (ep_num * 20h) + 14h */
897 uint32_t Reserved18[2]; /*!< Reserved B00h + (ep_num * 20h) + 18h - B00h + (ep_num * 20h) + 1Ch */
898} USB_OTG_OUTEndpointTypeDef;
899
900
901/**
902 * @brief USB_OTG_Host_Mode_Register_Structures
903 */
904typedef struct
905{
906 __IO uint32_t HCFG; /*!< Host Configuration Register 400h */
907 __IO uint32_t HFIR; /*!< Host Frame Interval Register 404h */
908 __IO uint32_t HFNUM; /*!< Host Frame Nbr/Frame Remaining 408h */
909 uint32_t Reserved40C; /*!< Reserved 40Ch */
910 __IO uint32_t HPTXSTS; /*!< Host Periodic Tx FIFO/ Queue Status 410h */
911 __IO uint32_t HAINT; /*!< Host All Channels Interrupt Register 414h */
912 __IO uint32_t HAINTMSK; /*!< Host All Channels Interrupt Mask 418h */
913} USB_OTG_HostTypeDef;
914
915/**
916 * @brief USB_OTG_Host_Channel_Specific_Registers
917 */
918typedef struct
919{
920 __IO uint32_t HCCHAR; /*!< Host Channel Characteristics Register 500h */
921 __IO uint32_t HCSPLT; /*!< Host Channel Split Control Register 504h */
922 __IO uint32_t HCINT; /*!< Host Channel Interrupt Register 508h */
923 __IO uint32_t HCINTMSK; /*!< Host Channel Interrupt Mask Register 50Ch */
924 __IO uint32_t HCTSIZ; /*!< Host Channel Transfer Size Register 510h */
925 __IO uint32_t HCDMA; /*!< Host Channel DMA Address Register 514h */
926 uint32_t Reserved[2]; /*!< Reserved */
927} USB_OTG_HostChannelTypeDef;
928/**
929 * @}
930 */
931
932
933
934
935/** @addtogroup Peripheral_memory_map
936 * @{
937 */
938#define RAMITCM_BASE 0x00000000U /*!< Base address of : 16KB RAM reserved for CPU execution/instruction accessible over ITCM */
939#define FLASHITCM_BASE 0x00200000U /*!< Base address of : (up to 512 KB) embedded FLASH memory accessible over ITCM */
940#define FLASHAXI_BASE 0x08000000U /*!< Base address of : (up to 512 KB) embedded FLASH memory accessible over AXI */
941#define RAMDTCM_BASE 0x20000000U /*!< Base address of : 64KB system data RAM accessible over DTCM */
942#define PERIPH_BASE 0x40000000U /*!< Base address of : AHB/ABP Peripherals */
943#define BKPSRAM_BASE 0x40024000U /*!< Base address of : Backup SRAM(4 KB) */
944#define QSPI_BASE 0x90000000U /*!< Base address of : QSPI memories accessible over AXI */
945#define FMC_R_BASE 0xA0000000U /*!< Base address of : FMC Control registers */
946#define QSPI_R_BASE 0xA0001000U /*!< Base address of : QSPI Control registers */
947#define SRAM1_BASE 0x20010000U /*!< Base address of : 176KB RAM1 accessible over AXI/AHB */
948#define SRAM2_BASE 0x2003C000U /*!< Base address of : 16KB RAM2 accessible over AXI/AHB */
949#define FLASH_END 0x0807FFFFU /*!< FLASH end address */
950#define FLASH_OTP_BASE 0x1FF07800U /*!< Base address of : (up to 528 Bytes) embedded FLASH OTP Area */
951#define FLASH_OTP_END 0x1FF07A0FU /*!< End address of : (up to 528 Bytes) embedded FLASH OTP Area */
952
953/* Legacy define */
954#define FLASH_BASE FLASHAXI_BASE
955
956/*!< Peripheral memory map */
957#define APB1PERIPH_BASE PERIPH_BASE
958#define APB2PERIPH_BASE (PERIPH_BASE + 0x00010000U)
959#define AHB1PERIPH_BASE (PERIPH_BASE + 0x00020000U)
960#define AHB2PERIPH_BASE (PERIPH_BASE + 0x10000000U)
961
962/*!< APB1 peripherals */
963#define TIM2_BASE (APB1PERIPH_BASE + 0x0000U)
964#define TIM3_BASE (APB1PERIPH_BASE + 0x0400U)
965#define TIM4_BASE (APB1PERIPH_BASE + 0x0800U)
966#define TIM5_BASE (APB1PERIPH_BASE + 0x0C00U)
967#define TIM6_BASE (APB1PERIPH_BASE + 0x1000U)
968#define TIM7_BASE (APB1PERIPH_BASE + 0x1400U)
969#define TIM12_BASE (APB1PERIPH_BASE + 0x1800U)
970#define TIM13_BASE (APB1PERIPH_BASE + 0x1C00U)
971#define TIM14_BASE (APB1PERIPH_BASE + 0x2000U)
972#define LPTIM1_BASE (APB1PERIPH_BASE + 0x2400U)
973#define RTC_BASE (APB1PERIPH_BASE + 0x2800U)
974#define WWDG_BASE (APB1PERIPH_BASE + 0x2C00U)
975#define IWDG_BASE (APB1PERIPH_BASE + 0x3000U)
976#define SPI2_BASE (APB1PERIPH_BASE + 0x3800U)
977#define SPI3_BASE (APB1PERIPH_BASE + 0x3C00U)
978#define USART2_BASE (APB1PERIPH_BASE + 0x4400U)
979#define USART3_BASE (APB1PERIPH_BASE + 0x4800U)
980#define UART4_BASE (APB1PERIPH_BASE + 0x4C00U)
981#define UART5_BASE (APB1PERIPH_BASE + 0x5000U)
982#define I2C1_BASE (APB1PERIPH_BASE + 0x5400U)
983#define I2C2_BASE (APB1PERIPH_BASE + 0x5800U)
984#define I2C3_BASE (APB1PERIPH_BASE + 0x5C00U)
985#define CAN1_BASE (APB1PERIPH_BASE + 0x6400U)
986#define PWR_BASE (APB1PERIPH_BASE + 0x7000U)
987#define DAC_BASE (APB1PERIPH_BASE + 0x7400U)
988#define UART7_BASE (APB1PERIPH_BASE + 0x7800U)
989#define UART8_BASE (APB1PERIPH_BASE + 0x7C00U)
990
991/*!< APB2 peripherals */
992#define TIM1_BASE (APB2PERIPH_BASE + 0x0000U)
993#define TIM8_BASE (APB2PERIPH_BASE + 0x0400U)
994#define USART1_BASE (APB2PERIPH_BASE + 0x1000U)
995#define USART6_BASE (APB2PERIPH_BASE + 0x1400U)
996#define SDMMC2_BASE (APB2PERIPH_BASE + 0x1C00U)
997#define ADC1_BASE (APB2PERIPH_BASE + 0x2000U)
998#define ADC2_BASE (APB2PERIPH_BASE + 0x2100U)
999#define ADC3_BASE (APB2PERIPH_BASE + 0x2200U)
1000#define ADC_BASE (APB2PERIPH_BASE + 0x2300U)
1001#define SDMMC1_BASE (APB2PERIPH_BASE + 0x2C00U)
1002#define SPI1_BASE (APB2PERIPH_BASE + 0x3000U)
1003#define SPI4_BASE (APB2PERIPH_BASE + 0x3400U)
1004#define SYSCFG_BASE (APB2PERIPH_BASE + 0x3800U)
1005#define EXTI_BASE (APB2PERIPH_BASE + 0x3C00U)
1006#define TIM9_BASE (APB2PERIPH_BASE + 0x4000U)
1007#define TIM10_BASE (APB2PERIPH_BASE + 0x4400U)
1008#define TIM11_BASE (APB2PERIPH_BASE + 0x4800U)
1009#define SPI5_BASE (APB2PERIPH_BASE + 0x5000U)
1010#define SAI1_BASE (APB2PERIPH_BASE + 0x5800U)
1011#define SAI2_BASE (APB2PERIPH_BASE + 0x5C00U)
1012#define SAI1_Block_A_BASE (SAI1_BASE + 0x004U)
1013#define SAI1_Block_B_BASE (SAI1_BASE + 0x024U)
1014#define SAI2_Block_A_BASE (SAI2_BASE + 0x004U)
1015#define SAI2_Block_B_BASE (SAI2_BASE + 0x024U)
1016/*!< AHB1 peripherals */
1017#define GPIOA_BASE (AHB1PERIPH_BASE + 0x0000U)
1018#define GPIOB_BASE (AHB1PERIPH_BASE + 0x0400U)
1019#define GPIOC_BASE (AHB1PERIPH_BASE + 0x0800U)
1020#define GPIOD_BASE (AHB1PERIPH_BASE + 0x0C00U)
1021#define GPIOE_BASE (AHB1PERIPH_BASE + 0x1000U)
1022#define GPIOF_BASE (AHB1PERIPH_BASE + 0x1400U)
1023#define GPIOG_BASE (AHB1PERIPH_BASE + 0x1800U)
1024#define GPIOH_BASE (AHB1PERIPH_BASE + 0x1C00U)
1025#define GPIOI_BASE (AHB1PERIPH_BASE + 0x2000U)
1026#define CRC_BASE (AHB1PERIPH_BASE + 0x3000U)
1027#define RCC_BASE (AHB1PERIPH_BASE + 0x3800U)
1028#define FLASH_R_BASE (AHB1PERIPH_BASE + 0x3C00U)
1029#define UID_BASE 0x1FF0F420U /*!< Unique device ID register base address */
1030#define FLASHSIZE_BASE 0x1FF0F442U /*!< FLASH Size register base address */
1031#define PACKAGE_BASE 0x1FFF7BF0U /*!< Package size register base address */
1032/* Legacy define */
1033#define PACKAGESIZE_BASE PACKAGE_BASE
1034
1035#define DMA1_BASE (AHB1PERIPH_BASE + 0x6000U)
1036#define DMA1_Stream0_BASE (DMA1_BASE + 0x010U)
1037#define DMA1_Stream1_BASE (DMA1_BASE + 0x028U)
1038#define DMA1_Stream2_BASE (DMA1_BASE + 0x040U)
1039#define DMA1_Stream3_BASE (DMA1_BASE + 0x058U)
1040#define DMA1_Stream4_BASE (DMA1_BASE + 0x070U)
1041#define DMA1_Stream5_BASE (DMA1_BASE + 0x088U)
1042#define DMA1_Stream6_BASE (DMA1_BASE + 0x0A0U)
1043#define DMA1_Stream7_BASE (DMA1_BASE + 0x0B8U)
1044#define DMA2_BASE (AHB1PERIPH_BASE + 0x6400U)
1045#define DMA2_Stream0_BASE (DMA2_BASE + 0x010U)
1046#define DMA2_Stream1_BASE (DMA2_BASE + 0x028U)
1047#define DMA2_Stream2_BASE (DMA2_BASE + 0x040U)
1048#define DMA2_Stream3_BASE (DMA2_BASE + 0x058U)
1049#define DMA2_Stream4_BASE (DMA2_BASE + 0x070U)
1050#define DMA2_Stream5_BASE (DMA2_BASE + 0x088U)
1051#define DMA2_Stream6_BASE (DMA2_BASE + 0x0A0U)
1052#define DMA2_Stream7_BASE (DMA2_BASE + 0x0B8U)
1053/*!< AHB2 peripherals */
1054#define RNG_BASE (AHB2PERIPH_BASE + 0x60800U)
1055/*!< FMC Bankx registers base address */
1056#define FMC_Bank1_R_BASE (FMC_R_BASE + 0x0000U)
1057#define FMC_Bank1E_R_BASE (FMC_R_BASE + 0x0104U)
1058#define FMC_Bank3_R_BASE (FMC_R_BASE + 0x0080U)
1059#define FMC_Bank5_6_R_BASE (FMC_R_BASE + 0x0140U)
1060
1061/* Debug MCU registers base address */
1062#define DBGMCU_BASE 0xE0042000U
1063
1064/*!< USB registers base address */
1065#define USB_OTG_HS_PERIPH_BASE 0x40040000U
1066#define USB_OTG_FS_PERIPH_BASE 0x50000000U
1067
1068#define USB_OTG_GLOBAL_BASE 0x000U
1069#define USB_OTG_DEVICE_BASE 0x800U
1070#define USB_OTG_IN_ENDPOINT_BASE 0x900U
1071#define USB_OTG_OUT_ENDPOINT_BASE 0xB00U
1072#define USB_OTG_EP_REG_SIZE 0x20U
1073#define USB_OTG_HOST_BASE 0x400U
1074#define USB_OTG_HOST_PORT_BASE 0x440U
1075#define USB_OTG_HOST_CHANNEL_BASE 0x500U
1076#define USB_OTG_HOST_CHANNEL_SIZE 0x20U
1077#define USB_OTG_PCGCCTL_BASE 0xE00U
1078#define USB_OTG_FIFO_BASE 0x1000U
1079#define USB_OTG_FIFO_SIZE 0x1000U
1080
1081/**
1082 * @}
1083 */
1084
1085/** @addtogroup Peripheral_declaration
1086 * @{
1087 */
1088#define TIM2 ((TIM_TypeDef *) TIM2_BASE)
1089#define TIM3 ((TIM_TypeDef *) TIM3_BASE)
1090#define TIM4 ((TIM_TypeDef *) TIM4_BASE)
1091#define TIM5 ((TIM_TypeDef *) TIM5_BASE)
1092#define TIM6 ((TIM_TypeDef *) TIM6_BASE)
1093#define TIM7 ((TIM_TypeDef *) TIM7_BASE)
1094#define TIM12 ((TIM_TypeDef *) TIM12_BASE)
1095#define TIM13 ((TIM_TypeDef *) TIM13_BASE)
1096#define TIM14 ((TIM_TypeDef *) TIM14_BASE)
1097#define LPTIM1 ((LPTIM_TypeDef *) LPTIM1_BASE)
1098#define RTC ((RTC_TypeDef *) RTC_BASE)
1099#define WWDG ((WWDG_TypeDef *) WWDG_BASE)
1100#define IWDG ((IWDG_TypeDef *) IWDG_BASE)
1101#define SPI2 ((SPI_TypeDef *) SPI2_BASE)
1102#define SPI3 ((SPI_TypeDef *) SPI3_BASE)
1103#define USART2 ((USART_TypeDef *) USART2_BASE)
1104#define USART3 ((USART_TypeDef *) USART3_BASE)
1105#define UART4 ((USART_TypeDef *) UART4_BASE)
1106#define UART5 ((USART_TypeDef *) UART5_BASE)
1107#define I2C1 ((I2C_TypeDef *) I2C1_BASE)
1108#define I2C2 ((I2C_TypeDef *) I2C2_BASE)
1109#define I2C3 ((I2C_TypeDef *) I2C3_BASE)
1110#define CAN1 ((CAN_TypeDef *) CAN1_BASE)
1111#define PWR ((PWR_TypeDef *) PWR_BASE)
1112#define DAC1 ((DAC_TypeDef *) DAC_BASE)
1113#define DAC ((DAC_TypeDef *) DAC_BASE) /* Kept for legacy purpose */
1114#define UART7 ((USART_TypeDef *) UART7_BASE)
1115#define UART8 ((USART_TypeDef *) UART8_BASE)
1116#define TIM1 ((TIM_TypeDef *) TIM1_BASE)
1117#define TIM8 ((TIM_TypeDef *) TIM8_BASE)
1118#define USART1 ((USART_TypeDef *) USART1_BASE)
1119#define USART6 ((USART_TypeDef *) USART6_BASE)
1120#define ADC ((ADC_Common_TypeDef *) ADC_BASE)
1121#define ADC1 ((ADC_TypeDef *) ADC1_BASE)
1122#define ADC2 ((ADC_TypeDef *) ADC2_BASE)
1123#define ADC3 ((ADC_TypeDef *) ADC3_BASE)
1124#define ADC123_COMMON ((ADC_Common_TypeDef *) ADC_BASE)
1125#define SDMMC1 ((SDMMC_TypeDef *) SDMMC1_BASE)
1126#define SPI1 ((SPI_TypeDef *) SPI1_BASE)
1127#define SPI4 ((SPI_TypeDef *) SPI4_BASE)
1128#define SYSCFG ((SYSCFG_TypeDef *) SYSCFG_BASE)
1129#define EXTI ((EXTI_TypeDef *) EXTI_BASE)
1130#define TIM9 ((TIM_TypeDef *) TIM9_BASE)
1131#define TIM10 ((TIM_TypeDef *) TIM10_BASE)
1132#define TIM11 ((TIM_TypeDef *) TIM11_BASE)
1133#define SPI5 ((SPI_TypeDef *) SPI5_BASE)
1134#define SAI1 ((SAI_TypeDef *) SAI1_BASE)
1135#define SAI2 ((SAI_TypeDef *) SAI2_BASE)
1136#define SAI1_Block_A ((SAI_Block_TypeDef *)SAI1_Block_A_BASE)
1137#define SAI1_Block_B ((SAI_Block_TypeDef *)SAI1_Block_B_BASE)
1138#define SAI2_Block_A ((SAI_Block_TypeDef *)SAI2_Block_A_BASE)
1139#define SAI2_Block_B ((SAI_Block_TypeDef *)SAI2_Block_B_BASE)
1140#define GPIOA ((GPIO_TypeDef *) GPIOA_BASE)
1141#define GPIOB ((GPIO_TypeDef *) GPIOB_BASE)
1142#define GPIOC ((GPIO_TypeDef *) GPIOC_BASE)
1143#define GPIOD ((GPIO_TypeDef *) GPIOD_BASE)
1144#define GPIOE ((GPIO_TypeDef *) GPIOE_BASE)
1145#define GPIOF ((GPIO_TypeDef *) GPIOF_BASE)
1146#define GPIOG ((GPIO_TypeDef *) GPIOG_BASE)
1147#define GPIOH ((GPIO_TypeDef *) GPIOH_BASE)
1148#define GPIOI ((GPIO_TypeDef *) GPIOI_BASE)
1149#define CRC ((CRC_TypeDef *) CRC_BASE)
1150#define RCC ((RCC_TypeDef *) RCC_BASE)
1151#define FLASH ((FLASH_TypeDef *) FLASH_R_BASE)
1152#define DMA1 ((DMA_TypeDef *) DMA1_BASE)
1153#define DMA1_Stream0 ((DMA_Stream_TypeDef *) DMA1_Stream0_BASE)
1154#define DMA1_Stream1 ((DMA_Stream_TypeDef *) DMA1_Stream1_BASE)
1155#define DMA1_Stream2 ((DMA_Stream_TypeDef *) DMA1_Stream2_BASE)
1156#define DMA1_Stream3 ((DMA_Stream_TypeDef *) DMA1_Stream3_BASE)
1157#define DMA1_Stream4 ((DMA_Stream_TypeDef *) DMA1_Stream4_BASE)
1158#define DMA1_Stream5 ((DMA_Stream_TypeDef *) DMA1_Stream5_BASE)
1159#define DMA1_Stream6 ((DMA_Stream_TypeDef *) DMA1_Stream6_BASE)
1160#define DMA1_Stream7 ((DMA_Stream_TypeDef *) DMA1_Stream7_BASE)
1161#define DMA2 ((DMA_TypeDef *) DMA2_BASE)
1162#define DMA2_Stream0 ((DMA_Stream_TypeDef *) DMA2_Stream0_BASE)
1163#define DMA2_Stream1 ((DMA_Stream_TypeDef *) DMA2_Stream1_BASE)
1164#define DMA2_Stream2 ((DMA_Stream_TypeDef *) DMA2_Stream2_BASE)
1165#define DMA2_Stream3 ((DMA_Stream_TypeDef *) DMA2_Stream3_BASE)
1166#define DMA2_Stream4 ((DMA_Stream_TypeDef *) DMA2_Stream4_BASE)
1167#define DMA2_Stream5 ((DMA_Stream_TypeDef *) DMA2_Stream5_BASE)
1168#define DMA2_Stream6 ((DMA_Stream_TypeDef *) DMA2_Stream6_BASE)
1169#define DMA2_Stream7 ((DMA_Stream_TypeDef *) DMA2_Stream7_BASE)
1170#define RNG ((RNG_TypeDef *) RNG_BASE)
1171#define FMC_Bank1 ((FMC_Bank1_TypeDef *) FMC_Bank1_R_BASE)
1172#define FMC_Bank1E ((FMC_Bank1E_TypeDef *) FMC_Bank1E_R_BASE)
1173#define FMC_Bank3 ((FMC_Bank3_TypeDef *) FMC_Bank3_R_BASE)
1174#define FMC_Bank5_6 ((FMC_Bank5_6_TypeDef *) FMC_Bank5_6_R_BASE)
1175#define QUADSPI ((QUADSPI_TypeDef *) QSPI_R_BASE)
1176#define DBGMCU ((DBGMCU_TypeDef *) DBGMCU_BASE)
1177#define USB_OTG_FS ((USB_OTG_GlobalTypeDef *) USB_OTG_FS_PERIPH_BASE)
1178#define USB_OTG_HS ((USB_OTG_GlobalTypeDef *) USB_OTG_HS_PERIPH_BASE)
1179#define SDMMC2 ((SDMMC_TypeDef *) SDMMC2_BASE)
1180
1181/**
1182 * @}
1183 */
1184
1185/** @addtogroup Exported_constants
1186 * @{
1187 */
1188
1189 /** @addtogroup Peripheral_Registers_Bits_Definition
1190 * @{
1191 */
1192
1193/******************************************************************************/
1194/* Peripheral Registers_Bits_Definition */
1195/******************************************************************************/
1196
1197/******************************************************************************/
1198/* */
1199/* Analog to Digital Converter */
1200/* */
1201/******************************************************************************/
1202/******************** Bit definition for ADC_SR register ********************/
1203#define ADC_SR_AWD_Pos (0U)
1204#define ADC_SR_AWD_Msk (0x1U << ADC_SR_AWD_Pos) /*!< 0x00000001 */
1205#define ADC_SR_AWD ADC_SR_AWD_Msk /*!<Analog watchdog flag */
1206#define ADC_SR_EOC_Pos (1U)
1207#define ADC_SR_EOC_Msk (0x1U << ADC_SR_EOC_Pos) /*!< 0x00000002 */
1208#define ADC_SR_EOC ADC_SR_EOC_Msk /*!<End of conversion */
1209#define ADC_SR_JEOC_Pos (2U)
1210#define ADC_SR_JEOC_Msk (0x1U << ADC_SR_JEOC_Pos) /*!< 0x00000004 */
1211#define ADC_SR_JEOC ADC_SR_JEOC_Msk /*!<Injected channel end of conversion */
1212#define ADC_SR_JSTRT_Pos (3U)
1213#define ADC_SR_JSTRT_Msk (0x1U << ADC_SR_JSTRT_Pos) /*!< 0x00000008 */
1214#define ADC_SR_JSTRT ADC_SR_JSTRT_Msk /*!<Injected channel Start flag */
1215#define ADC_SR_STRT_Pos (4U)
1216#define ADC_SR_STRT_Msk (0x1U << ADC_SR_STRT_Pos) /*!< 0x00000010 */
1217#define ADC_SR_STRT ADC_SR_STRT_Msk /*!<Regular channel Start flag */
1218#define ADC_SR_OVR_Pos (5U)
1219#define ADC_SR_OVR_Msk (0x1U << ADC_SR_OVR_Pos) /*!< 0x00000020 */
1220#define ADC_SR_OVR ADC_SR_OVR_Msk /*!<Overrun flag */
1221
1222/******************* Bit definition for ADC_CR1 register ********************/
1223#define ADC_CR1_AWDCH_Pos (0U)
1224#define ADC_CR1_AWDCH_Msk (0x1FU << ADC_CR1_AWDCH_Pos) /*!< 0x0000001F */
1225#define ADC_CR1_AWDCH ADC_CR1_AWDCH_Msk /*!<AWDCH[4:0] bits (Analog watchdog channel select bits) */
1226#define ADC_CR1_AWDCH_0 (0x01U << ADC_CR1_AWDCH_Pos) /*!< 0x00000001 */
1227#define ADC_CR1_AWDCH_1 (0x02U << ADC_CR1_AWDCH_Pos) /*!< 0x00000002 */
1228#define ADC_CR1_AWDCH_2 (0x04U << ADC_CR1_AWDCH_Pos) /*!< 0x00000004 */
1229#define ADC_CR1_AWDCH_3 (0x08U << ADC_CR1_AWDCH_Pos) /*!< 0x00000008 */
1230#define ADC_CR1_AWDCH_4 (0x10U << ADC_CR1_AWDCH_Pos) /*!< 0x00000010 */
1231#define ADC_CR1_EOCIE_Pos (5U)
1232#define ADC_CR1_EOCIE_Msk (0x1U << ADC_CR1_EOCIE_Pos) /*!< 0x00000020 */
1233#define ADC_CR1_EOCIE ADC_CR1_EOCIE_Msk /*!<Interrupt enable for EOC */
1234#define ADC_CR1_AWDIE_Pos (6U)
1235#define ADC_CR1_AWDIE_Msk (0x1U << ADC_CR1_AWDIE_Pos) /*!< 0x00000040 */
1236#define ADC_CR1_AWDIE ADC_CR1_AWDIE_Msk /*!<AAnalog Watchdog interrupt enable */
1237#define ADC_CR1_JEOCIE_Pos (7U)
1238#define ADC_CR1_JEOCIE_Msk (0x1U << ADC_CR1_JEOCIE_Pos) /*!< 0x00000080 */
1239#define ADC_CR1_JEOCIE ADC_CR1_JEOCIE_Msk /*!<Interrupt enable for injected channels */
1240#define ADC_CR1_SCAN_Pos (8U)
1241#define ADC_CR1_SCAN_Msk (0x1U << ADC_CR1_SCAN_Pos) /*!< 0x00000100 */
1242#define ADC_CR1_SCAN ADC_CR1_SCAN_Msk /*!<Scan mode */
1243#define ADC_CR1_AWDSGL_Pos (9U)
1244#define ADC_CR1_AWDSGL_Msk (0x1U << ADC_CR1_AWDSGL_Pos) /*!< 0x00000200 */
1245#define ADC_CR1_AWDSGL ADC_CR1_AWDSGL_Msk /*!<Enable the watchdog on a single channel in scan mode */
1246#define ADC_CR1_JAUTO_Pos (10U)
1247#define ADC_CR1_JAUTO_Msk (0x1U << ADC_CR1_JAUTO_Pos) /*!< 0x00000400 */
1248#define ADC_CR1_JAUTO ADC_CR1_JAUTO_Msk /*!<Automatic injected group conversion */
1249#define ADC_CR1_DISCEN_Pos (11U)
1250#define ADC_CR1_DISCEN_Msk (0x1U << ADC_CR1_DISCEN_Pos) /*!< 0x00000800 */
1251#define ADC_CR1_DISCEN ADC_CR1_DISCEN_Msk /*!<Discontinuous mode on regular channels */
1252#define ADC_CR1_JDISCEN_Pos (12U)
1253#define ADC_CR1_JDISCEN_Msk (0x1U << ADC_CR1_JDISCEN_Pos) /*!< 0x00001000 */
1254#define ADC_CR1_JDISCEN ADC_CR1_JDISCEN_Msk /*!<Discontinuous mode on injected channels */
1255#define ADC_CR1_DISCNUM_Pos (13U)
1256#define ADC_CR1_DISCNUM_Msk (0x7U << ADC_CR1_DISCNUM_Pos) /*!< 0x0000E000 */
1257#define ADC_CR1_DISCNUM ADC_CR1_DISCNUM_Msk /*!<DISCNUM[2:0] bits (Discontinuous mode channel count) */
1258#define ADC_CR1_DISCNUM_0 (0x1U << ADC_CR1_DISCNUM_Pos) /*!< 0x00002000 */
1259#define ADC_CR1_DISCNUM_1 (0x2U << ADC_CR1_DISCNUM_Pos) /*!< 0x00004000 */
1260#define ADC_CR1_DISCNUM_2 (0x4U << ADC_CR1_DISCNUM_Pos) /*!< 0x00008000 */
1261#define ADC_CR1_JAWDEN_Pos (22U)
1262#define ADC_CR1_JAWDEN_Msk (0x1U << ADC_CR1_JAWDEN_Pos) /*!< 0x00400000 */
1263#define ADC_CR1_JAWDEN ADC_CR1_JAWDEN_Msk /*!<Analog watchdog enable on injected channels */
1264#define ADC_CR1_AWDEN_Pos (23U)
1265#define ADC_CR1_AWDEN_Msk (0x1U << ADC_CR1_AWDEN_Pos) /*!< 0x00800000 */
1266#define ADC_CR1_AWDEN ADC_CR1_AWDEN_Msk /*!<Analog watchdog enable on regular channels */
1267#define ADC_CR1_RES_Pos (24U)
1268#define ADC_CR1_RES_Msk (0x3U << ADC_CR1_RES_Pos) /*!< 0x03000000 */
1269#define ADC_CR1_RES ADC_CR1_RES_Msk /*!<RES[2:0] bits (Resolution) */
1270#define ADC_CR1_RES_0 (0x1U << ADC_CR1_RES_Pos) /*!< 0x01000000 */
1271#define ADC_CR1_RES_1 (0x2U << ADC_CR1_RES_Pos) /*!< 0x02000000 */
1272#define ADC_CR1_OVRIE_Pos (26U)
1273#define ADC_CR1_OVRIE_Msk (0x1U << ADC_CR1_OVRIE_Pos) /*!< 0x04000000 */
1274#define ADC_CR1_OVRIE ADC_CR1_OVRIE_Msk /*!<overrun interrupt enable */
1275
1276/******************* Bit definition for ADC_CR2 register ********************/
1277#define ADC_CR2_ADON_Pos (0U)
1278#define ADC_CR2_ADON_Msk (0x1U << ADC_CR2_ADON_Pos) /*!< 0x00000001 */
1279#define ADC_CR2_ADON ADC_CR2_ADON_Msk /*!<A/D Converter ON / OFF */
1280#define ADC_CR2_CONT_Pos (1U)
1281#define ADC_CR2_CONT_Msk (0x1U << ADC_CR2_CONT_Pos) /*!< 0x00000002 */
1282#define ADC_CR2_CONT ADC_CR2_CONT_Msk /*!<Continuous Conversion */
1283#define ADC_CR2_DMA_Pos (8U)
1284#define ADC_CR2_DMA_Msk (0x1U << ADC_CR2_DMA_Pos) /*!< 0x00000100 */
1285#define ADC_CR2_DMA ADC_CR2_DMA_Msk /*!<Direct Memory access mode */
1286#define ADC_CR2_DDS_Pos (9U)
1287#define ADC_CR2_DDS_Msk (0x1U << ADC_CR2_DDS_Pos) /*!< 0x00000200 */
1288#define ADC_CR2_DDS ADC_CR2_DDS_Msk /*!<DMA disable selection (Single ADC) */
1289#define ADC_CR2_EOCS_Pos (10U)
1290#define ADC_CR2_EOCS_Msk (0x1U << ADC_CR2_EOCS_Pos) /*!< 0x00000400 */
1291#define ADC_CR2_EOCS ADC_CR2_EOCS_Msk /*!<End of conversion selection */
1292#define ADC_CR2_ALIGN_Pos (11U)
1293#define ADC_CR2_ALIGN_Msk (0x1U << ADC_CR2_ALIGN_Pos) /*!< 0x00000800 */
1294#define ADC_CR2_ALIGN ADC_CR2_ALIGN_Msk /*!<Data Alignment */
1295#define ADC_CR2_JEXTSEL_Pos (16U)
1296#define ADC_CR2_JEXTSEL_Msk (0xFU << ADC_CR2_JEXTSEL_Pos) /*!< 0x000F0000 */
1297#define ADC_CR2_JEXTSEL ADC_CR2_JEXTSEL_Msk /*!<JEXTSEL[3:0] bits (External event select for injected group) */
1298#define ADC_CR2_JEXTSEL_0 (0x1U << ADC_CR2_JEXTSEL_Pos) /*!< 0x00010000 */
1299#define ADC_CR2_JEXTSEL_1 (0x2U << ADC_CR2_JEXTSEL_Pos) /*!< 0x00020000 */
1300#define ADC_CR2_JEXTSEL_2 (0x4U << ADC_CR2_JEXTSEL_Pos) /*!< 0x00040000 */
1301#define ADC_CR2_JEXTSEL_3 (0x8U << ADC_CR2_JEXTSEL_Pos) /*!< 0x00080000 */
1302#define ADC_CR2_JEXTEN_Pos (20U)
1303#define ADC_CR2_JEXTEN_Msk (0x3U << ADC_CR2_JEXTEN_Pos) /*!< 0x00300000 */
1304#define ADC_CR2_JEXTEN ADC_CR2_JEXTEN_Msk /*!<JEXTEN[1:0] bits (External Trigger Conversion mode for injected channelsp) */
1305#define ADC_CR2_JEXTEN_0 (0x1U << ADC_CR2_JEXTEN_Pos) /*!< 0x00100000 */
1306#define ADC_CR2_JEXTEN_1 (0x2U << ADC_CR2_JEXTEN_Pos) /*!< 0x00200000 */
1307#define ADC_CR2_JSWSTART_Pos (22U)
1308#define ADC_CR2_JSWSTART_Msk (0x1U << ADC_CR2_JSWSTART_Pos) /*!< 0x00400000 */
1309#define ADC_CR2_JSWSTART ADC_CR2_JSWSTART_Msk /*!<Start Conversion of injected channels */
1310#define ADC_CR2_EXTSEL_Pos (24U)
1311#define ADC_CR2_EXTSEL_Msk (0xFU << ADC_CR2_EXTSEL_Pos) /*!< 0x0F000000 */
1312#define ADC_CR2_EXTSEL ADC_CR2_EXTSEL_Msk /*!<EXTSEL[3:0] bits (External Event Select for regular group) */
1313#define ADC_CR2_EXTSEL_0 (0x1U << ADC_CR2_EXTSEL_Pos) /*!< 0x01000000 */
1314#define ADC_CR2_EXTSEL_1 (0x2U << ADC_CR2_EXTSEL_Pos) /*!< 0x02000000 */
1315#define ADC_CR2_EXTSEL_2 (0x4U << ADC_CR2_EXTSEL_Pos) /*!< 0x04000000 */
1316#define ADC_CR2_EXTSEL_3 (0x8U << ADC_CR2_EXTSEL_Pos) /*!< 0x08000000 */
1317#define ADC_CR2_EXTEN_Pos (28U)
1318#define ADC_CR2_EXTEN_Msk (0x3U << ADC_CR2_EXTEN_Pos) /*!< 0x30000000 */
1319#define ADC_CR2_EXTEN ADC_CR2_EXTEN_Msk /*!<EXTEN[1:0] bits (External Trigger Conversion mode for regular channelsp) */
1320#define ADC_CR2_EXTEN_0 (0x1U << ADC_CR2_EXTEN_Pos) /*!< 0x10000000 */
1321#define ADC_CR2_EXTEN_1 (0x2U << ADC_CR2_EXTEN_Pos) /*!< 0x20000000 */
1322#define ADC_CR2_SWSTART_Pos (30U)
1323#define ADC_CR2_SWSTART_Msk (0x1U << ADC_CR2_SWSTART_Pos) /*!< 0x40000000 */
1324#define ADC_CR2_SWSTART ADC_CR2_SWSTART_Msk /*!<Start Conversion of regular channels */
1325
1326/****************** Bit definition for ADC_SMPR1 register *******************/
1327#define ADC_SMPR1_SMP10_Pos (0U)
1328#define ADC_SMPR1_SMP10_Msk (0x7U << ADC_SMPR1_SMP10_Pos) /*!< 0x00000007 */
1329#define ADC_SMPR1_SMP10 ADC_SMPR1_SMP10_Msk /*!<SMP10[2:0] bits (Channel 10 Sample time selection) */
1330#define ADC_SMPR1_SMP10_0 (0x1U << ADC_SMPR1_SMP10_Pos) /*!< 0x00000001 */
1331#define ADC_SMPR1_SMP10_1 (0x2U << ADC_SMPR1_SMP10_Pos) /*!< 0x00000002 */
1332#define ADC_SMPR1_SMP10_2 (0x4U << ADC_SMPR1_SMP10_Pos) /*!< 0x00000004 */
1333#define ADC_SMPR1_SMP11_Pos (3U)
1334#define ADC_SMPR1_SMP11_Msk (0x7U << ADC_SMPR1_SMP11_Pos) /*!< 0x00000038 */
1335#define ADC_SMPR1_SMP11 ADC_SMPR1_SMP11_Msk /*!<SMP11[2:0] bits (Channel 11 Sample time selection) */
1336#define ADC_SMPR1_SMP11_0 (0x1U << ADC_SMPR1_SMP11_Pos) /*!< 0x00000008 */
1337#define ADC_SMPR1_SMP11_1 (0x2U << ADC_SMPR1_SMP11_Pos) /*!< 0x00000010 */
1338#define ADC_SMPR1_SMP11_2 (0x4U << ADC_SMPR1_SMP11_Pos) /*!< 0x00000020 */
1339#define ADC_SMPR1_SMP12_Pos (6U)
1340#define ADC_SMPR1_SMP12_Msk (0x7U << ADC_SMPR1_SMP12_Pos) /*!< 0x000001C0 */
1341#define ADC_SMPR1_SMP12 ADC_SMPR1_SMP12_Msk /*!<SMP12[2:0] bits (Channel 12 Sample time selection) */
1342#define ADC_SMPR1_SMP12_0 (0x1U << ADC_SMPR1_SMP12_Pos) /*!< 0x00000040 */
1343#define ADC_SMPR1_SMP12_1 (0x2U << ADC_SMPR1_SMP12_Pos) /*!< 0x00000080 */
1344#define ADC_SMPR1_SMP12_2 (0x4U << ADC_SMPR1_SMP12_Pos) /*!< 0x00000100 */
1345#define ADC_SMPR1_SMP13_Pos (9U)
1346#define ADC_SMPR1_SMP13_Msk (0x7U << ADC_SMPR1_SMP13_Pos) /*!< 0x00000E00 */
1347#define ADC_SMPR1_SMP13 ADC_SMPR1_SMP13_Msk /*!<SMP13[2:0] bits (Channel 13 Sample time selection) */
1348#define ADC_SMPR1_SMP13_0 (0x1U << ADC_SMPR1_SMP13_Pos) /*!< 0x00000200 */
1349#define ADC_SMPR1_SMP13_1 (0x2U << ADC_SMPR1_SMP13_Pos) /*!< 0x00000400 */
1350#define ADC_SMPR1_SMP13_2 (0x4U << ADC_SMPR1_SMP13_Pos) /*!< 0x00000800 */
1351#define ADC_SMPR1_SMP14_Pos (12U)
1352#define ADC_SMPR1_SMP14_Msk (0x7U << ADC_SMPR1_SMP14_Pos) /*!< 0x00007000 */
1353#define ADC_SMPR1_SMP14 ADC_SMPR1_SMP14_Msk /*!<SMP14[2:0] bits (Channel 14 Sample time selection) */
1354#define ADC_SMPR1_SMP14_0 (0x1U << ADC_SMPR1_SMP14_Pos) /*!< 0x00001000 */
1355#define ADC_SMPR1_SMP14_1 (0x2U << ADC_SMPR1_SMP14_Pos) /*!< 0x00002000 */
1356#define ADC_SMPR1_SMP14_2 (0x4U << ADC_SMPR1_SMP14_Pos) /*!< 0x00004000 */
1357#define ADC_SMPR1_SMP15_Pos (15U)
1358#define ADC_SMPR1_SMP15_Msk (0x7U << ADC_SMPR1_SMP15_Pos) /*!< 0x00038000 */
1359#define ADC_SMPR1_SMP15 ADC_SMPR1_SMP15_Msk /*!<SMP15[2:0] bits (Channel 15 Sample time selection) */
1360#define ADC_SMPR1_SMP15_0 (0x1U << ADC_SMPR1_SMP15_Pos) /*!< 0x00008000 */
1361#define ADC_SMPR1_SMP15_1 (0x2U << ADC_SMPR1_SMP15_Pos) /*!< 0x00010000 */
1362#define ADC_SMPR1_SMP15_2 (0x4U << ADC_SMPR1_SMP15_Pos) /*!< 0x00020000 */
1363#define ADC_SMPR1_SMP16_Pos (18U)
1364#define ADC_SMPR1_SMP16_Msk (0x7U << ADC_SMPR1_SMP16_Pos) /*!< 0x001C0000 */
1365#define ADC_SMPR1_SMP16 ADC_SMPR1_SMP16_Msk /*!<SMP16[2:0] bits (Channel 16 Sample time selection) */
1366#define ADC_SMPR1_SMP16_0 (0x1U << ADC_SMPR1_SMP16_Pos) /*!< 0x00040000 */
1367#define ADC_SMPR1_SMP16_1 (0x2U << ADC_SMPR1_SMP16_Pos) /*!< 0x00080000 */
1368#define ADC_SMPR1_SMP16_2 (0x4U << ADC_SMPR1_SMP16_Pos) /*!< 0x00100000 */
1369#define ADC_SMPR1_SMP17_Pos (21U)
1370#define ADC_SMPR1_SMP17_Msk (0x7U << ADC_SMPR1_SMP17_Pos) /*!< 0x00E00000 */
1371#define ADC_SMPR1_SMP17 ADC_SMPR1_SMP17_Msk /*!<SMP17[2:0] bits (Channel 17 Sample time selection) */
1372#define ADC_SMPR1_SMP17_0 (0x1U << ADC_SMPR1_SMP17_Pos) /*!< 0x00200000 */
1373#define ADC_SMPR1_SMP17_1 (0x2U << ADC_SMPR1_SMP17_Pos) /*!< 0x00400000 */
1374#define ADC_SMPR1_SMP17_2 (0x4U << ADC_SMPR1_SMP17_Pos) /*!< 0x00800000 */
1375#define ADC_SMPR1_SMP18_Pos (24U)
1376#define ADC_SMPR1_SMP18_Msk (0x7U << ADC_SMPR1_SMP18_Pos) /*!< 0x07000000 */
1377#define ADC_SMPR1_SMP18 ADC_SMPR1_SMP18_Msk /*!<SMP18[2:0] bits (Channel 18 Sample time selection) */
1378#define ADC_SMPR1_SMP18_0 (0x1U << ADC_SMPR1_SMP18_Pos) /*!< 0x01000000 */
1379#define ADC_SMPR1_SMP18_1 (0x2U << ADC_SMPR1_SMP18_Pos) /*!< 0x02000000 */
1380#define ADC_SMPR1_SMP18_2 (0x4U << ADC_SMPR1_SMP18_Pos) /*!< 0x04000000 */
1381
1382/****************** Bit definition for ADC_SMPR2 register *******************/
1383#define ADC_SMPR2_SMP0_Pos (0U)
1384#define ADC_SMPR2_SMP0_Msk (0x7U << ADC_SMPR2_SMP0_Pos) /*!< 0x00000007 */
1385#define ADC_SMPR2_SMP0 ADC_SMPR2_SMP0_Msk /*!<SMP0[2:0] bits (Channel 0 Sample time selection) */
1386#define ADC_SMPR2_SMP0_0 (0x1U << ADC_SMPR2_SMP0_Pos) /*!< 0x00000001 */
1387#define ADC_SMPR2_SMP0_1 (0x2U << ADC_SMPR2_SMP0_Pos) /*!< 0x00000002 */
1388#define ADC_SMPR2_SMP0_2 (0x4U << ADC_SMPR2_SMP0_Pos) /*!< 0x00000004 */
1389#define ADC_SMPR2_SMP1_Pos (3U)
1390#define ADC_SMPR2_SMP1_Msk (0x7U << ADC_SMPR2_SMP1_Pos) /*!< 0x00000038 */
1391#define ADC_SMPR2_SMP1 ADC_SMPR2_SMP1_Msk /*!<SMP1[2:0] bits (Channel 1 Sample time selection) */
1392#define ADC_SMPR2_SMP1_0 (0x1U << ADC_SMPR2_SMP1_Pos) /*!< 0x00000008 */
1393#define ADC_SMPR2_SMP1_1 (0x2U << ADC_SMPR2_SMP1_Pos) /*!< 0x00000010 */
1394#define ADC_SMPR2_SMP1_2 (0x4U << ADC_SMPR2_SMP1_Pos) /*!< 0x00000020 */
1395#define ADC_SMPR2_SMP2_Pos (6U)
1396#define ADC_SMPR2_SMP2_Msk (0x7U << ADC_SMPR2_SMP2_Pos) /*!< 0x000001C0 */
1397#define ADC_SMPR2_SMP2 ADC_SMPR2_SMP2_Msk /*!<SMP2[2:0] bits (Channel 2 Sample time selection) */
1398#define ADC_SMPR2_SMP2_0 (0x1U << ADC_SMPR2_SMP2_Pos) /*!< 0x00000040 */
1399#define ADC_SMPR2_SMP2_1 (0x2U << ADC_SMPR2_SMP2_Pos) /*!< 0x00000080 */
1400#define ADC_SMPR2_SMP2_2 (0x4U << ADC_SMPR2_SMP2_Pos) /*!< 0x00000100 */
1401#define ADC_SMPR2_SMP3_Pos (9U)
1402#define ADC_SMPR2_SMP3_Msk (0x7U << ADC_SMPR2_SMP3_Pos) /*!< 0x00000E00 */
1403#define ADC_SMPR2_SMP3 ADC_SMPR2_SMP3_Msk /*!<SMP3[2:0] bits (Channel 3 Sample time selection) */
1404#define ADC_SMPR2_SMP3_0 (0x1U << ADC_SMPR2_SMP3_Pos) /*!< 0x00000200 */
1405#define ADC_SMPR2_SMP3_1 (0x2U << ADC_SMPR2_SMP3_Pos) /*!< 0x00000400 */
1406#define ADC_SMPR2_SMP3_2 (0x4U << ADC_SMPR2_SMP3_Pos) /*!< 0x00000800 */
1407#define ADC_SMPR2_SMP4_Pos (12U)
1408#define ADC_SMPR2_SMP4_Msk (0x7U << ADC_SMPR2_SMP4_Pos) /*!< 0x00007000 */
1409#define ADC_SMPR2_SMP4 ADC_SMPR2_SMP4_Msk /*!<SMP4[2:0] bits (Channel 4 Sample time selection) */
1410#define ADC_SMPR2_SMP4_0 (0x1U << ADC_SMPR2_SMP4_Pos) /*!< 0x00001000 */
1411#define ADC_SMPR2_SMP4_1 (0x2U << ADC_SMPR2_SMP4_Pos) /*!< 0x00002000 */
1412#define ADC_SMPR2_SMP4_2 (0x4U << ADC_SMPR2_SMP4_Pos) /*!< 0x00004000 */
1413#define ADC_SMPR2_SMP5_Pos (15U)
1414#define ADC_SMPR2_SMP5_Msk (0x7U << ADC_SMPR2_SMP5_Pos) /*!< 0x00038000 */
1415#define ADC_SMPR2_SMP5 ADC_SMPR2_SMP5_Msk /*!<SMP5[2:0] bits (Channel 5 Sample time selection) */
1416#define ADC_SMPR2_SMP5_0 (0x1U << ADC_SMPR2_SMP5_Pos) /*!< 0x00008000 */
1417#define ADC_SMPR2_SMP5_1 (0x2U << ADC_SMPR2_SMP5_Pos) /*!< 0x00010000 */
1418#define ADC_SMPR2_SMP5_2 (0x4U << ADC_SMPR2_SMP5_Pos) /*!< 0x00020000 */
1419#define ADC_SMPR2_SMP6_Pos (18U)
1420#define ADC_SMPR2_SMP6_Msk (0x7U << ADC_SMPR2_SMP6_Pos) /*!< 0x001C0000 */
1421#define ADC_SMPR2_SMP6 ADC_SMPR2_SMP6_Msk /*!<SMP6[2:0] bits (Channel 6 Sample time selection) */
1422#define ADC_SMPR2_SMP6_0 (0x1U << ADC_SMPR2_SMP6_Pos) /*!< 0x00040000 */
1423#define ADC_SMPR2_SMP6_1 (0x2U << ADC_SMPR2_SMP6_Pos) /*!< 0x00080000 */
1424#define ADC_SMPR2_SMP6_2 (0x4U << ADC_SMPR2_SMP6_Pos) /*!< 0x00100000 */
1425#define ADC_SMPR2_SMP7_Pos (21U)
1426#define ADC_SMPR2_SMP7_Msk (0x7U << ADC_SMPR2_SMP7_Pos) /*!< 0x00E00000 */
1427#define ADC_SMPR2_SMP7 ADC_SMPR2_SMP7_Msk /*!<SMP7[2:0] bits (Channel 7 Sample time selection) */
1428#define ADC_SMPR2_SMP7_0 (0x1U << ADC_SMPR2_SMP7_Pos) /*!< 0x00200000 */
1429#define ADC_SMPR2_SMP7_1 (0x2U << ADC_SMPR2_SMP7_Pos) /*!< 0x00400000 */
1430#define ADC_SMPR2_SMP7_2 (0x4U << ADC_SMPR2_SMP7_Pos) /*!< 0x00800000 */
1431#define ADC_SMPR2_SMP8_Pos (24U)
1432#define ADC_SMPR2_SMP8_Msk (0x7U << ADC_SMPR2_SMP8_Pos) /*!< 0x07000000 */
1433#define ADC_SMPR2_SMP8 ADC_SMPR2_SMP8_Msk /*!<SMP8[2:0] bits (Channel 8 Sample time selection) */
1434#define ADC_SMPR2_SMP8_0 (0x1U << ADC_SMPR2_SMP8_Pos) /*!< 0x01000000 */
1435#define ADC_SMPR2_SMP8_1 (0x2U << ADC_SMPR2_SMP8_Pos) /*!< 0x02000000 */
1436#define ADC_SMPR2_SMP8_2 (0x4U << ADC_SMPR2_SMP8_Pos) /*!< 0x04000000 */
1437#define ADC_SMPR2_SMP9_Pos (27U)
1438#define ADC_SMPR2_SMP9_Msk (0x7U << ADC_SMPR2_SMP9_Pos) /*!< 0x38000000 */
1439#define ADC_SMPR2_SMP9 ADC_SMPR2_SMP9_Msk /*!<SMP9[2:0] bits (Channel 9 Sample time selection) */
1440#define ADC_SMPR2_SMP9_0 (0x1U << ADC_SMPR2_SMP9_Pos) /*!< 0x08000000 */
1441#define ADC_SMPR2_SMP9_1 (0x2U << ADC_SMPR2_SMP9_Pos) /*!< 0x10000000 */
1442#define ADC_SMPR2_SMP9_2 (0x4U << ADC_SMPR2_SMP9_Pos) /*!< 0x20000000 */
1443
1444/****************** Bit definition for ADC_JOFR1 register *******************/
1445#define ADC_JOFR1_JOFFSET1_Pos (0U)
1446#define ADC_JOFR1_JOFFSET1_Msk (0xFFFU << ADC_JOFR1_JOFFSET1_Pos) /*!< 0x00000FFF */
1447#define ADC_JOFR1_JOFFSET1 ADC_JOFR1_JOFFSET1_Msk /*!<Data offset for injected channel 1 */
1448
1449/****************** Bit definition for ADC_JOFR2 register *******************/
1450#define ADC_JOFR2_JOFFSET2_Pos (0U)
1451#define ADC_JOFR2_JOFFSET2_Msk (0xFFFU << ADC_JOFR2_JOFFSET2_Pos) /*!< 0x00000FFF */
1452#define ADC_JOFR2_JOFFSET2 ADC_JOFR2_JOFFSET2_Msk /*!<Data offset for injected channel 2 */
1453
1454/****************** Bit definition for ADC_JOFR3 register *******************/
1455#define ADC_JOFR3_JOFFSET3_Pos (0U)
1456#define ADC_JOFR3_JOFFSET3_Msk (0xFFFU << ADC_JOFR3_JOFFSET3_Pos) /*!< 0x00000FFF */
1457#define ADC_JOFR3_JOFFSET3 ADC_JOFR3_JOFFSET3_Msk /*!<Data offset for injected channel 3 */
1458
1459/****************** Bit definition for ADC_JOFR4 register *******************/
1460#define ADC_JOFR4_JOFFSET4_Pos (0U)
1461#define ADC_JOFR4_JOFFSET4_Msk (0xFFFU << ADC_JOFR4_JOFFSET4_Pos) /*!< 0x00000FFF */
1462#define ADC_JOFR4_JOFFSET4 ADC_JOFR4_JOFFSET4_Msk /*!<Data offset for injected channel 4 */
1463
1464/******************* Bit definition for ADC_HTR register ********************/
1465#define ADC_HTR_HT_Pos (0U)
1466#define ADC_HTR_HT_Msk (0xFFFU << ADC_HTR_HT_Pos) /*!< 0x00000FFF */
1467#define ADC_HTR_HT ADC_HTR_HT_Msk /*!<Analog watchdog high threshold */
1468
1469/******************* Bit definition for ADC_LTR register ********************/
1470#define ADC_LTR_LT_Pos (0U)
1471#define ADC_LTR_LT_Msk (0xFFFU << ADC_LTR_LT_Pos) /*!< 0x00000FFF */
1472#define ADC_LTR_LT ADC_LTR_LT_Msk /*!<Analog watchdog low threshold */
1473
1474/******************* Bit definition for ADC_SQR1 register *******************/
1475#define ADC_SQR1_SQ13_Pos (0U)
1476#define ADC_SQR1_SQ13_Msk (0x1FU << ADC_SQR1_SQ13_Pos) /*!< 0x0000001F */
1477#define ADC_SQR1_SQ13 ADC_SQR1_SQ13_Msk /*!<SQ13[4:0] bits (13th conversion in regular sequence) */
1478#define ADC_SQR1_SQ13_0 (0x01U << ADC_SQR1_SQ13_Pos) /*!< 0x00000001 */
1479#define ADC_SQR1_SQ13_1 (0x02U << ADC_SQR1_SQ13_Pos) /*!< 0x00000002 */
1480#define ADC_SQR1_SQ13_2 (0x04U << ADC_SQR1_SQ13_Pos) /*!< 0x00000004 */
1481#define ADC_SQR1_SQ13_3 (0x08U << ADC_SQR1_SQ13_Pos) /*!< 0x00000008 */
1482#define ADC_SQR1_SQ13_4 (0x10U << ADC_SQR1_SQ13_Pos) /*!< 0x00000010 */
1483#define ADC_SQR1_SQ14_Pos (5U)
1484#define ADC_SQR1_SQ14_Msk (0x1FU << ADC_SQR1_SQ14_Pos) /*!< 0x000003E0 */
1485#define ADC_SQR1_SQ14 ADC_SQR1_SQ14_Msk /*!<SQ14[4:0] bits (14th conversion in regular sequence) */
1486#define ADC_SQR1_SQ14_0 (0x01U << ADC_SQR1_SQ14_Pos) /*!< 0x00000020 */
1487#define ADC_SQR1_SQ14_1 (0x02U << ADC_SQR1_SQ14_Pos) /*!< 0x00000040 */
1488#define ADC_SQR1_SQ14_2 (0x04U << ADC_SQR1_SQ14_Pos) /*!< 0x00000080 */
1489#define ADC_SQR1_SQ14_3 (0x08U << ADC_SQR1_SQ14_Pos) /*!< 0x00000100 */
1490#define ADC_SQR1_SQ14_4 (0x10U << ADC_SQR1_SQ14_Pos) /*!< 0x00000200 */
1491#define ADC_SQR1_SQ15_Pos (10U)
1492#define ADC_SQR1_SQ15_Msk (0x1FU << ADC_SQR1_SQ15_Pos) /*!< 0x00007C00 */
1493#define ADC_SQR1_SQ15 ADC_SQR1_SQ15_Msk /*!<SQ15[4:0] bits (15th conversion in regular sequence) */
1494#define ADC_SQR1_SQ15_0 (0x01U << ADC_SQR1_SQ15_Pos) /*!< 0x00000400 */
1495#define ADC_SQR1_SQ15_1 (0x02U << ADC_SQR1_SQ15_Pos) /*!< 0x00000800 */
1496#define ADC_SQR1_SQ15_2 (0x04U << ADC_SQR1_SQ15_Pos) /*!< 0x00001000 */
1497#define ADC_SQR1_SQ15_3 (0x08U << ADC_SQR1_SQ15_Pos) /*!< 0x00002000 */
1498#define ADC_SQR1_SQ15_4 (0x10U << ADC_SQR1_SQ15_Pos) /*!< 0x00004000 */
1499#define ADC_SQR1_SQ16_Pos (15U)
1500#define ADC_SQR1_SQ16_Msk (0x1FU << ADC_SQR1_SQ16_Pos) /*!< 0x000F8000 */
1501#define ADC_SQR1_SQ16 ADC_SQR1_SQ16_Msk /*!<SQ16[4:0] bits (16th conversion in regular sequence) */
1502#define ADC_SQR1_SQ16_0 (0x01U << ADC_SQR1_SQ16_Pos) /*!< 0x00008000 */
1503#define ADC_SQR1_SQ16_1 (0x02U << ADC_SQR1_SQ16_Pos) /*!< 0x00010000 */
1504#define ADC_SQR1_SQ16_2 (0x04U << ADC_SQR1_SQ16_Pos) /*!< 0x00020000 */
1505#define ADC_SQR1_SQ16_3 (0x08U << ADC_SQR1_SQ16_Pos) /*!< 0x00040000 */
1506#define ADC_SQR1_SQ16_4 (0x10U << ADC_SQR1_SQ16_Pos) /*!< 0x00080000 */
1507#define ADC_SQR1_L_Pos (20U)
1508#define ADC_SQR1_L_Msk (0xFU << ADC_SQR1_L_Pos) /*!< 0x00F00000 */
1509#define ADC_SQR1_L ADC_SQR1_L_Msk /*!<L[3:0] bits (Regular channel sequence length) */
1510#define ADC_SQR1_L_0 (0x1U << ADC_SQR1_L_Pos) /*!< 0x00100000 */
1511#define ADC_SQR1_L_1 (0x2U << ADC_SQR1_L_Pos) /*!< 0x00200000 */
1512#define ADC_SQR1_L_2 (0x4U << ADC_SQR1_L_Pos) /*!< 0x00400000 */
1513#define ADC_SQR1_L_3 (0x8U << ADC_SQR1_L_Pos) /*!< 0x00800000 */
1514
1515/******************* Bit definition for ADC_SQR2 register *******************/
1516#define ADC_SQR2_SQ7_Pos (0U)
1517#define ADC_SQR2_SQ7_Msk (0x1FU << ADC_SQR2_SQ7_Pos) /*!< 0x0000001F */
1518#define ADC_SQR2_SQ7 ADC_SQR2_SQ7_Msk /*!<SQ7[4:0] bits (7th conversion in regular sequence) */
1519#define ADC_SQR2_SQ7_0 (0x01U << ADC_SQR2_SQ7_Pos) /*!< 0x00000001 */
1520#define ADC_SQR2_SQ7_1 (0x02U << ADC_SQR2_SQ7_Pos) /*!< 0x00000002 */
1521#define ADC_SQR2_SQ7_2 (0x04U << ADC_SQR2_SQ7_Pos) /*!< 0x00000004 */
1522#define ADC_SQR2_SQ7_3 (0x08U << ADC_SQR2_SQ7_Pos) /*!< 0x00000008 */
1523#define ADC_SQR2_SQ7_4 (0x10U << ADC_SQR2_SQ7_Pos) /*!< 0x00000010 */
1524#define ADC_SQR2_SQ8_Pos (5U)
1525#define ADC_SQR2_SQ8_Msk (0x1FU << ADC_SQR2_SQ8_Pos) /*!< 0x000003E0 */
1526#define ADC_SQR2_SQ8 ADC_SQR2_SQ8_Msk /*!<SQ8[4:0] bits (8th conversion in regular sequence) */
1527#define ADC_SQR2_SQ8_0 (0x01U << ADC_SQR2_SQ8_Pos) /*!< 0x00000020 */
1528#define ADC_SQR2_SQ8_1 (0x02U << ADC_SQR2_SQ8_Pos) /*!< 0x00000040 */
1529#define ADC_SQR2_SQ8_2 (0x04U << ADC_SQR2_SQ8_Pos) /*!< 0x00000080 */
1530#define ADC_SQR2_SQ8_3 (0x08U << ADC_SQR2_SQ8_Pos) /*!< 0x00000100 */
1531#define ADC_SQR2_SQ8_4 (0x10U << ADC_SQR2_SQ8_Pos) /*!< 0x00000200 */
1532#define ADC_SQR2_SQ9_Pos (10U)
1533#define ADC_SQR2_SQ9_Msk (0x1FU << ADC_SQR2_SQ9_Pos) /*!< 0x00007C00 */
1534#define ADC_SQR2_SQ9 ADC_SQR2_SQ9_Msk /*!<SQ9[4:0] bits (9th conversion in regular sequence) */
1535#define ADC_SQR2_SQ9_0 (0x01U << ADC_SQR2_SQ9_Pos) /*!< 0x00000400 */
1536#define ADC_SQR2_SQ9_1 (0x02U << ADC_SQR2_SQ9_Pos) /*!< 0x00000800 */
1537#define ADC_SQR2_SQ9_2 (0x04U << ADC_SQR2_SQ9_Pos) /*!< 0x00001000 */
1538#define ADC_SQR2_SQ9_3 (0x08U << ADC_SQR2_SQ9_Pos) /*!< 0x00002000 */
1539#define ADC_SQR2_SQ9_4 (0x10U << ADC_SQR2_SQ9_Pos) /*!< 0x00004000 */
1540#define ADC_SQR2_SQ10_Pos (15U)
1541#define ADC_SQR2_SQ10_Msk (0x1FU << ADC_SQR2_SQ10_Pos) /*!< 0x000F8000 */
1542#define ADC_SQR2_SQ10 ADC_SQR2_SQ10_Msk /*!<SQ10[4:0] bits (10th conversion in regular sequence) */
1543#define ADC_SQR2_SQ10_0 (0x01U << ADC_SQR2_SQ10_Pos) /*!< 0x00008000 */
1544#define ADC_SQR2_SQ10_1 (0x02U << ADC_SQR2_SQ10_Pos) /*!< 0x00010000 */
1545#define ADC_SQR2_SQ10_2 (0x04U << ADC_SQR2_SQ10_Pos) /*!< 0x00020000 */
1546#define ADC_SQR2_SQ10_3 (0x08U << ADC_SQR2_SQ10_Pos) /*!< 0x00040000 */
1547#define ADC_SQR2_SQ10_4 (0x10U << ADC_SQR2_SQ10_Pos) /*!< 0x00080000 */
1548#define ADC_SQR2_SQ11_Pos (20U)
1549#define ADC_SQR2_SQ11_Msk (0x1FU << ADC_SQR2_SQ11_Pos) /*!< 0x01F00000 */
1550#define ADC_SQR2_SQ11 ADC_SQR2_SQ11_Msk /*!<SQ11[4:0] bits (11th conversion in regular sequence) */
1551#define ADC_SQR2_SQ11_0 (0x01U << ADC_SQR2_SQ11_Pos) /*!< 0x00100000 */
1552#define ADC_SQR2_SQ11_1 (0x02U << ADC_SQR2_SQ11_Pos) /*!< 0x00200000 */
1553#define ADC_SQR2_SQ11_2 (0x04U << ADC_SQR2_SQ11_Pos) /*!< 0x00400000 */
1554#define ADC_SQR2_SQ11_3 (0x08U << ADC_SQR2_SQ11_Pos) /*!< 0x00800000 */
1555#define ADC_SQR2_SQ11_4 (0x10U << ADC_SQR2_SQ11_Pos) /*!< 0x01000000 */
1556#define ADC_SQR2_SQ12_Pos (25U)
1557#define ADC_SQR2_SQ12_Msk (0x1FU << ADC_SQR2_SQ12_Pos) /*!< 0x3E000000 */
1558#define ADC_SQR2_SQ12 ADC_SQR2_SQ12_Msk /*!<SQ12[4:0] bits (12th conversion in regular sequence) */
1559#define ADC_SQR2_SQ12_0 (0x01U << ADC_SQR2_SQ12_Pos) /*!< 0x02000000 */
1560#define ADC_SQR2_SQ12_1 (0x02U << ADC_SQR2_SQ12_Pos) /*!< 0x04000000 */
1561#define ADC_SQR2_SQ12_2 (0x04U << ADC_SQR2_SQ12_Pos) /*!< 0x08000000 */
1562#define ADC_SQR2_SQ12_3 (0x08U << ADC_SQR2_SQ12_Pos) /*!< 0x10000000 */
1563#define ADC_SQR2_SQ12_4 (0x10U << ADC_SQR2_SQ12_Pos) /*!< 0x20000000 */
1564
1565/******************* Bit definition for ADC_SQR3 register *******************/
1566#define ADC_SQR3_SQ1_Pos (0U)
1567#define ADC_SQR3_SQ1_Msk (0x1FU << ADC_SQR3_SQ1_Pos) /*!< 0x0000001F */
1568#define ADC_SQR3_SQ1 ADC_SQR3_SQ1_Msk /*!<SQ1[4:0] bits (1st conversion in regular sequence) */
1569#define ADC_SQR3_SQ1_0 (0x01U << ADC_SQR3_SQ1_Pos) /*!< 0x00000001 */
1570#define ADC_SQR3_SQ1_1 (0x02U << ADC_SQR3_SQ1_Pos) /*!< 0x00000002 */
1571#define ADC_SQR3_SQ1_2 (0x04U << ADC_SQR3_SQ1_Pos) /*!< 0x00000004 */
1572#define ADC_SQR3_SQ1_3 (0x08U << ADC_SQR3_SQ1_Pos) /*!< 0x00000008 */
1573#define ADC_SQR3_SQ1_4 (0x10U << ADC_SQR3_SQ1_Pos) /*!< 0x00000010 */
1574#define ADC_SQR3_SQ2_Pos (5U)
1575#define ADC_SQR3_SQ2_Msk (0x1FU << ADC_SQR3_SQ2_Pos) /*!< 0x000003E0 */
1576#define ADC_SQR3_SQ2 ADC_SQR3_SQ2_Msk /*!<SQ2[4:0] bits (2nd conversion in regular sequence) */
1577#define ADC_SQR3_SQ2_0 (0x01U << ADC_SQR3_SQ2_Pos) /*!< 0x00000020 */
1578#define ADC_SQR3_SQ2_1 (0x02U << ADC_SQR3_SQ2_Pos) /*!< 0x00000040 */
1579#define ADC_SQR3_SQ2_2 (0x04U << ADC_SQR3_SQ2_Pos) /*!< 0x00000080 */
1580#define ADC_SQR3_SQ2_3 (0x08U << ADC_SQR3_SQ2_Pos) /*!< 0x00000100 */
1581#define ADC_SQR3_SQ2_4 (0x10U << ADC_SQR3_SQ2_Pos) /*!< 0x00000200 */
1582#define ADC_SQR3_SQ3_Pos (10U)
1583#define ADC_SQR3_SQ3_Msk (0x1FU << ADC_SQR3_SQ3_Pos) /*!< 0x00007C00 */
1584#define ADC_SQR3_SQ3 ADC_SQR3_SQ3_Msk /*!<SQ3[4:0] bits (3rd conversion in regular sequence) */
1585#define ADC_SQR3_SQ3_0 (0x01U << ADC_SQR3_SQ3_Pos) /*!< 0x00000400 */
1586#define ADC_SQR3_SQ3_1 (0x02U << ADC_SQR3_SQ3_Pos) /*!< 0x00000800 */
1587#define ADC_SQR3_SQ3_2 (0x04U << ADC_SQR3_SQ3_Pos) /*!< 0x00001000 */
1588#define ADC_SQR3_SQ3_3 (0x08U << ADC_SQR3_SQ3_Pos) /*!< 0x00002000 */
1589#define ADC_SQR3_SQ3_4 (0x10U << ADC_SQR3_SQ3_Pos) /*!< 0x00004000 */
1590#define ADC_SQR3_SQ4_Pos (15U)
1591#define ADC_SQR3_SQ4_Msk (0x1FU << ADC_SQR3_SQ4_Pos) /*!< 0x000F8000 */
1592#define ADC_SQR3_SQ4 ADC_SQR3_SQ4_Msk /*!<SQ4[4:0] bits (4th conversion in regular sequence) */
1593#define ADC_SQR3_SQ4_0 (0x01U << ADC_SQR3_SQ4_Pos) /*!< 0x00008000 */
1594#define ADC_SQR3_SQ4_1 (0x02U << ADC_SQR3_SQ4_Pos) /*!< 0x00010000 */
1595#define ADC_SQR3_SQ4_2 (0x04U << ADC_SQR3_SQ4_Pos) /*!< 0x00020000 */
1596#define ADC_SQR3_SQ4_3 (0x08U << ADC_SQR3_SQ4_Pos) /*!< 0x00040000 */
1597#define ADC_SQR3_SQ4_4 (0x10U << ADC_SQR3_SQ4_Pos) /*!< 0x00080000 */
1598#define ADC_SQR3_SQ5_Pos (20U)
1599#define ADC_SQR3_SQ5_Msk (0x1FU << ADC_SQR3_SQ5_Pos) /*!< 0x01F00000 */
1600#define ADC_SQR3_SQ5 ADC_SQR3_SQ5_Msk /*!<SQ5[4:0] bits (5th conversion in regular sequence) */
1601#define ADC_SQR3_SQ5_0 (0x01U << ADC_SQR3_SQ5_Pos) /*!< 0x00100000 */
1602#define ADC_SQR3_SQ5_1 (0x02U << ADC_SQR3_SQ5_Pos) /*!< 0x00200000 */
1603#define ADC_SQR3_SQ5_2 (0x04U << ADC_SQR3_SQ5_Pos) /*!< 0x00400000 */
1604#define ADC_SQR3_SQ5_3 (0x08U << ADC_SQR3_SQ5_Pos) /*!< 0x00800000 */
1605#define ADC_SQR3_SQ5_4 (0x10U << ADC_SQR3_SQ5_Pos) /*!< 0x01000000 */
1606#define ADC_SQR3_SQ6_Pos (25U)
1607#define ADC_SQR3_SQ6_Msk (0x1FU << ADC_SQR3_SQ6_Pos) /*!< 0x3E000000 */
1608#define ADC_SQR3_SQ6 ADC_SQR3_SQ6_Msk /*!<SQ6[4:0] bits (6th conversion in regular sequence) */
1609#define ADC_SQR3_SQ6_0 (0x01U << ADC_SQR3_SQ6_Pos) /*!< 0x02000000 */
1610#define ADC_SQR3_SQ6_1 (0x02U << ADC_SQR3_SQ6_Pos) /*!< 0x04000000 */
1611#define ADC_SQR3_SQ6_2 (0x04U << ADC_SQR3_SQ6_Pos) /*!< 0x08000000 */
1612#define ADC_SQR3_SQ6_3 (0x08U << ADC_SQR3_SQ6_Pos) /*!< 0x10000000 */
1613#define ADC_SQR3_SQ6_4 (0x10U << ADC_SQR3_SQ6_Pos) /*!< 0x20000000 */
1614
1615/******************* Bit definition for ADC_JSQR register *******************/
1616#define ADC_JSQR_JSQ1_Pos (0U)
1617#define ADC_JSQR_JSQ1_Msk (0x1FU << ADC_JSQR_JSQ1_Pos) /*!< 0x0000001F */
1618#define ADC_JSQR_JSQ1 ADC_JSQR_JSQ1_Msk /*!<JSQ1[4:0] bits (1st conversion in injected sequence) */
1619#define ADC_JSQR_JSQ1_0 (0x01U << ADC_JSQR_JSQ1_Pos) /*!< 0x00000001 */
1620#define ADC_JSQR_JSQ1_1 (0x02U << ADC_JSQR_JSQ1_Pos) /*!< 0x00000002 */
1621#define ADC_JSQR_JSQ1_2 (0x04U << ADC_JSQR_JSQ1_Pos) /*!< 0x00000004 */
1622#define ADC_JSQR_JSQ1_3 (0x08U << ADC_JSQR_JSQ1_Pos) /*!< 0x00000008 */
1623#define ADC_JSQR_JSQ1_4 (0x10U << ADC_JSQR_JSQ1_Pos) /*!< 0x00000010 */
1624#define ADC_JSQR_JSQ2_Pos (5U)
1625#define ADC_JSQR_JSQ2_Msk (0x1FU << ADC_JSQR_JSQ2_Pos) /*!< 0x000003E0 */
1626#define ADC_JSQR_JSQ2 ADC_JSQR_JSQ2_Msk /*!<JSQ2[4:0] bits (2nd conversion in injected sequence) */
1627#define ADC_JSQR_JSQ2_0 (0x01U << ADC_JSQR_JSQ2_Pos) /*!< 0x00000020 */
1628#define ADC_JSQR_JSQ2_1 (0x02U << ADC_JSQR_JSQ2_Pos) /*!< 0x00000040 */
1629#define ADC_JSQR_JSQ2_2 (0x04U << ADC_JSQR_JSQ2_Pos) /*!< 0x00000080 */
1630#define ADC_JSQR_JSQ2_3 (0x08U << ADC_JSQR_JSQ2_Pos) /*!< 0x00000100 */
1631#define ADC_JSQR_JSQ2_4 (0x10U << ADC_JSQR_JSQ2_Pos) /*!< 0x00000200 */
1632#define ADC_JSQR_JSQ3_Pos (10U)
1633#define ADC_JSQR_JSQ3_Msk (0x1FU << ADC_JSQR_JSQ3_Pos) /*!< 0x00007C00 */
1634#define ADC_JSQR_JSQ3 ADC_JSQR_JSQ3_Msk /*!<JSQ3[4:0] bits (3rd conversion in injected sequence) */
1635#define ADC_JSQR_JSQ3_0 (0x01U << ADC_JSQR_JSQ3_Pos) /*!< 0x00000400 */
1636#define ADC_JSQR_JSQ3_1 (0x02U << ADC_JSQR_JSQ3_Pos) /*!< 0x00000800 */
1637#define ADC_JSQR_JSQ3_2 (0x04U << ADC_JSQR_JSQ3_Pos) /*!< 0x00001000 */
1638#define ADC_JSQR_JSQ3_3 (0x08U << ADC_JSQR_JSQ3_Pos) /*!< 0x00002000 */
1639#define ADC_JSQR_JSQ3_4 (0x10U << ADC_JSQR_JSQ3_Pos) /*!< 0x00004000 */
1640#define ADC_JSQR_JSQ4_Pos (15U)
1641#define ADC_JSQR_JSQ4_Msk (0x1FU << ADC_JSQR_JSQ4_Pos) /*!< 0x000F8000 */
1642#define ADC_JSQR_JSQ4 ADC_JSQR_JSQ4_Msk /*!<JSQ4[4:0] bits (4th conversion in injected sequence) */
1643#define ADC_JSQR_JSQ4_0 (0x01U << ADC_JSQR_JSQ4_Pos) /*!< 0x00008000 */
1644#define ADC_JSQR_JSQ4_1 (0x02U << ADC_JSQR_JSQ4_Pos) /*!< 0x00010000 */
1645#define ADC_JSQR_JSQ4_2 (0x04U << ADC_JSQR_JSQ4_Pos) /*!< 0x00020000 */
1646#define ADC_JSQR_JSQ4_3 (0x08U << ADC_JSQR_JSQ4_Pos) /*!< 0x00040000 */
1647#define ADC_JSQR_JSQ4_4 (0x10U << ADC_JSQR_JSQ4_Pos) /*!< 0x00080000 */
1648#define ADC_JSQR_JL_Pos (20U)
1649#define ADC_JSQR_JL_Msk (0x3U << ADC_JSQR_JL_Pos) /*!< 0x00300000 */
1650#define ADC_JSQR_JL ADC_JSQR_JL_Msk /*!<JL[1:0] bits (Injected Sequence length) */
1651#define ADC_JSQR_JL_0 (0x1U << ADC_JSQR_JL_Pos) /*!< 0x00100000 */
1652#define ADC_JSQR_JL_1 (0x2U << ADC_JSQR_JL_Pos) /*!< 0x00200000 */
1653
1654/******************* Bit definition for ADC_JDR1 register *******************/
1655#define ADC_JDR1_JDATA ((uint16_t)0xFFFFU) /*!<Injected data */
1656
1657/******************* Bit definition for ADC_JDR2 register *******************/
1658#define ADC_JDR2_JDATA ((uint16_t)0xFFFFU) /*!<Injected data */
1659
1660/******************* Bit definition for ADC_JDR3 register *******************/
1661#define ADC_JDR3_JDATA ((uint16_t)0xFFFFU) /*!<Injected data */
1662
1663/******************* Bit definition for ADC_JDR4 register *******************/
1664#define ADC_JDR4_JDATA ((uint16_t)0xFFFFU) /*!<Injected data */
1665
1666/******************** Bit definition for ADC_DR register ********************/
1667#define ADC_DR_DATA_Pos (0U)
1668#define ADC_DR_DATA_Msk (0xFFFFU << ADC_DR_DATA_Pos) /*!< 0x0000FFFF */
1669#define ADC_DR_DATA ADC_DR_DATA_Msk /*!<Regular data */
1670#define ADC_DR_ADC2DATA_Pos (16U)
1671#define ADC_DR_ADC2DATA_Msk (0xFFFFU << ADC_DR_ADC2DATA_Pos) /*!< 0xFFFF0000 */
1672#define ADC_DR_ADC2DATA ADC_DR_ADC2DATA_Msk /*!<ADC2 data */
1673
1674/******************* Bit definition for ADC_CSR register ********************/
1675#define ADC_CSR_AWD1_Pos (0U)
1676#define ADC_CSR_AWD1_Msk (0x1U << ADC_CSR_AWD1_Pos) /*!< 0x00000001 */
1677#define ADC_CSR_AWD1 ADC_CSR_AWD1_Msk /*!<ADC1 Analog watchdog flag */
1678#define ADC_CSR_EOC1_Pos (1U)
1679#define ADC_CSR_EOC1_Msk (0x1U << ADC_CSR_EOC1_Pos) /*!< 0x00000002 */
1680#define ADC_CSR_EOC1 ADC_CSR_EOC1_Msk /*!<ADC1 End of conversion */
1681#define ADC_CSR_JEOC1_Pos (2U)
1682#define ADC_CSR_JEOC1_Msk (0x1U << ADC_CSR_JEOC1_Pos) /*!< 0x00000004 */
1683#define ADC_CSR_JEOC1 ADC_CSR_JEOC1_Msk /*!<ADC1 Injected channel end of conversion */
1684#define ADC_CSR_JSTRT1_Pos (3U)
1685#define ADC_CSR_JSTRT1_Msk (0x1U << ADC_CSR_JSTRT1_Pos) /*!< 0x00000008 */
1686#define ADC_CSR_JSTRT1 ADC_CSR_JSTRT1_Msk /*!<ADC1 Injected channel Start flag */
1687#define ADC_CSR_STRT1_Pos (4U)
1688#define ADC_CSR_STRT1_Msk (0x1U << ADC_CSR_STRT1_Pos) /*!< 0x00000010 */
1689#define ADC_CSR_STRT1 ADC_CSR_STRT1_Msk /*!<ADC1 Regular channel Start flag */
1690#define ADC_CSR_OVR1_Pos (5U)
1691#define ADC_CSR_OVR1_Msk (0x1U << ADC_CSR_OVR1_Pos) /*!< 0x00000020 */
1692#define ADC_CSR_OVR1 ADC_CSR_OVR1_Msk /*!<ADC1 Overrun flag */
1693#define ADC_CSR_AWD2_Pos (8U)
1694#define ADC_CSR_AWD2_Msk (0x1U << ADC_CSR_AWD2_Pos) /*!< 0x00000100 */
1695#define ADC_CSR_AWD2 ADC_CSR_AWD2_Msk /*!<ADC2 Analog watchdog flag */
1696#define ADC_CSR_EOC2_Pos (9U)
1697#define ADC_CSR_EOC2_Msk (0x1U << ADC_CSR_EOC2_Pos) /*!< 0x00000200 */
1698#define ADC_CSR_EOC2 ADC_CSR_EOC2_Msk /*!<ADC2 End of conversion */
1699#define ADC_CSR_JEOC2_Pos (10U)
1700#define ADC_CSR_JEOC2_Msk (0x1U << ADC_CSR_JEOC2_Pos) /*!< 0x00000400 */
1701#define ADC_CSR_JEOC2 ADC_CSR_JEOC2_Msk /*!<ADC2 Injected channel end of conversion */
1702#define ADC_CSR_JSTRT2_Pos (11U)
1703#define ADC_CSR_JSTRT2_Msk (0x1U << ADC_CSR_JSTRT2_Pos) /*!< 0x00000800 */
1704#define ADC_CSR_JSTRT2 ADC_CSR_JSTRT2_Msk /*!<ADC2 Injected channel Start flag */
1705#define ADC_CSR_STRT2_Pos (12U)
1706#define ADC_CSR_STRT2_Msk (0x1U << ADC_CSR_STRT2_Pos) /*!< 0x00001000 */
1707#define ADC_CSR_STRT2 ADC_CSR_STRT2_Msk /*!<ADC2 Regular channel Start flag */
1708#define ADC_CSR_OVR2_Pos (13U)
1709#define ADC_CSR_OVR2_Msk (0x1U << ADC_CSR_OVR2_Pos) /*!< 0x00002000 */
1710#define ADC_CSR_OVR2 ADC_CSR_OVR2_Msk /*!<ADC2 Overrun flag */
1711#define ADC_CSR_AWD3_Pos (16U)
1712#define ADC_CSR_AWD3_Msk (0x1U << ADC_CSR_AWD3_Pos) /*!< 0x00010000 */
1713#define ADC_CSR_AWD3 ADC_CSR_AWD3_Msk /*!<ADC3 Analog watchdog flag */
1714#define ADC_CSR_EOC3_Pos (17U)
1715#define ADC_CSR_EOC3_Msk (0x1U << ADC_CSR_EOC3_Pos) /*!< 0x00020000 */
1716#define ADC_CSR_EOC3 ADC_CSR_EOC3_Msk /*!<ADC3 End of conversion */
1717#define ADC_CSR_JEOC3_Pos (18U)
1718#define ADC_CSR_JEOC3_Msk (0x1U << ADC_CSR_JEOC3_Pos) /*!< 0x00040000 */
1719#define ADC_CSR_JEOC3 ADC_CSR_JEOC3_Msk /*!<ADC3 Injected channel end of conversion */
1720#define ADC_CSR_JSTRT3_Pos (19U)
1721#define ADC_CSR_JSTRT3_Msk (0x1U << ADC_CSR_JSTRT3_Pos) /*!< 0x00080000 */
1722#define ADC_CSR_JSTRT3 ADC_CSR_JSTRT3_Msk /*!<ADC3 Injected channel Start flag */
1723#define ADC_CSR_STRT3_Pos (20U)
1724#define ADC_CSR_STRT3_Msk (0x1U << ADC_CSR_STRT3_Pos) /*!< 0x00100000 */
1725#define ADC_CSR_STRT3 ADC_CSR_STRT3_Msk /*!<ADC3 Regular channel Start flag */
1726#define ADC_CSR_OVR3_Pos (21U)
1727#define ADC_CSR_OVR3_Msk (0x1U << ADC_CSR_OVR3_Pos) /*!< 0x00200000 */
1728#define ADC_CSR_OVR3 ADC_CSR_OVR3_Msk /*!<ADC3 Overrun flag */
1729
1730/* Legacy defines */
1731#define ADC_CSR_DOVR1 ADC_CSR_OVR1
1732#define ADC_CSR_DOVR2 ADC_CSR_OVR2
1733#define ADC_CSR_DOVR3 ADC_CSR_OVR3
1734
1735
1736/******************* Bit definition for ADC_CCR register ********************/
1737#define ADC_CCR_MULTI_Pos (0U)
1738#define ADC_CCR_MULTI_Msk (0x1FU << ADC_CCR_MULTI_Pos) /*!< 0x0000001F */
1739#define ADC_CCR_MULTI ADC_CCR_MULTI_Msk /*!<MULTI[4:0] bits (Multi-ADC mode selection) */
1740#define ADC_CCR_MULTI_0 (0x01U << ADC_CCR_MULTI_Pos) /*!< 0x00000001 */
1741#define ADC_CCR_MULTI_1 (0x02U << ADC_CCR_MULTI_Pos) /*!< 0x00000002 */
1742#define ADC_CCR_MULTI_2 (0x04U << ADC_CCR_MULTI_Pos) /*!< 0x00000004 */
1743#define ADC_CCR_MULTI_3 (0x08U << ADC_CCR_MULTI_Pos) /*!< 0x00000008 */
1744#define ADC_CCR_MULTI_4 (0x10U << ADC_CCR_MULTI_Pos) /*!< 0x00000010 */
1745#define ADC_CCR_DELAY_Pos (8U)
1746#define ADC_CCR_DELAY_Msk (0xFU << ADC_CCR_DELAY_Pos) /*!< 0x00000F00 */
1747#define ADC_CCR_DELAY ADC_CCR_DELAY_Msk /*!<DELAY[3:0] bits (Delay between 2 sampling phases) */
1748#define ADC_CCR_DELAY_0 (0x1U << ADC_CCR_DELAY_Pos) /*!< 0x00000100 */
1749#define ADC_CCR_DELAY_1 (0x2U << ADC_CCR_DELAY_Pos) /*!< 0x00000200 */
1750#define ADC_CCR_DELAY_2 (0x4U << ADC_CCR_DELAY_Pos) /*!< 0x00000400 */
1751#define ADC_CCR_DELAY_3 (0x8U << ADC_CCR_DELAY_Pos) /*!< 0x00000800 */
1752#define ADC_CCR_DDS_Pos (13U)
1753#define ADC_CCR_DDS_Msk (0x1U << ADC_CCR_DDS_Pos) /*!< 0x00002000 */
1754#define ADC_CCR_DDS ADC_CCR_DDS_Msk /*!<DMA disable selection (Multi-ADC mode) */
1755#define ADC_CCR_DMA_Pos (14U)
1756#define ADC_CCR_DMA_Msk (0x3U << ADC_CCR_DMA_Pos) /*!< 0x0000C000 */
1757#define ADC_CCR_DMA ADC_CCR_DMA_Msk /*!<DMA[1:0] bits (Direct Memory Access mode for multimode) */
1758#define ADC_CCR_DMA_0 (0x1U << ADC_CCR_DMA_Pos) /*!< 0x00004000 */
1759#define ADC_CCR_DMA_1 (0x2U << ADC_CCR_DMA_Pos) /*!< 0x00008000 */
1760#define ADC_CCR_ADCPRE_Pos (16U)
1761#define ADC_CCR_ADCPRE_Msk (0x3U << ADC_CCR_ADCPRE_Pos) /*!< 0x00030000 */
1762#define ADC_CCR_ADCPRE ADC_CCR_ADCPRE_Msk /*!<ADCPRE[1:0] bits (ADC prescaler) */
1763#define ADC_CCR_ADCPRE_0 (0x1U << ADC_CCR_ADCPRE_Pos) /*!< 0x00010000 */
1764#define ADC_CCR_ADCPRE_1 (0x2U << ADC_CCR_ADCPRE_Pos) /*!< 0x00020000 */
1765#define ADC_CCR_VBATE_Pos (22U)
1766#define ADC_CCR_VBATE_Msk (0x1U << ADC_CCR_VBATE_Pos) /*!< 0x00400000 */
1767#define ADC_CCR_VBATE ADC_CCR_VBATE_Msk /*!<VBAT Enable */
1768#define ADC_CCR_TSVREFE_Pos (23U)
1769#define ADC_CCR_TSVREFE_Msk (0x1U << ADC_CCR_TSVREFE_Pos) /*!< 0x00800000 */
1770#define ADC_CCR_TSVREFE ADC_CCR_TSVREFE_Msk /*!<Temperature Sensor and VREFINT Enable */
1771
1772/******************* Bit definition for ADC_CDR register ********************/
1773#define ADC_CDR_DATA1_Pos (0U)
1774#define ADC_CDR_DATA1_Msk (0xFFFFU << ADC_CDR_DATA1_Pos) /*!< 0x0000FFFF */
1775#define ADC_CDR_DATA1 ADC_CDR_DATA1_Msk /*!<1st data of a pair of regular conversions */
1776#define ADC_CDR_DATA2_Pos (16U)
1777#define ADC_CDR_DATA2_Msk (0xFFFFU << ADC_CDR_DATA2_Pos) /*!< 0xFFFF0000 */
1778#define ADC_CDR_DATA2 ADC_CDR_DATA2_Msk /*!<2nd data of a pair of regular conversions */
1779
1780/* Legacy defines */
1781#define ADC_CDR_RDATA_MST ADC_CDR_DATA1
1782#define ADC_CDR_RDATA_SLV ADC_CDR_DATA2
1783
1784/******************************************************************************/
1785/* */
1786/* Controller Area Network */
1787/* */
1788/******************************************************************************/
1789/*!<CAN control and status registers */
1790/******************* Bit definition for CAN_MCR register ********************/
1791#define CAN_MCR_INRQ_Pos (0U)
1792#define CAN_MCR_INRQ_Msk (0x1U << CAN_MCR_INRQ_Pos) /*!< 0x00000001 */
1793#define CAN_MCR_INRQ CAN_MCR_INRQ_Msk /*!<Initialization Request */
1794#define CAN_MCR_SLEEP_Pos (1U)
1795#define CAN_MCR_SLEEP_Msk (0x1U << CAN_MCR_SLEEP_Pos) /*!< 0x00000002 */
1796#define CAN_MCR_SLEEP CAN_MCR_SLEEP_Msk /*!<Sleep Mode Request */
1797#define CAN_MCR_TXFP_Pos (2U)
1798#define CAN_MCR_TXFP_Msk (0x1U << CAN_MCR_TXFP_Pos) /*!< 0x00000004 */
1799#define CAN_MCR_TXFP CAN_MCR_TXFP_Msk /*!<Transmit FIFO Priority */
1800#define CAN_MCR_RFLM_Pos (3U)
1801#define CAN_MCR_RFLM_Msk (0x1U << CAN_MCR_RFLM_Pos) /*!< 0x00000008 */
1802#define CAN_MCR_RFLM CAN_MCR_RFLM_Msk /*!<Receive FIFO Locked Mode */
1803#define CAN_MCR_NART_Pos (4U)
1804#define CAN_MCR_NART_Msk (0x1U << CAN_MCR_NART_Pos) /*!< 0x00000010 */
1805#define CAN_MCR_NART CAN_MCR_NART_Msk /*!<No Automatic Retransmission */
1806#define CAN_MCR_AWUM_Pos (5U)
1807#define CAN_MCR_AWUM_Msk (0x1U << CAN_MCR_AWUM_Pos) /*!< 0x00000020 */
1808#define CAN_MCR_AWUM CAN_MCR_AWUM_Msk /*!<Automatic Wakeup Mode */
1809#define CAN_MCR_ABOM_Pos (6U)
1810#define CAN_MCR_ABOM_Msk (0x1U << CAN_MCR_ABOM_Pos) /*!< 0x00000040 */
1811#define CAN_MCR_ABOM CAN_MCR_ABOM_Msk /*!<Automatic Bus-Off Management */
1812#define CAN_MCR_TTCM_Pos (7U)
1813#define CAN_MCR_TTCM_Msk (0x1U << CAN_MCR_TTCM_Pos) /*!< 0x00000080 */
1814#define CAN_MCR_TTCM CAN_MCR_TTCM_Msk /*!<Time Triggered Communication Mode */
1815#define CAN_MCR_RESET_Pos (15U)
1816#define CAN_MCR_RESET_Msk (0x1U << CAN_MCR_RESET_Pos) /*!< 0x00008000 */
1817#define CAN_MCR_RESET CAN_MCR_RESET_Msk /*!<bxCAN software master reset */
1818
1819/******************* Bit definition for CAN_MSR register ********************/
1820#define CAN_MSR_INAK_Pos (0U)
1821#define CAN_MSR_INAK_Msk (0x1U << CAN_MSR_INAK_Pos) /*!< 0x00000001 */
1822#define CAN_MSR_INAK CAN_MSR_INAK_Msk /*!<Initialization Acknowledge */
1823#define CAN_MSR_SLAK_Pos (1U)
1824#define CAN_MSR_SLAK_Msk (0x1U << CAN_MSR_SLAK_Pos) /*!< 0x00000002 */
1825#define CAN_MSR_SLAK CAN_MSR_SLAK_Msk /*!<Sleep Acknowledge */
1826#define CAN_MSR_ERRI_Pos (2U)
1827#define CAN_MSR_ERRI_Msk (0x1U << CAN_MSR_ERRI_Pos) /*!< 0x00000004 */
1828#define CAN_MSR_ERRI CAN_MSR_ERRI_Msk /*!<Error Interrupt */
1829#define CAN_MSR_WKUI_Pos (3U)
1830#define CAN_MSR_WKUI_Msk (0x1U << CAN_MSR_WKUI_Pos) /*!< 0x00000008 */
1831#define CAN_MSR_WKUI CAN_MSR_WKUI_Msk /*!<Wakeup Interrupt */
1832#define CAN_MSR_SLAKI_Pos (4U)
1833#define CAN_MSR_SLAKI_Msk (0x1U << CAN_MSR_SLAKI_Pos) /*!< 0x00000010 */
1834#define CAN_MSR_SLAKI CAN_MSR_SLAKI_Msk /*!<Sleep Acknowledge Interrupt */
1835#define CAN_MSR_TXM_Pos (8U)
1836#define CAN_MSR_TXM_Msk (0x1U << CAN_MSR_TXM_Pos) /*!< 0x00000100 */
1837#define CAN_MSR_TXM CAN_MSR_TXM_Msk /*!<Transmit Mode */
1838#define CAN_MSR_RXM_Pos (9U)
1839#define CAN_MSR_RXM_Msk (0x1U << CAN_MSR_RXM_Pos) /*!< 0x00000200 */
1840#define CAN_MSR_RXM CAN_MSR_RXM_Msk /*!<Receive Mode */
1841#define CAN_MSR_SAMP_Pos (10U)
1842#define CAN_MSR_SAMP_Msk (0x1U << CAN_MSR_SAMP_Pos) /*!< 0x00000400 */
1843#define CAN_MSR_SAMP CAN_MSR_SAMP_Msk /*!<Last Sample Point */
1844#define CAN_MSR_RX_Pos (11U)
1845#define CAN_MSR_RX_Msk (0x1U << CAN_MSR_RX_Pos) /*!< 0x00000800 */
1846#define CAN_MSR_RX CAN_MSR_RX_Msk /*!<CAN Rx Signal */
1847
1848/******************* Bit definition for CAN_TSR register ********************/
1849#define CAN_TSR_RQCP0_Pos (0U)
1850#define CAN_TSR_RQCP0_Msk (0x1U << CAN_TSR_RQCP0_Pos) /*!< 0x00000001 */
1851#define CAN_TSR_RQCP0 CAN_TSR_RQCP0_Msk /*!<Request Completed Mailbox0 */
1852#define CAN_TSR_TXOK0_Pos (1U)
1853#define CAN_TSR_TXOK0_Msk (0x1U << CAN_TSR_TXOK0_Pos) /*!< 0x00000002 */
1854#define CAN_TSR_TXOK0 CAN_TSR_TXOK0_Msk /*!<Transmission OK of Mailbox0 */
1855#define CAN_TSR_ALST0_Pos (2U)
1856#define CAN_TSR_ALST0_Msk (0x1U << CAN_TSR_ALST0_Pos) /*!< 0x00000004 */
1857#define CAN_TSR_ALST0 CAN_TSR_ALST0_Msk /*!<Arbitration Lost for Mailbox0 */
1858#define CAN_TSR_TERR0_Pos (3U)
1859#define CAN_TSR_TERR0_Msk (0x1U << CAN_TSR_TERR0_Pos) /*!< 0x00000008 */
1860#define CAN_TSR_TERR0 CAN_TSR_TERR0_Msk /*!<Transmission Error of Mailbox0 */
1861#define CAN_TSR_ABRQ0_Pos (7U)
1862#define CAN_TSR_ABRQ0_Msk (0x1U << CAN_TSR_ABRQ0_Pos) /*!< 0x00000080 */
1863#define CAN_TSR_ABRQ0 CAN_TSR_ABRQ0_Msk /*!<Abort Request for Mailbox0 */
1864#define CAN_TSR_RQCP1_Pos (8U)
1865#define CAN_TSR_RQCP1_Msk (0x1U << CAN_TSR_RQCP1_Pos) /*!< 0x00000100 */
1866#define CAN_TSR_RQCP1 CAN_TSR_RQCP1_Msk /*!<Request Completed Mailbox1 */
1867#define CAN_TSR_TXOK1_Pos (9U)
1868#define CAN_TSR_TXOK1_Msk (0x1U << CAN_TSR_TXOK1_Pos) /*!< 0x00000200 */
1869#define CAN_TSR_TXOK1 CAN_TSR_TXOK1_Msk /*!<Transmission OK of Mailbox1 */
1870#define CAN_TSR_ALST1_Pos (10U)
1871#define CAN_TSR_ALST1_Msk (0x1U << CAN_TSR_ALST1_Pos) /*!< 0x00000400 */
1872#define CAN_TSR_ALST1 CAN_TSR_ALST1_Msk /*!<Arbitration Lost for Mailbox1 */
1873#define CAN_TSR_TERR1_Pos (11U)
1874#define CAN_TSR_TERR1_Msk (0x1U << CAN_TSR_TERR1_Pos) /*!< 0x00000800 */
1875#define CAN_TSR_TERR1 CAN_TSR_TERR1_Msk /*!<Transmission Error of Mailbox1 */
1876#define CAN_TSR_ABRQ1_Pos (15U)
1877#define CAN_TSR_ABRQ1_Msk (0x1U << CAN_TSR_ABRQ1_Pos) /*!< 0x00008000 */
1878#define CAN_TSR_ABRQ1 CAN_TSR_ABRQ1_Msk /*!<Abort Request for Mailbox 1 */
1879#define CAN_TSR_RQCP2_Pos (16U)
1880#define CAN_TSR_RQCP2_Msk (0x1U << CAN_TSR_RQCP2_Pos) /*!< 0x00010000 */
1881#define CAN_TSR_RQCP2 CAN_TSR_RQCP2_Msk /*!<Request Completed Mailbox2 */
1882#define CAN_TSR_TXOK2_Pos (17U)
1883#define CAN_TSR_TXOK2_Msk (0x1U << CAN_TSR_TXOK2_Pos) /*!< 0x00020000 */
1884#define CAN_TSR_TXOK2 CAN_TSR_TXOK2_Msk /*!<Transmission OK of Mailbox 2 */
1885#define CAN_TSR_ALST2_Pos (18U)
1886#define CAN_TSR_ALST2_Msk (0x1U << CAN_TSR_ALST2_Pos) /*!< 0x00040000 */
1887#define CAN_TSR_ALST2 CAN_TSR_ALST2_Msk /*!<Arbitration Lost for mailbox 2 */
1888#define CAN_TSR_TERR2_Pos (19U)
1889#define CAN_TSR_TERR2_Msk (0x1U << CAN_TSR_TERR2_Pos) /*!< 0x00080000 */
1890#define CAN_TSR_TERR2 CAN_TSR_TERR2_Msk /*!<Transmission Error of Mailbox 2 */
1891#define CAN_TSR_ABRQ2_Pos (23U)
1892#define CAN_TSR_ABRQ2_Msk (0x1U << CAN_TSR_ABRQ2_Pos) /*!< 0x00800000 */
1893#define CAN_TSR_ABRQ2 CAN_TSR_ABRQ2_Msk /*!<Abort Request for Mailbox 2 */
1894#define CAN_TSR_CODE_Pos (24U)
1895#define CAN_TSR_CODE_Msk (0x3U << CAN_TSR_CODE_Pos) /*!< 0x03000000 */
1896#define CAN_TSR_CODE CAN_TSR_CODE_Msk /*!<Mailbox Code */
1897
1898#define CAN_TSR_TME_Pos (26U)
1899#define CAN_TSR_TME_Msk (0x7U << CAN_TSR_TME_Pos) /*!< 0x1C000000 */
1900#define CAN_TSR_TME CAN_TSR_TME_Msk /*!<TME[2:0] bits */
1901#define CAN_TSR_TME0_Pos (26U)
1902#define CAN_TSR_TME0_Msk (0x1U << CAN_TSR_TME0_Pos) /*!< 0x04000000 */
1903#define CAN_TSR_TME0 CAN_TSR_TME0_Msk /*!<Transmit Mailbox 0 Empty */
1904#define CAN_TSR_TME1_Pos (27U)
1905#define CAN_TSR_TME1_Msk (0x1U << CAN_TSR_TME1_Pos) /*!< 0x08000000 */
1906#define CAN_TSR_TME1 CAN_TSR_TME1_Msk /*!<Transmit Mailbox 1 Empty */
1907#define CAN_TSR_TME2_Pos (28U)
1908#define CAN_TSR_TME2_Msk (0x1U << CAN_TSR_TME2_Pos) /*!< 0x10000000 */
1909#define CAN_TSR_TME2 CAN_TSR_TME2_Msk /*!<Transmit Mailbox 2 Empty */
1910
1911#define CAN_TSR_LOW_Pos (29U)
1912#define CAN_TSR_LOW_Msk (0x7U << CAN_TSR_LOW_Pos) /*!< 0xE0000000 */
1913#define CAN_TSR_LOW CAN_TSR_LOW_Msk /*!<LOW[2:0] bits */
1914#define CAN_TSR_LOW0_Pos (29U)
1915#define CAN_TSR_LOW0_Msk (0x1U << CAN_TSR_LOW0_Pos) /*!< 0x20000000 */
1916#define CAN_TSR_LOW0 CAN_TSR_LOW0_Msk /*!<Lowest Priority Flag for Mailbox 0 */
1917#define CAN_TSR_LOW1_Pos (30U)
1918#define CAN_TSR_LOW1_Msk (0x1U << CAN_TSR_LOW1_Pos) /*!< 0x40000000 */
1919#define CAN_TSR_LOW1 CAN_TSR_LOW1_Msk /*!<Lowest Priority Flag for Mailbox 1 */
1920#define CAN_TSR_LOW2_Pos (31U)
1921#define CAN_TSR_LOW2_Msk (0x1U << CAN_TSR_LOW2_Pos) /*!< 0x80000000 */
1922#define CAN_TSR_LOW2 CAN_TSR_LOW2_Msk /*!<Lowest Priority Flag for Mailbox 2 */
1923
1924/******************* Bit definition for CAN_RF0R register *******************/
1925#define CAN_RF0R_FMP0_Pos (0U)
1926#define CAN_RF0R_FMP0_Msk (0x3U << CAN_RF0R_FMP0_Pos) /*!< 0x00000003 */
1927#define CAN_RF0R_FMP0 CAN_RF0R_FMP0_Msk /*!<FIFO 0 Message Pending */
1928#define CAN_RF0R_FULL0_Pos (3U)
1929#define CAN_RF0R_FULL0_Msk (0x1U << CAN_RF0R_FULL0_Pos) /*!< 0x00000008 */
1930#define CAN_RF0R_FULL0 CAN_RF0R_FULL0_Msk /*!<FIFO 0 Full */
1931#define CAN_RF0R_FOVR0_Pos (4U)
1932#define CAN_RF0R_FOVR0_Msk (0x1U << CAN_RF0R_FOVR0_Pos) /*!< 0x00000010 */
1933#define CAN_RF0R_FOVR0 CAN_RF0R_FOVR0_Msk /*!<FIFO 0 Overrun */
1934#define CAN_RF0R_RFOM0_Pos (5U)
1935#define CAN_RF0R_RFOM0_Msk (0x1U << CAN_RF0R_RFOM0_Pos) /*!< 0x00000020 */
1936#define CAN_RF0R_RFOM0 CAN_RF0R_RFOM0_Msk /*!<Release FIFO 0 Output Mailbox */
1937
1938/******************* Bit definition for CAN_RF1R register *******************/
1939#define CAN_RF1R_FMP1_Pos (0U)
1940#define CAN_RF1R_FMP1_Msk (0x3U << CAN_RF1R_FMP1_Pos) /*!< 0x00000003 */
1941#define CAN_RF1R_FMP1 CAN_RF1R_FMP1_Msk /*!<FIFO 1 Message Pending */
1942#define CAN_RF1R_FULL1_Pos (3U)
1943#define CAN_RF1R_FULL1_Msk (0x1U << CAN_RF1R_FULL1_Pos) /*!< 0x00000008 */
1944#define CAN_RF1R_FULL1 CAN_RF1R_FULL1_Msk /*!<FIFO 1 Full */
1945#define CAN_RF1R_FOVR1_Pos (4U)
1946#define CAN_RF1R_FOVR1_Msk (0x1U << CAN_RF1R_FOVR1_Pos) /*!< 0x00000010 */
1947#define CAN_RF1R_FOVR1 CAN_RF1R_FOVR1_Msk /*!<FIFO 1 Overrun */
1948#define CAN_RF1R_RFOM1_Pos (5U)
1949#define CAN_RF1R_RFOM1_Msk (0x1U << CAN_RF1R_RFOM1_Pos) /*!< 0x00000020 */
1950#define CAN_RF1R_RFOM1 CAN_RF1R_RFOM1_Msk /*!<Release FIFO 1 Output Mailbox */
1951
1952/******************** Bit definition for CAN_IER register *******************/
1953#define CAN_IER_TMEIE_Pos (0U)
1954#define CAN_IER_TMEIE_Msk (0x1U << CAN_IER_TMEIE_Pos) /*!< 0x00000001 */
1955#define CAN_IER_TMEIE CAN_IER_TMEIE_Msk /*!<Transmit Mailbox Empty Interrupt Enable */
1956#define CAN_IER_FMPIE0_Pos (1U)
1957#define CAN_IER_FMPIE0_Msk (0x1U << CAN_IER_FMPIE0_Pos) /*!< 0x00000002 */
1958#define CAN_IER_FMPIE0 CAN_IER_FMPIE0_Msk /*!<FIFO Message Pending Interrupt Enable */
1959#define CAN_IER_FFIE0_Pos (2U)
1960#define CAN_IER_FFIE0_Msk (0x1U << CAN_IER_FFIE0_Pos) /*!< 0x00000004 */
1961#define CAN_IER_FFIE0 CAN_IER_FFIE0_Msk /*!<FIFO Full Interrupt Enable */
1962#define CAN_IER_FOVIE0_Pos (3U)
1963#define CAN_IER_FOVIE0_Msk (0x1U << CAN_IER_FOVIE0_Pos) /*!< 0x00000008 */
1964#define CAN_IER_FOVIE0 CAN_IER_FOVIE0_Msk /*!<FIFO Overrun Interrupt Enable */
1965#define CAN_IER_FMPIE1_Pos (4U)
1966#define CAN_IER_FMPIE1_Msk (0x1U << CAN_IER_FMPIE1_Pos) /*!< 0x00000010 */
1967#define CAN_IER_FMPIE1 CAN_IER_FMPIE1_Msk /*!<FIFO Message Pending Interrupt Enable */
1968#define CAN_IER_FFIE1_Pos (5U)
1969#define CAN_IER_FFIE1_Msk (0x1U << CAN_IER_FFIE1_Pos) /*!< 0x00000020 */
1970#define CAN_IER_FFIE1 CAN_IER_FFIE1_Msk /*!<FIFO Full Interrupt Enable */
1971#define CAN_IER_FOVIE1_Pos (6U)
1972#define CAN_IER_FOVIE1_Msk (0x1U << CAN_IER_FOVIE1_Pos) /*!< 0x00000040 */
1973#define CAN_IER_FOVIE1 CAN_IER_FOVIE1_Msk /*!<FIFO Overrun Interrupt Enable */
1974#define CAN_IER_EWGIE_Pos (8U)
1975#define CAN_IER_EWGIE_Msk (0x1U << CAN_IER_EWGIE_Pos) /*!< 0x00000100 */
1976#define CAN_IER_EWGIE CAN_IER_EWGIE_Msk /*!<Error Warning Interrupt Enable */
1977#define CAN_IER_EPVIE_Pos (9U)
1978#define CAN_IER_EPVIE_Msk (0x1U << CAN_IER_EPVIE_Pos) /*!< 0x00000200 */
1979#define CAN_IER_EPVIE CAN_IER_EPVIE_Msk /*!<Error Passive Interrupt Enable */
1980#define CAN_IER_BOFIE_Pos (10U)
1981#define CAN_IER_BOFIE_Msk (0x1U << CAN_IER_BOFIE_Pos) /*!< 0x00000400 */
1982#define CAN_IER_BOFIE CAN_IER_BOFIE_Msk /*!<Bus-Off Interrupt Enable */
1983#define CAN_IER_LECIE_Pos (11U)
1984#define CAN_IER_LECIE_Msk (0x1U << CAN_IER_LECIE_Pos) /*!< 0x00000800 */
1985#define CAN_IER_LECIE CAN_IER_LECIE_Msk /*!<Last Error Code Interrupt Enable */
1986#define CAN_IER_ERRIE_Pos (15U)
1987#define CAN_IER_ERRIE_Msk (0x1U << CAN_IER_ERRIE_Pos) /*!< 0x00008000 */
1988#define CAN_IER_ERRIE CAN_IER_ERRIE_Msk /*!<Error Interrupt Enable */
1989#define CAN_IER_WKUIE_Pos (16U)
1990#define CAN_IER_WKUIE_Msk (0x1U << CAN_IER_WKUIE_Pos) /*!< 0x00010000 */
1991#define CAN_IER_WKUIE CAN_IER_WKUIE_Msk /*!<Wakeup Interrupt Enable */
1992#define CAN_IER_SLKIE_Pos (17U)
1993#define CAN_IER_SLKIE_Msk (0x1U << CAN_IER_SLKIE_Pos) /*!< 0x00020000 */
1994#define CAN_IER_SLKIE CAN_IER_SLKIE_Msk /*!<Sleep Interrupt Enable */
1995
1996/******************** Bit definition for CAN_ESR register *******************/
1997#define CAN_ESR_EWGF_Pos (0U)
1998#define CAN_ESR_EWGF_Msk (0x1U << CAN_ESR_EWGF_Pos) /*!< 0x00000001 */
1999#define CAN_ESR_EWGF CAN_ESR_EWGF_Msk /*!<Error Warning Flag */
2000#define CAN_ESR_EPVF_Pos (1U)
2001#define CAN_ESR_EPVF_Msk (0x1U << CAN_ESR_EPVF_Pos) /*!< 0x00000002 */
2002#define CAN_ESR_EPVF CAN_ESR_EPVF_Msk /*!<Error Passive Flag */
2003#define CAN_ESR_BOFF_Pos (2U)
2004#define CAN_ESR_BOFF_Msk (0x1U << CAN_ESR_BOFF_Pos) /*!< 0x00000004 */
2005#define CAN_ESR_BOFF CAN_ESR_BOFF_Msk /*!<Bus-Off Flag */
2006
2007#define CAN_ESR_LEC_Pos (4U)
2008#define CAN_ESR_LEC_Msk (0x7U << CAN_ESR_LEC_Pos) /*!< 0x00000070 */
2009#define CAN_ESR_LEC CAN_ESR_LEC_Msk /*!<LEC[2:0] bits (Last Error Code) */
2010#define CAN_ESR_LEC_0 (0x1U << CAN_ESR_LEC_Pos) /*!< 0x00000010 */
2011#define CAN_ESR_LEC_1 (0x2U << CAN_ESR_LEC_Pos) /*!< 0x00000020 */
2012#define CAN_ESR_LEC_2 (0x4U << CAN_ESR_LEC_Pos) /*!< 0x00000040 */
2013
2014#define CAN_ESR_TEC_Pos (16U)
2015#define CAN_ESR_TEC_Msk (0xFFU << CAN_ESR_TEC_Pos) /*!< 0x00FF0000 */
2016#define CAN_ESR_TEC CAN_ESR_TEC_Msk /*!<Least significant byte of the 9-bit Transmit Error Counter */
2017#define CAN_ESR_REC_Pos (24U)
2018#define CAN_ESR_REC_Msk (0xFFU << CAN_ESR_REC_Pos) /*!< 0xFF000000 */
2019#define CAN_ESR_REC CAN_ESR_REC_Msk /*!<Receive Error Counter */
2020
2021/******************* Bit definition for CAN_BTR register ********************/
2022#define CAN_BTR_BRP_Pos (0U)
2023#define CAN_BTR_BRP_Msk (0x3FFU << CAN_BTR_BRP_Pos) /*!< 0x000003FF */
2024#define CAN_BTR_BRP CAN_BTR_BRP_Msk /*!<Baud Rate Prescaler */
2025#define CAN_BTR_TS1_Pos (16U)
2026#define CAN_BTR_TS1_Msk (0xFU << CAN_BTR_TS1_Pos) /*!< 0x000F0000 */
2027#define CAN_BTR_TS1 CAN_BTR_TS1_Msk /*!<Time Segment 1 */
2028#define CAN_BTR_TS1_0 (0x1U << CAN_BTR_TS1_Pos) /*!< 0x00010000 */
2029#define CAN_BTR_TS1_1 (0x2U << CAN_BTR_TS1_Pos) /*!< 0x00020000 */
2030#define CAN_BTR_TS1_2 (0x4U << CAN_BTR_TS1_Pos) /*!< 0x00040000 */
2031#define CAN_BTR_TS1_3 (0x8U << CAN_BTR_TS1_Pos) /*!< 0x00080000 */
2032#define CAN_BTR_TS2_Pos (20U)
2033#define CAN_BTR_TS2_Msk (0x7U << CAN_BTR_TS2_Pos) /*!< 0x00700000 */
2034#define CAN_BTR_TS2 CAN_BTR_TS2_Msk /*!<Time Segment 2 */
2035#define CAN_BTR_TS2_0 (0x1U << CAN_BTR_TS2_Pos) /*!< 0x00100000 */
2036#define CAN_BTR_TS2_1 (0x2U << CAN_BTR_TS2_Pos) /*!< 0x00200000 */
2037#define CAN_BTR_TS2_2 (0x4U << CAN_BTR_TS2_Pos) /*!< 0x00400000 */
2038#define CAN_BTR_SJW_Pos (24U)
2039#define CAN_BTR_SJW_Msk (0x3U << CAN_BTR_SJW_Pos) /*!< 0x03000000 */
2040#define CAN_BTR_SJW CAN_BTR_SJW_Msk /*!<Resynchronization Jump Width */
2041#define CAN_BTR_SJW_0 (0x1U << CAN_BTR_SJW_Pos) /*!< 0x01000000 */
2042#define CAN_BTR_SJW_1 (0x2U << CAN_BTR_SJW_Pos) /*!< 0x02000000 */
2043#define CAN_BTR_LBKM_Pos (30U)
2044#define CAN_BTR_LBKM_Msk (0x1U << CAN_BTR_LBKM_Pos) /*!< 0x40000000 */
2045#define CAN_BTR_LBKM CAN_BTR_LBKM_Msk /*!<Loop Back Mode (Debug) */
2046#define CAN_BTR_SILM_Pos (31U)
2047#define CAN_BTR_SILM_Msk (0x1U << CAN_BTR_SILM_Pos) /*!< 0x80000000 */
2048#define CAN_BTR_SILM CAN_BTR_SILM_Msk /*!<Silent Mode */
2049
2050/*!<Mailbox registers */
2051/****************** Bit definition for CAN_TI0R register ********************/
2052#define CAN_TI0R_TXRQ_Pos (0U)
2053#define CAN_TI0R_TXRQ_Msk (0x1U << CAN_TI0R_TXRQ_Pos) /*!< 0x00000001 */
2054#define CAN_TI0R_TXRQ CAN_TI0R_TXRQ_Msk /*!<Transmit Mailbox Request */
2055#define CAN_TI0R_RTR_Pos (1U)
2056#define CAN_TI0R_RTR_Msk (0x1U << CAN_TI0R_RTR_Pos) /*!< 0x00000002 */
2057#define CAN_TI0R_RTR CAN_TI0R_RTR_Msk /*!<Remote Transmission Request */
2058#define CAN_TI0R_IDE_Pos (2U)
2059#define CAN_TI0R_IDE_Msk (0x1U << CAN_TI0R_IDE_Pos) /*!< 0x00000004 */
2060#define CAN_TI0R_IDE CAN_TI0R_IDE_Msk /*!<Identifier Extension */
2061#define CAN_TI0R_EXID_Pos (3U)
2062#define CAN_TI0R_EXID_Msk (0x3FFFFU << CAN_TI0R_EXID_Pos) /*!< 0x001FFFF8 */
2063#define CAN_TI0R_EXID CAN_TI0R_EXID_Msk /*!<Extended Identifier */
2064#define CAN_TI0R_STID_Pos (21U)
2065#define CAN_TI0R_STID_Msk (0x7FFU << CAN_TI0R_STID_Pos) /*!< 0xFFE00000 */
2066#define CAN_TI0R_STID CAN_TI0R_STID_Msk /*!<Standard Identifier or Extended Identifier */
2067
2068/****************** Bit definition for CAN_TDT0R register *******************/
2069#define CAN_TDT0R_DLC_Pos (0U)
2070#define CAN_TDT0R_DLC_Msk (0xFU << CAN_TDT0R_DLC_Pos) /*!< 0x0000000F */
2071#define CAN_TDT0R_DLC CAN_TDT0R_DLC_Msk /*!<Data Length Code */
2072#define CAN_TDT0R_TGT_Pos (8U)
2073#define CAN_TDT0R_TGT_Msk (0x1U << CAN_TDT0R_TGT_Pos) /*!< 0x00000100 */
2074#define CAN_TDT0R_TGT CAN_TDT0R_TGT_Msk /*!<Transmit Global Time */
2075#define CAN_TDT0R_TIME_Pos (16U)
2076#define CAN_TDT0R_TIME_Msk (0xFFFFU << CAN_TDT0R_TIME_Pos) /*!< 0xFFFF0000 */
2077#define CAN_TDT0R_TIME CAN_TDT0R_TIME_Msk /*!<Message Time Stamp */
2078
2079/****************** Bit definition for CAN_TDL0R register *******************/
2080#define CAN_TDL0R_DATA0_Pos (0U)
2081#define CAN_TDL0R_DATA0_Msk (0xFFU << CAN_TDL0R_DATA0_Pos) /*!< 0x000000FF */
2082#define CAN_TDL0R_DATA0 CAN_TDL0R_DATA0_Msk /*!<Data byte 0 */
2083#define CAN_TDL0R_DATA1_Pos (8U)
2084#define CAN_TDL0R_DATA1_Msk (0xFFU << CAN_TDL0R_DATA1_Pos) /*!< 0x0000FF00 */
2085#define CAN_TDL0R_DATA1 CAN_TDL0R_DATA1_Msk /*!<Data byte 1 */
2086#define CAN_TDL0R_DATA2_Pos (16U)
2087#define CAN_TDL0R_DATA2_Msk (0xFFU << CAN_TDL0R_DATA2_Pos) /*!< 0x00FF0000 */
2088#define CAN_TDL0R_DATA2 CAN_TDL0R_DATA2_Msk /*!<Data byte 2 */
2089#define CAN_TDL0R_DATA3_Pos (24U)
2090#define CAN_TDL0R_DATA3_Msk (0xFFU << CAN_TDL0R_DATA3_Pos) /*!< 0xFF000000 */
2091#define CAN_TDL0R_DATA3 CAN_TDL0R_DATA3_Msk /*!<Data byte 3 */
2092
2093/****************** Bit definition for CAN_TDH0R register *******************/
2094#define CAN_TDH0R_DATA4_Pos (0U)
2095#define CAN_TDH0R_DATA4_Msk (0xFFU << CAN_TDH0R_DATA4_Pos) /*!< 0x000000FF */
2096#define CAN_TDH0R_DATA4 CAN_TDH0R_DATA4_Msk /*!<Data byte 4 */
2097#define CAN_TDH0R_DATA5_Pos (8U)
2098#define CAN_TDH0R_DATA5_Msk (0xFFU << CAN_TDH0R_DATA5_Pos) /*!< 0x0000FF00 */
2099#define CAN_TDH0R_DATA5 CAN_TDH0R_DATA5_Msk /*!<Data byte 5 */
2100#define CAN_TDH0R_DATA6_Pos (16U)
2101#define CAN_TDH0R_DATA6_Msk (0xFFU << CAN_TDH0R_DATA6_Pos) /*!< 0x00FF0000 */
2102#define CAN_TDH0R_DATA6 CAN_TDH0R_DATA6_Msk /*!<Data byte 6 */
2103#define CAN_TDH0R_DATA7_Pos (24U)
2104#define CAN_TDH0R_DATA7_Msk (0xFFU << CAN_TDH0R_DATA7_Pos) /*!< 0xFF000000 */
2105#define CAN_TDH0R_DATA7 CAN_TDH0R_DATA7_Msk /*!<Data byte 7 */
2106
2107/******************* Bit definition for CAN_TI1R register *******************/
2108#define CAN_TI1R_TXRQ_Pos (0U)
2109#define CAN_TI1R_TXRQ_Msk (0x1U << CAN_TI1R_TXRQ_Pos) /*!< 0x00000001 */
2110#define CAN_TI1R_TXRQ CAN_TI1R_TXRQ_Msk /*!<Transmit Mailbox Request */
2111#define CAN_TI1R_RTR_Pos (1U)
2112#define CAN_TI1R_RTR_Msk (0x1U << CAN_TI1R_RTR_Pos) /*!< 0x00000002 */
2113#define CAN_TI1R_RTR CAN_TI1R_RTR_Msk /*!<Remote Transmission Request */
2114#define CAN_TI1R_IDE_Pos (2U)
2115#define CAN_TI1R_IDE_Msk (0x1U << CAN_TI1R_IDE_Pos) /*!< 0x00000004 */
2116#define CAN_TI1R_IDE CAN_TI1R_IDE_Msk /*!<Identifier Extension */
2117#define CAN_TI1R_EXID_Pos (3U)
2118#define CAN_TI1R_EXID_Msk (0x3FFFFU << CAN_TI1R_EXID_Pos) /*!< 0x001FFFF8 */
2119#define CAN_TI1R_EXID CAN_TI1R_EXID_Msk /*!<Extended Identifier */
2120#define CAN_TI1R_STID_Pos (21U)
2121#define CAN_TI1R_STID_Msk (0x7FFU << CAN_TI1R_STID_Pos) /*!< 0xFFE00000 */
2122#define CAN_TI1R_STID CAN_TI1R_STID_Msk /*!<Standard Identifier or Extended Identifier */
2123
2124/******************* Bit definition for CAN_TDT1R register ******************/
2125#define CAN_TDT1R_DLC_Pos (0U)
2126#define CAN_TDT1R_DLC_Msk (0xFU << CAN_TDT1R_DLC_Pos) /*!< 0x0000000F */
2127#define CAN_TDT1R_DLC CAN_TDT1R_DLC_Msk /*!<Data Length Code */
2128#define CAN_TDT1R_TGT_Pos (8U)
2129#define CAN_TDT1R_TGT_Msk (0x1U << CAN_TDT1R_TGT_Pos) /*!< 0x00000100 */
2130#define CAN_TDT1R_TGT CAN_TDT1R_TGT_Msk /*!<Transmit Global Time */
2131#define CAN_TDT1R_TIME_Pos (16U)
2132#define CAN_TDT1R_TIME_Msk (0xFFFFU << CAN_TDT1R_TIME_Pos) /*!< 0xFFFF0000 */
2133#define CAN_TDT1R_TIME CAN_TDT1R_TIME_Msk /*!<Message Time Stamp */
2134
2135/******************* Bit definition for CAN_TDL1R register ******************/
2136#define CAN_TDL1R_DATA0_Pos (0U)
2137#define CAN_TDL1R_DATA0_Msk (0xFFU << CAN_TDL1R_DATA0_Pos) /*!< 0x000000FF */
2138#define CAN_TDL1R_DATA0 CAN_TDL1R_DATA0_Msk /*!<Data byte 0 */
2139#define CAN_TDL1R_DATA1_Pos (8U)
2140#define CAN_TDL1R_DATA1_Msk (0xFFU << CAN_TDL1R_DATA1_Pos) /*!< 0x0000FF00 */
2141#define CAN_TDL1R_DATA1 CAN_TDL1R_DATA1_Msk /*!<Data byte 1 */
2142#define CAN_TDL1R_DATA2_Pos (16U)
2143#define CAN_TDL1R_DATA2_Msk (0xFFU << CAN_TDL1R_DATA2_Pos) /*!< 0x00FF0000 */
2144#define CAN_TDL1R_DATA2 CAN_TDL1R_DATA2_Msk /*!<Data byte 2 */
2145#define CAN_TDL1R_DATA3_Pos (24U)
2146#define CAN_TDL1R_DATA3_Msk (0xFFU << CAN_TDL1R_DATA3_Pos) /*!< 0xFF000000 */
2147#define CAN_TDL1R_DATA3 CAN_TDL1R_DATA3_Msk /*!<Data byte 3 */
2148
2149/******************* Bit definition for CAN_TDH1R register ******************/
2150#define CAN_TDH1R_DATA4_Pos (0U)
2151#define CAN_TDH1R_DATA4_Msk (0xFFU << CAN_TDH1R_DATA4_Pos) /*!< 0x000000FF */
2152#define CAN_TDH1R_DATA4 CAN_TDH1R_DATA4_Msk /*!<Data byte 4 */
2153#define CAN_TDH1R_DATA5_Pos (8U)
2154#define CAN_TDH1R_DATA5_Msk (0xFFU << CAN_TDH1R_DATA5_Pos) /*!< 0x0000FF00 */
2155#define CAN_TDH1R_DATA5 CAN_TDH1R_DATA5_Msk /*!<Data byte 5 */
2156#define CAN_TDH1R_DATA6_Pos (16U)
2157#define CAN_TDH1R_DATA6_Msk (0xFFU << CAN_TDH1R_DATA6_Pos) /*!< 0x00FF0000 */
2158#define CAN_TDH1R_DATA6 CAN_TDH1R_DATA6_Msk /*!<Data byte 6 */
2159#define CAN_TDH1R_DATA7_Pos (24U)
2160#define CAN_TDH1R_DATA7_Msk (0xFFU << CAN_TDH1R_DATA7_Pos) /*!< 0xFF000000 */
2161#define CAN_TDH1R_DATA7 CAN_TDH1R_DATA7_Msk /*!<Data byte 7 */
2162
2163/******************* Bit definition for CAN_TI2R register *******************/
2164#define CAN_TI2R_TXRQ_Pos (0U)
2165#define CAN_TI2R_TXRQ_Msk (0x1U << CAN_TI2R_TXRQ_Pos) /*!< 0x00000001 */
2166#define CAN_TI2R_TXRQ CAN_TI2R_TXRQ_Msk /*!<Transmit Mailbox Request */
2167#define CAN_TI2R_RTR_Pos (1U)
2168#define CAN_TI2R_RTR_Msk (0x1U << CAN_TI2R_RTR_Pos) /*!< 0x00000002 */
2169#define CAN_TI2R_RTR CAN_TI2R_RTR_Msk /*!<Remote Transmission Request */
2170#define CAN_TI2R_IDE_Pos (2U)
2171#define CAN_TI2R_IDE_Msk (0x1U << CAN_TI2R_IDE_Pos) /*!< 0x00000004 */
2172#define CAN_TI2R_IDE CAN_TI2R_IDE_Msk /*!<Identifier Extension */
2173#define CAN_TI2R_EXID_Pos (3U)
2174#define CAN_TI2R_EXID_Msk (0x3FFFFU << CAN_TI2R_EXID_Pos) /*!< 0x001FFFF8 */
2175#define CAN_TI2R_EXID CAN_TI2R_EXID_Msk /*!<Extended identifier */
2176#define CAN_TI2R_STID_Pos (21U)
2177#define CAN_TI2R_STID_Msk (0x7FFU << CAN_TI2R_STID_Pos) /*!< 0xFFE00000 */
2178#define CAN_TI2R_STID CAN_TI2R_STID_Msk /*!<Standard Identifier or Extended Identifier */
2179
2180/******************* Bit definition for CAN_TDT2R register ******************/
2181#define CAN_TDT2R_DLC_Pos (0U)
2182#define CAN_TDT2R_DLC_Msk (0xFU << CAN_TDT2R_DLC_Pos) /*!< 0x0000000F */
2183#define CAN_TDT2R_DLC CAN_TDT2R_DLC_Msk /*!<Data Length Code */
2184#define CAN_TDT2R_TGT_Pos (8U)
2185#define CAN_TDT2R_TGT_Msk (0x1U << CAN_TDT2R_TGT_Pos) /*!< 0x00000100 */
2186#define CAN_TDT2R_TGT CAN_TDT2R_TGT_Msk /*!<Transmit Global Time */
2187#define CAN_TDT2R_TIME_Pos (16U)
2188#define CAN_TDT2R_TIME_Msk (0xFFFFU << CAN_TDT2R_TIME_Pos) /*!< 0xFFFF0000 */
2189#define CAN_TDT2R_TIME CAN_TDT2R_TIME_Msk /*!<Message Time Stamp */
2190
2191/******************* Bit definition for CAN_TDL2R register ******************/
2192#define CAN_TDL2R_DATA0_Pos (0U)
2193#define CAN_TDL2R_DATA0_Msk (0xFFU << CAN_TDL2R_DATA0_Pos) /*!< 0x000000FF */
2194#define CAN_TDL2R_DATA0 CAN_TDL2R_DATA0_Msk /*!<Data byte 0 */
2195#define CAN_TDL2R_DATA1_Pos (8U)
2196#define CAN_TDL2R_DATA1_Msk (0xFFU << CAN_TDL2R_DATA1_Pos) /*!< 0x0000FF00 */
2197#define CAN_TDL2R_DATA1 CAN_TDL2R_DATA1_Msk /*!<Data byte 1 */
2198#define CAN_TDL2R_DATA2_Pos (16U)
2199#define CAN_TDL2R_DATA2_Msk (0xFFU << CAN_TDL2R_DATA2_Pos) /*!< 0x00FF0000 */
2200#define CAN_TDL2R_DATA2 CAN_TDL2R_DATA2_Msk /*!<Data byte 2 */
2201#define CAN_TDL2R_DATA3_Pos (24U)
2202#define CAN_TDL2R_DATA3_Msk (0xFFU << CAN_TDL2R_DATA3_Pos) /*!< 0xFF000000 */
2203#define CAN_TDL2R_DATA3 CAN_TDL2R_DATA3_Msk /*!<Data byte 3 */
2204
2205/******************* Bit definition for CAN_TDH2R register ******************/
2206#define CAN_TDH2R_DATA4_Pos (0U)
2207#define CAN_TDH2R_DATA4_Msk (0xFFU << CAN_TDH2R_DATA4_Pos) /*!< 0x000000FF */
2208#define CAN_TDH2R_DATA4 CAN_TDH2R_DATA4_Msk /*!<Data byte 4 */
2209#define CAN_TDH2R_DATA5_Pos (8U)
2210#define CAN_TDH2R_DATA5_Msk (0xFFU << CAN_TDH2R_DATA5_Pos) /*!< 0x0000FF00 */
2211#define CAN_TDH2R_DATA5 CAN_TDH2R_DATA5_Msk /*!<Data byte 5 */
2212#define CAN_TDH2R_DATA6_Pos (16U)
2213#define CAN_TDH2R_DATA6_Msk (0xFFU << CAN_TDH2R_DATA6_Pos) /*!< 0x00FF0000 */
2214#define CAN_TDH2R_DATA6 CAN_TDH2R_DATA6_Msk /*!<Data byte 6 */
2215#define CAN_TDH2R_DATA7_Pos (24U)
2216#define CAN_TDH2R_DATA7_Msk (0xFFU << CAN_TDH2R_DATA7_Pos) /*!< 0xFF000000 */
2217#define CAN_TDH2R_DATA7 CAN_TDH2R_DATA7_Msk /*!<Data byte 7 */
2218
2219/******************* Bit definition for CAN_RI0R register *******************/
2220#define CAN_RI0R_RTR_Pos (1U)
2221#define CAN_RI0R_RTR_Msk (0x1U << CAN_RI0R_RTR_Pos) /*!< 0x00000002 */
2222#define CAN_RI0R_RTR CAN_RI0R_RTR_Msk /*!<Remote Transmission Request */
2223#define CAN_RI0R_IDE_Pos (2U)
2224#define CAN_RI0R_IDE_Msk (0x1U << CAN_RI0R_IDE_Pos) /*!< 0x00000004 */
2225#define CAN_RI0R_IDE CAN_RI0R_IDE_Msk /*!<Identifier Extension */
2226#define CAN_RI0R_EXID_Pos (3U)
2227#define CAN_RI0R_EXID_Msk (0x3FFFFU << CAN_RI0R_EXID_Pos) /*!< 0x001FFFF8 */
2228#define CAN_RI0R_EXID CAN_RI0R_EXID_Msk /*!<Extended Identifier */
2229#define CAN_RI0R_STID_Pos (21U)
2230#define CAN_RI0R_STID_Msk (0x7FFU << CAN_RI0R_STID_Pos) /*!< 0xFFE00000 */
2231#define CAN_RI0R_STID CAN_RI0R_STID_Msk /*!<Standard Identifier or Extended Identifier */
2232
2233/******************* Bit definition for CAN_RDT0R register ******************/
2234#define CAN_RDT0R_DLC_Pos (0U)
2235#define CAN_RDT0R_DLC_Msk (0xFU << CAN_RDT0R_DLC_Pos) /*!< 0x0000000F */
2236#define CAN_RDT0R_DLC CAN_RDT0R_DLC_Msk /*!<Data Length Code */
2237#define CAN_RDT0R_FMI_Pos (8U)
2238#define CAN_RDT0R_FMI_Msk (0xFFU << CAN_RDT0R_FMI_Pos) /*!< 0x0000FF00 */
2239#define CAN_RDT0R_FMI CAN_RDT0R_FMI_Msk /*!<Filter Match Index */
2240#define CAN_RDT0R_TIME_Pos (16U)
2241#define CAN_RDT0R_TIME_Msk (0xFFFFU << CAN_RDT0R_TIME_Pos) /*!< 0xFFFF0000 */
2242#define CAN_RDT0R_TIME CAN_RDT0R_TIME_Msk /*!<Message Time Stamp */
2243
2244/******************* Bit definition for CAN_RDL0R register ******************/
2245#define CAN_RDL0R_DATA0_Pos (0U)
2246#define CAN_RDL0R_DATA0_Msk (0xFFU << CAN_RDL0R_DATA0_Pos) /*!< 0x000000FF */
2247#define CAN_RDL0R_DATA0 CAN_RDL0R_DATA0_Msk /*!<Data byte 0 */
2248#define CAN_RDL0R_DATA1_Pos (8U)
2249#define CAN_RDL0R_DATA1_Msk (0xFFU << CAN_RDL0R_DATA1_Pos) /*!< 0x0000FF00 */
2250#define CAN_RDL0R_DATA1 CAN_RDL0R_DATA1_Msk /*!<Data byte 1 */
2251#define CAN_RDL0R_DATA2_Pos (16U)
2252#define CAN_RDL0R_DATA2_Msk (0xFFU << CAN_RDL0R_DATA2_Pos) /*!< 0x00FF0000 */
2253#define CAN_RDL0R_DATA2 CAN_RDL0R_DATA2_Msk /*!<Data byte 2 */
2254#define CAN_RDL0R_DATA3_Pos (24U)
2255#define CAN_RDL0R_DATA3_Msk (0xFFU << CAN_RDL0R_DATA3_Pos) /*!< 0xFF000000 */
2256#define CAN_RDL0R_DATA3 CAN_RDL0R_DATA3_Msk /*!<Data byte 3 */
2257
2258/******************* Bit definition for CAN_RDH0R register ******************/
2259#define CAN_RDH0R_DATA4_Pos (0U)
2260#define CAN_RDH0R_DATA4_Msk (0xFFU << CAN_RDH0R_DATA4_Pos) /*!< 0x000000FF */
2261#define CAN_RDH0R_DATA4 CAN_RDH0R_DATA4_Msk /*!<Data byte 4 */
2262#define CAN_RDH0R_DATA5_Pos (8U)
2263#define CAN_RDH0R_DATA5_Msk (0xFFU << CAN_RDH0R_DATA5_Pos) /*!< 0x0000FF00 */
2264#define CAN_RDH0R_DATA5 CAN_RDH0R_DATA5_Msk /*!<Data byte 5 */
2265#define CAN_RDH0R_DATA6_Pos (16U)
2266#define CAN_RDH0R_DATA6_Msk (0xFFU << CAN_RDH0R_DATA6_Pos) /*!< 0x00FF0000 */
2267#define CAN_RDH0R_DATA6 CAN_RDH0R_DATA6_Msk /*!<Data byte 6 */
2268#define CAN_RDH0R_DATA7_Pos (24U)
2269#define CAN_RDH0R_DATA7_Msk (0xFFU << CAN_RDH0R_DATA7_Pos) /*!< 0xFF000000 */
2270#define CAN_RDH0R_DATA7 CAN_RDH0R_DATA7_Msk /*!<Data byte 7 */
2271
2272/******************* Bit definition for CAN_RI1R register *******************/
2273#define CAN_RI1R_RTR_Pos (1U)
2274#define CAN_RI1R_RTR_Msk (0x1U << CAN_RI1R_RTR_Pos) /*!< 0x00000002 */
2275#define CAN_RI1R_RTR CAN_RI1R_RTR_Msk /*!<Remote Transmission Request */
2276#define CAN_RI1R_IDE_Pos (2U)
2277#define CAN_RI1R_IDE_Msk (0x1U << CAN_RI1R_IDE_Pos) /*!< 0x00000004 */
2278#define CAN_RI1R_IDE CAN_RI1R_IDE_Msk /*!<Identifier Extension */
2279#define CAN_RI1R_EXID_Pos (3U)
2280#define CAN_RI1R_EXID_Msk (0x3FFFFU << CAN_RI1R_EXID_Pos) /*!< 0x001FFFF8 */
2281#define CAN_RI1R_EXID CAN_RI1R_EXID_Msk /*!<Extended identifier */
2282#define CAN_RI1R_STID_Pos (21U)
2283#define CAN_RI1R_STID_Msk (0x7FFU << CAN_RI1R_STID_Pos) /*!< 0xFFE00000 */
2284#define CAN_RI1R_STID CAN_RI1R_STID_Msk /*!<Standard Identifier or Extended Identifier */
2285
2286/******************* Bit definition for CAN_RDT1R register ******************/
2287#define CAN_RDT1R_DLC_Pos (0U)
2288#define CAN_RDT1R_DLC_Msk (0xFU << CAN_RDT1R_DLC_Pos) /*!< 0x0000000F */
2289#define CAN_RDT1R_DLC CAN_RDT1R_DLC_Msk /*!<Data Length Code */
2290#define CAN_RDT1R_FMI_Pos (8U)
2291#define CAN_RDT1R_FMI_Msk (0xFFU << CAN_RDT1R_FMI_Pos) /*!< 0x0000FF00 */
2292#define CAN_RDT1R_FMI CAN_RDT1R_FMI_Msk /*!<Filter Match Index */
2293#define CAN_RDT1R_TIME_Pos (16U)
2294#define CAN_RDT1R_TIME_Msk (0xFFFFU << CAN_RDT1R_TIME_Pos) /*!< 0xFFFF0000 */
2295#define CAN_RDT1R_TIME CAN_RDT1R_TIME_Msk /*!<Message Time Stamp */
2296
2297/******************* Bit definition for CAN_RDL1R register ******************/
2298#define CAN_RDL1R_DATA0_Pos (0U)
2299#define CAN_RDL1R_DATA0_Msk (0xFFU << CAN_RDL1R_DATA0_Pos) /*!< 0x000000FF */
2300#define CAN_RDL1R_DATA0 CAN_RDL1R_DATA0_Msk /*!<Data byte 0 */
2301#define CAN_RDL1R_DATA1_Pos (8U)
2302#define CAN_RDL1R_DATA1_Msk (0xFFU << CAN_RDL1R_DATA1_Pos) /*!< 0x0000FF00 */
2303#define CAN_RDL1R_DATA1 CAN_RDL1R_DATA1_Msk /*!<Data byte 1 */
2304#define CAN_RDL1R_DATA2_Pos (16U)
2305#define CAN_RDL1R_DATA2_Msk (0xFFU << CAN_RDL1R_DATA2_Pos) /*!< 0x00FF0000 */
2306#define CAN_RDL1R_DATA2 CAN_RDL1R_DATA2_Msk /*!<Data byte 2 */
2307#define CAN_RDL1R_DATA3_Pos (24U)
2308#define CAN_RDL1R_DATA3_Msk (0xFFU << CAN_RDL1R_DATA3_Pos) /*!< 0xFF000000 */
2309#define CAN_RDL1R_DATA3 CAN_RDL1R_DATA3_Msk /*!<Data byte 3 */
2310
2311/******************* Bit definition for CAN_RDH1R register ******************/
2312#define CAN_RDH1R_DATA4_Pos (0U)
2313#define CAN_RDH1R_DATA4_Msk (0xFFU << CAN_RDH1R_DATA4_Pos) /*!< 0x000000FF */
2314#define CAN_RDH1R_DATA4 CAN_RDH1R_DATA4_Msk /*!<Data byte 4 */
2315#define CAN_RDH1R_DATA5_Pos (8U)
2316#define CAN_RDH1R_DATA5_Msk (0xFFU << CAN_RDH1R_DATA5_Pos) /*!< 0x0000FF00 */
2317#define CAN_RDH1R_DATA5 CAN_RDH1R_DATA5_Msk /*!<Data byte 5 */
2318#define CAN_RDH1R_DATA6_Pos (16U)
2319#define CAN_RDH1R_DATA6_Msk (0xFFU << CAN_RDH1R_DATA6_Pos) /*!< 0x00FF0000 */
2320#define CAN_RDH1R_DATA6 CAN_RDH1R_DATA6_Msk /*!<Data byte 6 */
2321#define CAN_RDH1R_DATA7_Pos (24U)
2322#define CAN_RDH1R_DATA7_Msk (0xFFU << CAN_RDH1R_DATA7_Pos) /*!< 0xFF000000 */
2323#define CAN_RDH1R_DATA7 CAN_RDH1R_DATA7_Msk /*!<Data byte 7 */
2324
2325/*!<CAN filter registers */
2326/******************* Bit definition for CAN_FMR register ********************/
2327#define CAN_FMR_FINIT ((uint8_t)0x01U) /*!<Filter Init Mode */
2328
2329/******************* Bit definition for CAN_FM1R register *******************/
2330#define CAN_FM1R_FBM_Pos (0U)
2331#define CAN_FM1R_FBM_Msk (0x3FFFU << CAN_FM1R_FBM_Pos) /*!< 0x00003FFF */
2332#define CAN_FM1R_FBM CAN_FM1R_FBM_Msk /*!<Filter Mode */
2333#define CAN_FM1R_FBM0_Pos (0U)
2334#define CAN_FM1R_FBM0_Msk (0x1U << CAN_FM1R_FBM0_Pos) /*!< 0x00000001 */
2335#define CAN_FM1R_FBM0 CAN_FM1R_FBM0_Msk /*!<Filter Init Mode bit 0 */
2336#define CAN_FM1R_FBM1_Pos (1U)
2337#define CAN_FM1R_FBM1_Msk (0x1U << CAN_FM1R_FBM1_Pos) /*!< 0x00000002 */
2338#define CAN_FM1R_FBM1 CAN_FM1R_FBM1_Msk /*!<Filter Init Mode bit 1 */
2339#define CAN_FM1R_FBM2_Pos (2U)
2340#define CAN_FM1R_FBM2_Msk (0x1U << CAN_FM1R_FBM2_Pos) /*!< 0x00000004 */
2341#define CAN_FM1R_FBM2 CAN_FM1R_FBM2_Msk /*!<Filter Init Mode bit 2 */
2342#define CAN_FM1R_FBM3_Pos (3U)
2343#define CAN_FM1R_FBM3_Msk (0x1U << CAN_FM1R_FBM3_Pos) /*!< 0x00000008 */
2344#define CAN_FM1R_FBM3 CAN_FM1R_FBM3_Msk /*!<Filter Init Mode bit 3 */
2345#define CAN_FM1R_FBM4_Pos (4U)
2346#define CAN_FM1R_FBM4_Msk (0x1U << CAN_FM1R_FBM4_Pos) /*!< 0x00000010 */
2347#define CAN_FM1R_FBM4 CAN_FM1R_FBM4_Msk /*!<Filter Init Mode bit 4 */
2348#define CAN_FM1R_FBM5_Pos (5U)
2349#define CAN_FM1R_FBM5_Msk (0x1U << CAN_FM1R_FBM5_Pos) /*!< 0x00000020 */
2350#define CAN_FM1R_FBM5 CAN_FM1R_FBM5_Msk /*!<Filter Init Mode bit 5 */
2351#define CAN_FM1R_FBM6_Pos (6U)
2352#define CAN_FM1R_FBM6_Msk (0x1U << CAN_FM1R_FBM6_Pos) /*!< 0x00000040 */
2353#define CAN_FM1R_FBM6 CAN_FM1R_FBM6_Msk /*!<Filter Init Mode bit 6 */
2354#define CAN_FM1R_FBM7_Pos (7U)
2355#define CAN_FM1R_FBM7_Msk (0x1U << CAN_FM1R_FBM7_Pos) /*!< 0x00000080 */
2356#define CAN_FM1R_FBM7 CAN_FM1R_FBM7_Msk /*!<Filter Init Mode bit 7 */
2357#define CAN_FM1R_FBM8_Pos (8U)
2358#define CAN_FM1R_FBM8_Msk (0x1U << CAN_FM1R_FBM8_Pos) /*!< 0x00000100 */
2359#define CAN_FM1R_FBM8 CAN_FM1R_FBM8_Msk /*!<Filter Init Mode bit 8 */
2360#define CAN_FM1R_FBM9_Pos (9U)
2361#define CAN_FM1R_FBM9_Msk (0x1U << CAN_FM1R_FBM9_Pos) /*!< 0x00000200 */
2362#define CAN_FM1R_FBM9 CAN_FM1R_FBM9_Msk /*!<Filter Init Mode bit 9 */
2363#define CAN_FM1R_FBM10_Pos (10U)
2364#define CAN_FM1R_FBM10_Msk (0x1U << CAN_FM1R_FBM10_Pos) /*!< 0x00000400 */
2365#define CAN_FM1R_FBM10 CAN_FM1R_FBM10_Msk /*!<Filter Init Mode bit 10 */
2366#define CAN_FM1R_FBM11_Pos (11U)
2367#define CAN_FM1R_FBM11_Msk (0x1U << CAN_FM1R_FBM11_Pos) /*!< 0x00000800 */
2368#define CAN_FM1R_FBM11 CAN_FM1R_FBM11_Msk /*!<Filter Init Mode bit 11 */
2369#define CAN_FM1R_FBM12_Pos (12U)
2370#define CAN_FM1R_FBM12_Msk (0x1U << CAN_FM1R_FBM12_Pos) /*!< 0x00001000 */
2371#define CAN_FM1R_FBM12 CAN_FM1R_FBM12_Msk /*!<Filter Init Mode bit 12 */
2372#define CAN_FM1R_FBM13_Pos (13U)
2373#define CAN_FM1R_FBM13_Msk (0x1U << CAN_FM1R_FBM13_Pos) /*!< 0x00002000 */
2374#define CAN_FM1R_FBM13 CAN_FM1R_FBM13_Msk /*!<Filter Init Mode bit 13 */
2375
2376/******************* Bit definition for CAN_FS1R register *******************/
2377#define CAN_FS1R_FSC_Pos (0U)
2378#define CAN_FS1R_FSC_Msk (0x3FFFU << CAN_FS1R_FSC_Pos) /*!< 0x00003FFF */
2379#define CAN_FS1R_FSC CAN_FS1R_FSC_Msk /*!<Filter Scale Configuration */
2380#define CAN_FS1R_FSC0_Pos (0U)
2381#define CAN_FS1R_FSC0_Msk (0x1U << CAN_FS1R_FSC0_Pos) /*!< 0x00000001 */
2382#define CAN_FS1R_FSC0 CAN_FS1R_FSC0_Msk /*!<Filter Scale Configuration bit 0 */
2383#define CAN_FS1R_FSC1_Pos (1U)
2384#define CAN_FS1R_FSC1_Msk (0x1U << CAN_FS1R_FSC1_Pos) /*!< 0x00000002 */
2385#define CAN_FS1R_FSC1 CAN_FS1R_FSC1_Msk /*!<Filter Scale Configuration bit 1 */
2386#define CAN_FS1R_FSC2_Pos (2U)
2387#define CAN_FS1R_FSC2_Msk (0x1U << CAN_FS1R_FSC2_Pos) /*!< 0x00000004 */
2388#define CAN_FS1R_FSC2 CAN_FS1R_FSC2_Msk /*!<Filter Scale Configuration bit 2 */
2389#define CAN_FS1R_FSC3_Pos (3U)
2390#define CAN_FS1R_FSC3_Msk (0x1U << CAN_FS1R_FSC3_Pos) /*!< 0x00000008 */
2391#define CAN_FS1R_FSC3 CAN_FS1R_FSC3_Msk /*!<Filter Scale Configuration bit 3 */
2392#define CAN_FS1R_FSC4_Pos (4U)
2393#define CAN_FS1R_FSC4_Msk (0x1U << CAN_FS1R_FSC4_Pos) /*!< 0x00000010 */
2394#define CAN_FS1R_FSC4 CAN_FS1R_FSC4_Msk /*!<Filter Scale Configuration bit 4 */
2395#define CAN_FS1R_FSC5_Pos (5U)
2396#define CAN_FS1R_FSC5_Msk (0x1U << CAN_FS1R_FSC5_Pos) /*!< 0x00000020 */
2397#define CAN_FS1R_FSC5 CAN_FS1R_FSC5_Msk /*!<Filter Scale Configuration bit 5 */
2398#define CAN_FS1R_FSC6_Pos (6U)
2399#define CAN_FS1R_FSC6_Msk (0x1U << CAN_FS1R_FSC6_Pos) /*!< 0x00000040 */
2400#define CAN_FS1R_FSC6 CAN_FS1R_FSC6_Msk /*!<Filter Scale Configuration bit 6 */
2401#define CAN_FS1R_FSC7_Pos (7U)
2402#define CAN_FS1R_FSC7_Msk (0x1U << CAN_FS1R_FSC7_Pos) /*!< 0x00000080 */
2403#define CAN_FS1R_FSC7 CAN_FS1R_FSC7_Msk /*!<Filter Scale Configuration bit 7 */
2404#define CAN_FS1R_FSC8_Pos (8U)
2405#define CAN_FS1R_FSC8_Msk (0x1U << CAN_FS1R_FSC8_Pos) /*!< 0x00000100 */
2406#define CAN_FS1R_FSC8 CAN_FS1R_FSC8_Msk /*!<Filter Scale Configuration bit 8 */
2407#define CAN_FS1R_FSC9_Pos (9U)
2408#define CAN_FS1R_FSC9_Msk (0x1U << CAN_FS1R_FSC9_Pos) /*!< 0x00000200 */
2409#define CAN_FS1R_FSC9 CAN_FS1R_FSC9_Msk /*!<Filter Scale Configuration bit 9 */
2410#define CAN_FS1R_FSC10_Pos (10U)
2411#define CAN_FS1R_FSC10_Msk (0x1U << CAN_FS1R_FSC10_Pos) /*!< 0x00000400 */
2412#define CAN_FS1R_FSC10 CAN_FS1R_FSC10_Msk /*!<Filter Scale Configuration bit 10 */
2413#define CAN_FS1R_FSC11_Pos (11U)
2414#define CAN_FS1R_FSC11_Msk (0x1U << CAN_FS1R_FSC11_Pos) /*!< 0x00000800 */
2415#define CAN_FS1R_FSC11 CAN_FS1R_FSC11_Msk /*!<Filter Scale Configuration bit 11 */
2416#define CAN_FS1R_FSC12_Pos (12U)
2417#define CAN_FS1R_FSC12_Msk (0x1U << CAN_FS1R_FSC12_Pos) /*!< 0x00001000 */
2418#define CAN_FS1R_FSC12 CAN_FS1R_FSC12_Msk /*!<Filter Scale Configuration bit 12 */
2419#define CAN_FS1R_FSC13_Pos (13U)
2420#define CAN_FS1R_FSC13_Msk (0x1U << CAN_FS1R_FSC13_Pos) /*!< 0x00002000 */
2421#define CAN_FS1R_FSC13 CAN_FS1R_FSC13_Msk /*!<Filter Scale Configuration bit 13 */
2422
2423/****************** Bit definition for CAN_FFA1R register *******************/
2424#define CAN_FFA1R_FFA_Pos (0U)
2425#define CAN_FFA1R_FFA_Msk (0x3FFFU << CAN_FFA1R_FFA_Pos) /*!< 0x00003FFF */
2426#define CAN_FFA1R_FFA CAN_FFA1R_FFA_Msk /*!<Filter FIFO Assignment */
2427#define CAN_FFA1R_FFA0_Pos (0U)
2428#define CAN_FFA1R_FFA0_Msk (0x1U << CAN_FFA1R_FFA0_Pos) /*!< 0x00000001 */
2429#define CAN_FFA1R_FFA0 CAN_FFA1R_FFA0_Msk /*!<Filter FIFO Assignment for Filter 0 */
2430#define CAN_FFA1R_FFA1_Pos (1U)
2431#define CAN_FFA1R_FFA1_Msk (0x1U << CAN_FFA1R_FFA1_Pos) /*!< 0x00000002 */
2432#define CAN_FFA1R_FFA1 CAN_FFA1R_FFA1_Msk /*!<Filter FIFO Assignment for Filter 1 */
2433#define CAN_FFA1R_FFA2_Pos (2U)
2434#define CAN_FFA1R_FFA2_Msk (0x1U << CAN_FFA1R_FFA2_Pos) /*!< 0x00000004 */
2435#define CAN_FFA1R_FFA2 CAN_FFA1R_FFA2_Msk /*!<Filter FIFO Assignment for Filter 2 */
2436#define CAN_FFA1R_FFA3_Pos (3U)
2437#define CAN_FFA1R_FFA3_Msk (0x1U << CAN_FFA1R_FFA3_Pos) /*!< 0x00000008 */
2438#define CAN_FFA1R_FFA3 CAN_FFA1R_FFA3_Msk /*!<Filter FIFO Assignment for Filter 3 */
2439#define CAN_FFA1R_FFA4_Pos (4U)
2440#define CAN_FFA1R_FFA4_Msk (0x1U << CAN_FFA1R_FFA4_Pos) /*!< 0x00000010 */
2441#define CAN_FFA1R_FFA4 CAN_FFA1R_FFA4_Msk /*!<Filter FIFO Assignment for Filter 4 */
2442#define CAN_FFA1R_FFA5_Pos (5U)
2443#define CAN_FFA1R_FFA5_Msk (0x1U << CAN_FFA1R_FFA5_Pos) /*!< 0x00000020 */
2444#define CAN_FFA1R_FFA5 CAN_FFA1R_FFA5_Msk /*!<Filter FIFO Assignment for Filter 5 */
2445#define CAN_FFA1R_FFA6_Pos (6U)
2446#define CAN_FFA1R_FFA6_Msk (0x1U << CAN_FFA1R_FFA6_Pos) /*!< 0x00000040 */
2447#define CAN_FFA1R_FFA6 CAN_FFA1R_FFA6_Msk /*!<Filter FIFO Assignment for Filter 6 */
2448#define CAN_FFA1R_FFA7_Pos (7U)
2449#define CAN_FFA1R_FFA7_Msk (0x1U << CAN_FFA1R_FFA7_Pos) /*!< 0x00000080 */
2450#define CAN_FFA1R_FFA7 CAN_FFA1R_FFA7_Msk /*!<Filter FIFO Assignment for Filter 7 */
2451#define CAN_FFA1R_FFA8_Pos (8U)
2452#define CAN_FFA1R_FFA8_Msk (0x1U << CAN_FFA1R_FFA8_Pos) /*!< 0x00000100 */
2453#define CAN_FFA1R_FFA8 CAN_FFA1R_FFA8_Msk /*!<Filter FIFO Assignment for Filter 8 */
2454#define CAN_FFA1R_FFA9_Pos (9U)
2455#define CAN_FFA1R_FFA9_Msk (0x1U << CAN_FFA1R_FFA9_Pos) /*!< 0x00000200 */
2456#define CAN_FFA1R_FFA9 CAN_FFA1R_FFA9_Msk /*!<Filter FIFO Assignment for Filter 9 */
2457#define CAN_FFA1R_FFA10_Pos (10U)
2458#define CAN_FFA1R_FFA10_Msk (0x1U << CAN_FFA1R_FFA10_Pos) /*!< 0x00000400 */
2459#define CAN_FFA1R_FFA10 CAN_FFA1R_FFA10_Msk /*!<Filter FIFO Assignment for Filter 10 */
2460#define CAN_FFA1R_FFA11_Pos (11U)
2461#define CAN_FFA1R_FFA11_Msk (0x1U << CAN_FFA1R_FFA11_Pos) /*!< 0x00000800 */
2462#define CAN_FFA1R_FFA11 CAN_FFA1R_FFA11_Msk /*!<Filter FIFO Assignment for Filter 11 */
2463#define CAN_FFA1R_FFA12_Pos (12U)
2464#define CAN_FFA1R_FFA12_Msk (0x1U << CAN_FFA1R_FFA12_Pos) /*!< 0x00001000 */
2465#define CAN_FFA1R_FFA12 CAN_FFA1R_FFA12_Msk /*!<Filter FIFO Assignment for Filter 12 */
2466#define CAN_FFA1R_FFA13_Pos (13U)
2467#define CAN_FFA1R_FFA13_Msk (0x1U << CAN_FFA1R_FFA13_Pos) /*!< 0x00002000 */
2468#define CAN_FFA1R_FFA13 CAN_FFA1R_FFA13_Msk /*!<Filter FIFO Assignment for Filter 13 */
2469
2470/******************* Bit definition for CAN_FA1R register *******************/
2471#define CAN_FA1R_FACT_Pos (0U)
2472#define CAN_FA1R_FACT_Msk (0x3FFFU << CAN_FA1R_FACT_Pos) /*!< 0x00003FFF */
2473#define CAN_FA1R_FACT CAN_FA1R_FACT_Msk /*!<Filter Active */
2474#define CAN_FA1R_FACT0_Pos (0U)
2475#define CAN_FA1R_FACT0_Msk (0x1U << CAN_FA1R_FACT0_Pos) /*!< 0x00000001 */
2476#define CAN_FA1R_FACT0 CAN_FA1R_FACT0_Msk /*!<Filter 0 Active */
2477#define CAN_FA1R_FACT1_Pos (1U)
2478#define CAN_FA1R_FACT1_Msk (0x1U << CAN_FA1R_FACT1_Pos) /*!< 0x00000002 */
2479#define CAN_FA1R_FACT1 CAN_FA1R_FACT1_Msk /*!<Filter 1 Active */
2480#define CAN_FA1R_FACT2_Pos (2U)
2481#define CAN_FA1R_FACT2_Msk (0x1U << CAN_FA1R_FACT2_Pos) /*!< 0x00000004 */
2482#define CAN_FA1R_FACT2 CAN_FA1R_FACT2_Msk /*!<Filter 2 Active */
2483#define CAN_FA1R_FACT3_Pos (3U)
2484#define CAN_FA1R_FACT3_Msk (0x1U << CAN_FA1R_FACT3_Pos) /*!< 0x00000008 */
2485#define CAN_FA1R_FACT3 CAN_FA1R_FACT3_Msk /*!<Filter 3 Active */
2486#define CAN_FA1R_FACT4_Pos (4U)
2487#define CAN_FA1R_FACT4_Msk (0x1U << CAN_FA1R_FACT4_Pos) /*!< 0x00000010 */
2488#define CAN_FA1R_FACT4 CAN_FA1R_FACT4_Msk /*!<Filter 4 Active */
2489#define CAN_FA1R_FACT5_Pos (5U)
2490#define CAN_FA1R_FACT5_Msk (0x1U << CAN_FA1R_FACT5_Pos) /*!< 0x00000020 */
2491#define CAN_FA1R_FACT5 CAN_FA1R_FACT5_Msk /*!<Filter 5 Active */
2492#define CAN_FA1R_FACT6_Pos (6U)
2493#define CAN_FA1R_FACT6_Msk (0x1U << CAN_FA1R_FACT6_Pos) /*!< 0x00000040 */
2494#define CAN_FA1R_FACT6 CAN_FA1R_FACT6_Msk /*!<Filter 6 Active */
2495#define CAN_FA1R_FACT7_Pos (7U)
2496#define CAN_FA1R_FACT7_Msk (0x1U << CAN_FA1R_FACT7_Pos) /*!< 0x00000080 */
2497#define CAN_FA1R_FACT7 CAN_FA1R_FACT7_Msk /*!<Filter 7 Active */
2498#define CAN_FA1R_FACT8_Pos (8U)
2499#define CAN_FA1R_FACT8_Msk (0x1U << CAN_FA1R_FACT8_Pos) /*!< 0x00000100 */
2500#define CAN_FA1R_FACT8 CAN_FA1R_FACT8_Msk /*!<Filter 8 Active */
2501#define CAN_FA1R_FACT9_Pos (9U)
2502#define CAN_FA1R_FACT9_Msk (0x1U << CAN_FA1R_FACT9_Pos) /*!< 0x00000200 */
2503#define CAN_FA1R_FACT9 CAN_FA1R_FACT9_Msk /*!<Filter 9 Active */
2504#define CAN_FA1R_FACT10_Pos (10U)
2505#define CAN_FA1R_FACT10_Msk (0x1U << CAN_FA1R_FACT10_Pos) /*!< 0x00000400 */
2506#define CAN_FA1R_FACT10 CAN_FA1R_FACT10_Msk /*!<Filter 10 Active */
2507#define CAN_FA1R_FACT11_Pos (11U)
2508#define CAN_FA1R_FACT11_Msk (0x1U << CAN_FA1R_FACT11_Pos) /*!< 0x00000800 */
2509#define CAN_FA1R_FACT11 CAN_FA1R_FACT11_Msk /*!<Filter 11 Active */
2510#define CAN_FA1R_FACT12_Pos (12U)
2511#define CAN_FA1R_FACT12_Msk (0x1U << CAN_FA1R_FACT12_Pos) /*!< 0x00001000 */
2512#define CAN_FA1R_FACT12 CAN_FA1R_FACT12_Msk /*!<Filter 12 Active */
2513#define CAN_FA1R_FACT13_Pos (13U)
2514#define CAN_FA1R_FACT13_Msk (0x1U << CAN_FA1R_FACT13_Pos) /*!< 0x00002000 */
2515#define CAN_FA1R_FACT13 CAN_FA1R_FACT13_Msk /*!<Filter 13 Active */
2516
2517/******************* Bit definition for CAN_F0R1 register *******************/
2518#define CAN_F0R1_FB0_Pos (0U)
2519#define CAN_F0R1_FB0_Msk (0x1U << CAN_F0R1_FB0_Pos) /*!< 0x00000001 */
2520#define CAN_F0R1_FB0 CAN_F0R1_FB0_Msk /*!<Filter bit 0 */
2521#define CAN_F0R1_FB1_Pos (1U)
2522#define CAN_F0R1_FB1_Msk (0x1U << CAN_F0R1_FB1_Pos) /*!< 0x00000002 */
2523#define CAN_F0R1_FB1 CAN_F0R1_FB1_Msk /*!<Filter bit 1 */
2524#define CAN_F0R1_FB2_Pos (2U)
2525#define CAN_F0R1_FB2_Msk (0x1U << CAN_F0R1_FB2_Pos) /*!< 0x00000004 */
2526#define CAN_F0R1_FB2 CAN_F0R1_FB2_Msk /*!<Filter bit 2 */
2527#define CAN_F0R1_FB3_Pos (3U)
2528#define CAN_F0R1_FB3_Msk (0x1U << CAN_F0R1_FB3_Pos) /*!< 0x00000008 */
2529#define CAN_F0R1_FB3 CAN_F0R1_FB3_Msk /*!<Filter bit 3 */
2530#define CAN_F0R1_FB4_Pos (4U)
2531#define CAN_F0R1_FB4_Msk (0x1U << CAN_F0R1_FB4_Pos) /*!< 0x00000010 */
2532#define CAN_F0R1_FB4 CAN_F0R1_FB4_Msk /*!<Filter bit 4 */
2533#define CAN_F0R1_FB5_Pos (5U)
2534#define CAN_F0R1_FB5_Msk (0x1U << CAN_F0R1_FB5_Pos) /*!< 0x00000020 */
2535#define CAN_F0R1_FB5 CAN_F0R1_FB5_Msk /*!<Filter bit 5 */
2536#define CAN_F0R1_FB6_Pos (6U)
2537#define CAN_F0R1_FB6_Msk (0x1U << CAN_F0R1_FB6_Pos) /*!< 0x00000040 */
2538#define CAN_F0R1_FB6 CAN_F0R1_FB6_Msk /*!<Filter bit 6 */
2539#define CAN_F0R1_FB7_Pos (7U)
2540#define CAN_F0R1_FB7_Msk (0x1U << CAN_F0R1_FB7_Pos) /*!< 0x00000080 */
2541#define CAN_F0R1_FB7 CAN_F0R1_FB7_Msk /*!<Filter bit 7 */
2542#define CAN_F0R1_FB8_Pos (8U)
2543#define CAN_F0R1_FB8_Msk (0x1U << CAN_F0R1_FB8_Pos) /*!< 0x00000100 */
2544#define CAN_F0R1_FB8 CAN_F0R1_FB8_Msk /*!<Filter bit 8 */
2545#define CAN_F0R1_FB9_Pos (9U)
2546#define CAN_F0R1_FB9_Msk (0x1U << CAN_F0R1_FB9_Pos) /*!< 0x00000200 */
2547#define CAN_F0R1_FB9 CAN_F0R1_FB9_Msk /*!<Filter bit 9 */
2548#define CAN_F0R1_FB10_Pos (10U)
2549#define CAN_F0R1_FB10_Msk (0x1U << CAN_F0R1_FB10_Pos) /*!< 0x00000400 */
2550#define CAN_F0R1_FB10 CAN_F0R1_FB10_Msk /*!<Filter bit 10 */
2551#define CAN_F0R1_FB11_Pos (11U)
2552#define CAN_F0R1_FB11_Msk (0x1U << CAN_F0R1_FB11_Pos) /*!< 0x00000800 */
2553#define CAN_F0R1_FB11 CAN_F0R1_FB11_Msk /*!<Filter bit 11 */
2554#define CAN_F0R1_FB12_Pos (12U)
2555#define CAN_F0R1_FB12_Msk (0x1U << CAN_F0R1_FB12_Pos) /*!< 0x00001000 */
2556#define CAN_F0R1_FB12 CAN_F0R1_FB12_Msk /*!<Filter bit 12 */
2557#define CAN_F0R1_FB13_Pos (13U)
2558#define CAN_F0R1_FB13_Msk (0x1U << CAN_F0R1_FB13_Pos) /*!< 0x00002000 */
2559#define CAN_F0R1_FB13 CAN_F0R1_FB13_Msk /*!<Filter bit 13 */
2560#define CAN_F0R1_FB14_Pos (14U)
2561#define CAN_F0R1_FB14_Msk (0x1U << CAN_F0R1_FB14_Pos) /*!< 0x00004000 */
2562#define CAN_F0R1_FB14 CAN_F0R1_FB14_Msk /*!<Filter bit 14 */
2563#define CAN_F0R1_FB15_Pos (15U)
2564#define CAN_F0R1_FB15_Msk (0x1U << CAN_F0R1_FB15_Pos) /*!< 0x00008000 */
2565#define CAN_F0R1_FB15 CAN_F0R1_FB15_Msk /*!<Filter bit 15 */
2566#define CAN_F0R1_FB16_Pos (16U)
2567#define CAN_F0R1_FB16_Msk (0x1U << CAN_F0R1_FB16_Pos) /*!< 0x00010000 */
2568#define CAN_F0R1_FB16 CAN_F0R1_FB16_Msk /*!<Filter bit 16 */
2569#define CAN_F0R1_FB17_Pos (17U)
2570#define CAN_F0R1_FB17_Msk (0x1U << CAN_F0R1_FB17_Pos) /*!< 0x00020000 */
2571#define CAN_F0R1_FB17 CAN_F0R1_FB17_Msk /*!<Filter bit 17 */
2572#define CAN_F0R1_FB18_Pos (18U)
2573#define CAN_F0R1_FB18_Msk (0x1U << CAN_F0R1_FB18_Pos) /*!< 0x00040000 */
2574#define CAN_F0R1_FB18 CAN_F0R1_FB18_Msk /*!<Filter bit 18 */
2575#define CAN_F0R1_FB19_Pos (19U)
2576#define CAN_F0R1_FB19_Msk (0x1U << CAN_F0R1_FB19_Pos) /*!< 0x00080000 */
2577#define CAN_F0R1_FB19 CAN_F0R1_FB19_Msk /*!<Filter bit 19 */
2578#define CAN_F0R1_FB20_Pos (20U)
2579#define CAN_F0R1_FB20_Msk (0x1U << CAN_F0R1_FB20_Pos) /*!< 0x00100000 */
2580#define CAN_F0R1_FB20 CAN_F0R1_FB20_Msk /*!<Filter bit 20 */
2581#define CAN_F0R1_FB21_Pos (21U)
2582#define CAN_F0R1_FB21_Msk (0x1U << CAN_F0R1_FB21_Pos) /*!< 0x00200000 */
2583#define CAN_F0R1_FB21 CAN_F0R1_FB21_Msk /*!<Filter bit 21 */
2584#define CAN_F0R1_FB22_Pos (22U)
2585#define CAN_F0R1_FB22_Msk (0x1U << CAN_F0R1_FB22_Pos) /*!< 0x00400000 */
2586#define CAN_F0R1_FB22 CAN_F0R1_FB22_Msk /*!<Filter bit 22 */
2587#define CAN_F0R1_FB23_Pos (23U)
2588#define CAN_F0R1_FB23_Msk (0x1U << CAN_F0R1_FB23_Pos) /*!< 0x00800000 */
2589#define CAN_F0R1_FB23 CAN_F0R1_FB23_Msk /*!<Filter bit 23 */
2590#define CAN_F0R1_FB24_Pos (24U)
2591#define CAN_F0R1_FB24_Msk (0x1U << CAN_F0R1_FB24_Pos) /*!< 0x01000000 */
2592#define CAN_F0R1_FB24 CAN_F0R1_FB24_Msk /*!<Filter bit 24 */
2593#define CAN_F0R1_FB25_Pos (25U)
2594#define CAN_F0R1_FB25_Msk (0x1U << CAN_F0R1_FB25_Pos) /*!< 0x02000000 */
2595#define CAN_F0R1_FB25 CAN_F0R1_FB25_Msk /*!<Filter bit 25 */
2596#define CAN_F0R1_FB26_Pos (26U)
2597#define CAN_F0R1_FB26_Msk (0x1U << CAN_F0R1_FB26_Pos) /*!< 0x04000000 */
2598#define CAN_F0R1_FB26 CAN_F0R1_FB26_Msk /*!<Filter bit 26 */
2599#define CAN_F0R1_FB27_Pos (27U)
2600#define CAN_F0R1_FB27_Msk (0x1U << CAN_F0R1_FB27_Pos) /*!< 0x08000000 */
2601#define CAN_F0R1_FB27 CAN_F0R1_FB27_Msk /*!<Filter bit 27 */
2602#define CAN_F0R1_FB28_Pos (28U)
2603#define CAN_F0R1_FB28_Msk (0x1U << CAN_F0R1_FB28_Pos) /*!< 0x10000000 */
2604#define CAN_F0R1_FB28 CAN_F0R1_FB28_Msk /*!<Filter bit 28 */
2605#define CAN_F0R1_FB29_Pos (29U)
2606#define CAN_F0R1_FB29_Msk (0x1U << CAN_F0R1_FB29_Pos) /*!< 0x20000000 */
2607#define CAN_F0R1_FB29 CAN_F0R1_FB29_Msk /*!<Filter bit 29 */
2608#define CAN_F0R1_FB30_Pos (30U)
2609#define CAN_F0R1_FB30_Msk (0x1U << CAN_F0R1_FB30_Pos) /*!< 0x40000000 */
2610#define CAN_F0R1_FB30 CAN_F0R1_FB30_Msk /*!<Filter bit 30 */
2611#define CAN_F0R1_FB31_Pos (31U)
2612#define CAN_F0R1_FB31_Msk (0x1U << CAN_F0R1_FB31_Pos) /*!< 0x80000000 */
2613#define CAN_F0R1_FB31 CAN_F0R1_FB31_Msk /*!<Filter bit 31 */
2614
2615/******************* Bit definition for CAN_F1R1 register *******************/
2616#define CAN_F1R1_FB0_Pos (0U)
2617#define CAN_F1R1_FB0_Msk (0x1U << CAN_F1R1_FB0_Pos) /*!< 0x00000001 */
2618#define CAN_F1R1_FB0 CAN_F1R1_FB0_Msk /*!<Filter bit 0 */
2619#define CAN_F1R1_FB1_Pos (1U)
2620#define CAN_F1R1_FB1_Msk (0x1U << CAN_F1R1_FB1_Pos) /*!< 0x00000002 */
2621#define CAN_F1R1_FB1 CAN_F1R1_FB1_Msk /*!<Filter bit 1 */
2622#define CAN_F1R1_FB2_Pos (2U)
2623#define CAN_F1R1_FB2_Msk (0x1U << CAN_F1R1_FB2_Pos) /*!< 0x00000004 */
2624#define CAN_F1R1_FB2 CAN_F1R1_FB2_Msk /*!<Filter bit 2 */
2625#define CAN_F1R1_FB3_Pos (3U)
2626#define CAN_F1R1_FB3_Msk (0x1U << CAN_F1R1_FB3_Pos) /*!< 0x00000008 */
2627#define CAN_F1R1_FB3 CAN_F1R1_FB3_Msk /*!<Filter bit 3 */
2628#define CAN_F1R1_FB4_Pos (4U)
2629#define CAN_F1R1_FB4_Msk (0x1U << CAN_F1R1_FB4_Pos) /*!< 0x00000010 */
2630#define CAN_F1R1_FB4 CAN_F1R1_FB4_Msk /*!<Filter bit 4 */
2631#define CAN_F1R1_FB5_Pos (5U)
2632#define CAN_F1R1_FB5_Msk (0x1U << CAN_F1R1_FB5_Pos) /*!< 0x00000020 */
2633#define CAN_F1R1_FB5 CAN_F1R1_FB5_Msk /*!<Filter bit 5 */
2634#define CAN_F1R1_FB6_Pos (6U)
2635#define CAN_F1R1_FB6_Msk (0x1U << CAN_F1R1_FB6_Pos) /*!< 0x00000040 */
2636#define CAN_F1R1_FB6 CAN_F1R1_FB6_Msk /*!<Filter bit 6 */
2637#define CAN_F1R1_FB7_Pos (7U)
2638#define CAN_F1R1_FB7_Msk (0x1U << CAN_F1R1_FB7_Pos) /*!< 0x00000080 */
2639#define CAN_F1R1_FB7 CAN_F1R1_FB7_Msk /*!<Filter bit 7 */
2640#define CAN_F1R1_FB8_Pos (8U)
2641#define CAN_F1R1_FB8_Msk (0x1U << CAN_F1R1_FB8_Pos) /*!< 0x00000100 */
2642#define CAN_F1R1_FB8 CAN_F1R1_FB8_Msk /*!<Filter bit 8 */
2643#define CAN_F1R1_FB9_Pos (9U)
2644#define CAN_F1R1_FB9_Msk (0x1U << CAN_F1R1_FB9_Pos) /*!< 0x00000200 */
2645#define CAN_F1R1_FB9 CAN_F1R1_FB9_Msk /*!<Filter bit 9 */
2646#define CAN_F1R1_FB10_Pos (10U)
2647#define CAN_F1R1_FB10_Msk (0x1U << CAN_F1R1_FB10_Pos) /*!< 0x00000400 */
2648#define CAN_F1R1_FB10 CAN_F1R1_FB10_Msk /*!<Filter bit 10 */
2649#define CAN_F1R1_FB11_Pos (11U)
2650#define CAN_F1R1_FB11_Msk (0x1U << CAN_F1R1_FB11_Pos) /*!< 0x00000800 */
2651#define CAN_F1R1_FB11 CAN_F1R1_FB11_Msk /*!<Filter bit 11 */
2652#define CAN_F1R1_FB12_Pos (12U)
2653#define CAN_F1R1_FB12_Msk (0x1U << CAN_F1R1_FB12_Pos) /*!< 0x00001000 */
2654#define CAN_F1R1_FB12 CAN_F1R1_FB12_Msk /*!<Filter bit 12 */
2655#define CAN_F1R1_FB13_Pos (13U)
2656#define CAN_F1R1_FB13_Msk (0x1U << CAN_F1R1_FB13_Pos) /*!< 0x00002000 */
2657#define CAN_F1R1_FB13 CAN_F1R1_FB13_Msk /*!<Filter bit 13 */
2658#define CAN_F1R1_FB14_Pos (14U)
2659#define CAN_F1R1_FB14_Msk (0x1U << CAN_F1R1_FB14_Pos) /*!< 0x00004000 */
2660#define CAN_F1R1_FB14 CAN_F1R1_FB14_Msk /*!<Filter bit 14 */
2661#define CAN_F1R1_FB15_Pos (15U)
2662#define CAN_F1R1_FB15_Msk (0x1U << CAN_F1R1_FB15_Pos) /*!< 0x00008000 */
2663#define CAN_F1R1_FB15 CAN_F1R1_FB15_Msk /*!<Filter bit 15 */
2664#define CAN_F1R1_FB16_Pos (16U)
2665#define CAN_F1R1_FB16_Msk (0x1U << CAN_F1R1_FB16_Pos) /*!< 0x00010000 */
2666#define CAN_F1R1_FB16 CAN_F1R1_FB16_Msk /*!<Filter bit 16 */
2667#define CAN_F1R1_FB17_Pos (17U)
2668#define CAN_F1R1_FB17_Msk (0x1U << CAN_F1R1_FB17_Pos) /*!< 0x00020000 */
2669#define CAN_F1R1_FB17 CAN_F1R1_FB17_Msk /*!<Filter bit 17 */
2670#define CAN_F1R1_FB18_Pos (18U)
2671#define CAN_F1R1_FB18_Msk (0x1U << CAN_F1R1_FB18_Pos) /*!< 0x00040000 */
2672#define CAN_F1R1_FB18 CAN_F1R1_FB18_Msk /*!<Filter bit 18 */
2673#define CAN_F1R1_FB19_Pos (19U)
2674#define CAN_F1R1_FB19_Msk (0x1U << CAN_F1R1_FB19_Pos) /*!< 0x00080000 */
2675#define CAN_F1R1_FB19 CAN_F1R1_FB19_Msk /*!<Filter bit 19 */
2676#define CAN_F1R1_FB20_Pos (20U)
2677#define CAN_F1R1_FB20_Msk (0x1U << CAN_F1R1_FB20_Pos) /*!< 0x00100000 */
2678#define CAN_F1R1_FB20 CAN_F1R1_FB20_Msk /*!<Filter bit 20 */
2679#define CAN_F1R1_FB21_Pos (21U)
2680#define CAN_F1R1_FB21_Msk (0x1U << CAN_F1R1_FB21_Pos) /*!< 0x00200000 */
2681#define CAN_F1R1_FB21 CAN_F1R1_FB21_Msk /*!<Filter bit 21 */
2682#define CAN_F1R1_FB22_Pos (22U)
2683#define CAN_F1R1_FB22_Msk (0x1U << CAN_F1R1_FB22_Pos) /*!< 0x00400000 */
2684#define CAN_F1R1_FB22 CAN_F1R1_FB22_Msk /*!<Filter bit 22 */
2685#define CAN_F1R1_FB23_Pos (23U)
2686#define CAN_F1R1_FB23_Msk (0x1U << CAN_F1R1_FB23_Pos) /*!< 0x00800000 */
2687#define CAN_F1R1_FB23 CAN_F1R1_FB23_Msk /*!<Filter bit 23 */
2688#define CAN_F1R1_FB24_Pos (24U)
2689#define CAN_F1R1_FB24_Msk (0x1U << CAN_F1R1_FB24_Pos) /*!< 0x01000000 */
2690#define CAN_F1R1_FB24 CAN_F1R1_FB24_Msk /*!<Filter bit 24 */
2691#define CAN_F1R1_FB25_Pos (25U)
2692#define CAN_F1R1_FB25_Msk (0x1U << CAN_F1R1_FB25_Pos) /*!< 0x02000000 */
2693#define CAN_F1R1_FB25 CAN_F1R1_FB25_Msk /*!<Filter bit 25 */
2694#define CAN_F1R1_FB26_Pos (26U)
2695#define CAN_F1R1_FB26_Msk (0x1U << CAN_F1R1_FB26_Pos) /*!< 0x04000000 */
2696#define CAN_F1R1_FB26 CAN_F1R1_FB26_Msk /*!<Filter bit 26 */
2697#define CAN_F1R1_FB27_Pos (27U)
2698#define CAN_F1R1_FB27_Msk (0x1U << CAN_F1R1_FB27_Pos) /*!< 0x08000000 */
2699#define CAN_F1R1_FB27 CAN_F1R1_FB27_Msk /*!<Filter bit 27 */
2700#define CAN_F1R1_FB28_Pos (28U)
2701#define CAN_F1R1_FB28_Msk (0x1U << CAN_F1R1_FB28_Pos) /*!< 0x10000000 */
2702#define CAN_F1R1_FB28 CAN_F1R1_FB28_Msk /*!<Filter bit 28 */
2703#define CAN_F1R1_FB29_Pos (29U)
2704#define CAN_F1R1_FB29_Msk (0x1U << CAN_F1R1_FB29_Pos) /*!< 0x20000000 */
2705#define CAN_F1R1_FB29 CAN_F1R1_FB29_Msk /*!<Filter bit 29 */
2706#define CAN_F1R1_FB30_Pos (30U)
2707#define CAN_F1R1_FB30_Msk (0x1U << CAN_F1R1_FB30_Pos) /*!< 0x40000000 */
2708#define CAN_F1R1_FB30 CAN_F1R1_FB30_Msk /*!<Filter bit 30 */
2709#define CAN_F1R1_FB31_Pos (31U)
2710#define CAN_F1R1_FB31_Msk (0x1U << CAN_F1R1_FB31_Pos) /*!< 0x80000000 */
2711#define CAN_F1R1_FB31 CAN_F1R1_FB31_Msk /*!<Filter bit 31 */
2712
2713/******************* Bit definition for CAN_F2R1 register *******************/
2714#define CAN_F2R1_FB0_Pos (0U)
2715#define CAN_F2R1_FB0_Msk (0x1U << CAN_F2R1_FB0_Pos) /*!< 0x00000001 */
2716#define CAN_F2R1_FB0 CAN_F2R1_FB0_Msk /*!<Filter bit 0 */
2717#define CAN_F2R1_FB1_Pos (1U)
2718#define CAN_F2R1_FB1_Msk (0x1U << CAN_F2R1_FB1_Pos) /*!< 0x00000002 */
2719#define CAN_F2R1_FB1 CAN_F2R1_FB1_Msk /*!<Filter bit 1 */
2720#define CAN_F2R1_FB2_Pos (2U)
2721#define CAN_F2R1_FB2_Msk (0x1U << CAN_F2R1_FB2_Pos) /*!< 0x00000004 */
2722#define CAN_F2R1_FB2 CAN_F2R1_FB2_Msk /*!<Filter bit 2 */
2723#define CAN_F2R1_FB3_Pos (3U)
2724#define CAN_F2R1_FB3_Msk (0x1U << CAN_F2R1_FB3_Pos) /*!< 0x00000008 */
2725#define CAN_F2R1_FB3 CAN_F2R1_FB3_Msk /*!<Filter bit 3 */
2726#define CAN_F2R1_FB4_Pos (4U)
2727#define CAN_F2R1_FB4_Msk (0x1U << CAN_F2R1_FB4_Pos) /*!< 0x00000010 */
2728#define CAN_F2R1_FB4 CAN_F2R1_FB4_Msk /*!<Filter bit 4 */
2729#define CAN_F2R1_FB5_Pos (5U)
2730#define CAN_F2R1_FB5_Msk (0x1U << CAN_F2R1_FB5_Pos) /*!< 0x00000020 */
2731#define CAN_F2R1_FB5 CAN_F2R1_FB5_Msk /*!<Filter bit 5 */
2732#define CAN_F2R1_FB6_Pos (6U)
2733#define CAN_F2R1_FB6_Msk (0x1U << CAN_F2R1_FB6_Pos) /*!< 0x00000040 */
2734#define CAN_F2R1_FB6 CAN_F2R1_FB6_Msk /*!<Filter bit 6 */
2735#define CAN_F2R1_FB7_Pos (7U)
2736#define CAN_F2R1_FB7_Msk (0x1U << CAN_F2R1_FB7_Pos) /*!< 0x00000080 */
2737#define CAN_F2R1_FB7 CAN_F2R1_FB7_Msk /*!<Filter bit 7 */
2738#define CAN_F2R1_FB8_Pos (8U)
2739#define CAN_F2R1_FB8_Msk (0x1U << CAN_F2R1_FB8_Pos) /*!< 0x00000100 */
2740#define CAN_F2R1_FB8 CAN_F2R1_FB8_Msk /*!<Filter bit 8 */
2741#define CAN_F2R1_FB9_Pos (9U)
2742#define CAN_F2R1_FB9_Msk (0x1U << CAN_F2R1_FB9_Pos) /*!< 0x00000200 */
2743#define CAN_F2R1_FB9 CAN_F2R1_FB9_Msk /*!<Filter bit 9 */
2744#define CAN_F2R1_FB10_Pos (10U)
2745#define CAN_F2R1_FB10_Msk (0x1U << CAN_F2R1_FB10_Pos) /*!< 0x00000400 */
2746#define CAN_F2R1_FB10 CAN_F2R1_FB10_Msk /*!<Filter bit 10 */
2747#define CAN_F2R1_FB11_Pos (11U)
2748#define CAN_F2R1_FB11_Msk (0x1U << CAN_F2R1_FB11_Pos) /*!< 0x00000800 */
2749#define CAN_F2R1_FB11 CAN_F2R1_FB11_Msk /*!<Filter bit 11 */
2750#define CAN_F2R1_FB12_Pos (12U)
2751#define CAN_F2R1_FB12_Msk (0x1U << CAN_F2R1_FB12_Pos) /*!< 0x00001000 */
2752#define CAN_F2R1_FB12 CAN_F2R1_FB12_Msk /*!<Filter bit 12 */
2753#define CAN_F2R1_FB13_Pos (13U)
2754#define CAN_F2R1_FB13_Msk (0x1U << CAN_F2R1_FB13_Pos) /*!< 0x00002000 */
2755#define CAN_F2R1_FB13 CAN_F2R1_FB13_Msk /*!<Filter bit 13 */
2756#define CAN_F2R1_FB14_Pos (14U)
2757#define CAN_F2R1_FB14_Msk (0x1U << CAN_F2R1_FB14_Pos) /*!< 0x00004000 */
2758#define CAN_F2R1_FB14 CAN_F2R1_FB14_Msk /*!<Filter bit 14 */
2759#define CAN_F2R1_FB15_Pos (15U)
2760#define CAN_F2R1_FB15_Msk (0x1U << CAN_F2R1_FB15_Pos) /*!< 0x00008000 */
2761#define CAN_F2R1_FB15 CAN_F2R1_FB15_Msk /*!<Filter bit 15 */
2762#define CAN_F2R1_FB16_Pos (16U)
2763#define CAN_F2R1_FB16_Msk (0x1U << CAN_F2R1_FB16_Pos) /*!< 0x00010000 */
2764#define CAN_F2R1_FB16 CAN_F2R1_FB16_Msk /*!<Filter bit 16 */
2765#define CAN_F2R1_FB17_Pos (17U)
2766#define CAN_F2R1_FB17_Msk (0x1U << CAN_F2R1_FB17_Pos) /*!< 0x00020000 */
2767#define CAN_F2R1_FB17 CAN_F2R1_FB17_Msk /*!<Filter bit 17 */
2768#define CAN_F2R1_FB18_Pos (18U)
2769#define CAN_F2R1_FB18_Msk (0x1U << CAN_F2R1_FB18_Pos) /*!< 0x00040000 */
2770#define CAN_F2R1_FB18 CAN_F2R1_FB18_Msk /*!<Filter bit 18 */
2771#define CAN_F2R1_FB19_Pos (19U)
2772#define CAN_F2R1_FB19_Msk (0x1U << CAN_F2R1_FB19_Pos) /*!< 0x00080000 */
2773#define CAN_F2R1_FB19 CAN_F2R1_FB19_Msk /*!<Filter bit 19 */
2774#define CAN_F2R1_FB20_Pos (20U)
2775#define CAN_F2R1_FB20_Msk (0x1U << CAN_F2R1_FB20_Pos) /*!< 0x00100000 */
2776#define CAN_F2R1_FB20 CAN_F2R1_FB20_Msk /*!<Filter bit 20 */
2777#define CAN_F2R1_FB21_Pos (21U)
2778#define CAN_F2R1_FB21_Msk (0x1U << CAN_F2R1_FB21_Pos) /*!< 0x00200000 */
2779#define CAN_F2R1_FB21 CAN_F2R1_FB21_Msk /*!<Filter bit 21 */
2780#define CAN_F2R1_FB22_Pos (22U)
2781#define CAN_F2R1_FB22_Msk (0x1U << CAN_F2R1_FB22_Pos) /*!< 0x00400000 */
2782#define CAN_F2R1_FB22 CAN_F2R1_FB22_Msk /*!<Filter bit 22 */
2783#define CAN_F2R1_FB23_Pos (23U)
2784#define CAN_F2R1_FB23_Msk (0x1U << CAN_F2R1_FB23_Pos) /*!< 0x00800000 */
2785#define CAN_F2R1_FB23 CAN_F2R1_FB23_Msk /*!<Filter bit 23 */
2786#define CAN_F2R1_FB24_Pos (24U)
2787#define CAN_F2R1_FB24_Msk (0x1U << CAN_F2R1_FB24_Pos) /*!< 0x01000000 */
2788#define CAN_F2R1_FB24 CAN_F2R1_FB24_Msk /*!<Filter bit 24 */
2789#define CAN_F2R1_FB25_Pos (25U)
2790#define CAN_F2R1_FB25_Msk (0x1U << CAN_F2R1_FB25_Pos) /*!< 0x02000000 */
2791#define CAN_F2R1_FB25 CAN_F2R1_FB25_Msk /*!<Filter bit 25 */
2792#define CAN_F2R1_FB26_Pos (26U)
2793#define CAN_F2R1_FB26_Msk (0x1U << CAN_F2R1_FB26_Pos) /*!< 0x04000000 */
2794#define CAN_F2R1_FB26 CAN_F2R1_FB26_Msk /*!<Filter bit 26 */
2795#define CAN_F2R1_FB27_Pos (27U)
2796#define CAN_F2R1_FB27_Msk (0x1U << CAN_F2R1_FB27_Pos) /*!< 0x08000000 */
2797#define CAN_F2R1_FB27 CAN_F2R1_FB27_Msk /*!<Filter bit 27 */
2798#define CAN_F2R1_FB28_Pos (28U)
2799#define CAN_F2R1_FB28_Msk (0x1U << CAN_F2R1_FB28_Pos) /*!< 0x10000000 */
2800#define CAN_F2R1_FB28 CAN_F2R1_FB28_Msk /*!<Filter bit 28 */
2801#define CAN_F2R1_FB29_Pos (29U)
2802#define CAN_F2R1_FB29_Msk (0x1U << CAN_F2R1_FB29_Pos) /*!< 0x20000000 */
2803#define CAN_F2R1_FB29 CAN_F2R1_FB29_Msk /*!<Filter bit 29 */
2804#define CAN_F2R1_FB30_Pos (30U)
2805#define CAN_F2R1_FB30_Msk (0x1U << CAN_F2R1_FB30_Pos) /*!< 0x40000000 */
2806#define CAN_F2R1_FB30 CAN_F2R1_FB30_Msk /*!<Filter bit 30 */
2807#define CAN_F2R1_FB31_Pos (31U)
2808#define CAN_F2R1_FB31_Msk (0x1U << CAN_F2R1_FB31_Pos) /*!< 0x80000000 */
2809#define CAN_F2R1_FB31 CAN_F2R1_FB31_Msk /*!<Filter bit 31 */
2810
2811/******************* Bit definition for CAN_F3R1 register *******************/
2812#define CAN_F3R1_FB0_Pos (0U)
2813#define CAN_F3R1_FB0_Msk (0x1U << CAN_F3R1_FB0_Pos) /*!< 0x00000001 */
2814#define CAN_F3R1_FB0 CAN_F3R1_FB0_Msk /*!<Filter bit 0 */
2815#define CAN_F3R1_FB1_Pos (1U)
2816#define CAN_F3R1_FB1_Msk (0x1U << CAN_F3R1_FB1_Pos) /*!< 0x00000002 */
2817#define CAN_F3R1_FB1 CAN_F3R1_FB1_Msk /*!<Filter bit 1 */
2818#define CAN_F3R1_FB2_Pos (2U)
2819#define CAN_F3R1_FB2_Msk (0x1U << CAN_F3R1_FB2_Pos) /*!< 0x00000004 */
2820#define CAN_F3R1_FB2 CAN_F3R1_FB2_Msk /*!<Filter bit 2 */
2821#define CAN_F3R1_FB3_Pos (3U)
2822#define CAN_F3R1_FB3_Msk (0x1U << CAN_F3R1_FB3_Pos) /*!< 0x00000008 */
2823#define CAN_F3R1_FB3 CAN_F3R1_FB3_Msk /*!<Filter bit 3 */
2824#define CAN_F3R1_FB4_Pos (4U)
2825#define CAN_F3R1_FB4_Msk (0x1U << CAN_F3R1_FB4_Pos) /*!< 0x00000010 */
2826#define CAN_F3R1_FB4 CAN_F3R1_FB4_Msk /*!<Filter bit 4 */
2827#define CAN_F3R1_FB5_Pos (5U)
2828#define CAN_F3R1_FB5_Msk (0x1U << CAN_F3R1_FB5_Pos) /*!< 0x00000020 */
2829#define CAN_F3R1_FB5 CAN_F3R1_FB5_Msk /*!<Filter bit 5 */
2830#define CAN_F3R1_FB6_Pos (6U)
2831#define CAN_F3R1_FB6_Msk (0x1U << CAN_F3R1_FB6_Pos) /*!< 0x00000040 */
2832#define CAN_F3R1_FB6 CAN_F3R1_FB6_Msk /*!<Filter bit 6 */
2833#define CAN_F3R1_FB7_Pos (7U)
2834#define CAN_F3R1_FB7_Msk (0x1U << CAN_F3R1_FB7_Pos) /*!< 0x00000080 */
2835#define CAN_F3R1_FB7 CAN_F3R1_FB7_Msk /*!<Filter bit 7 */
2836#define CAN_F3R1_FB8_Pos (8U)
2837#define CAN_F3R1_FB8_Msk (0x1U << CAN_F3R1_FB8_Pos) /*!< 0x00000100 */
2838#define CAN_F3R1_FB8 CAN_F3R1_FB8_Msk /*!<Filter bit 8 */
2839#define CAN_F3R1_FB9_Pos (9U)
2840#define CAN_F3R1_FB9_Msk (0x1U << CAN_F3R1_FB9_Pos) /*!< 0x00000200 */
2841#define CAN_F3R1_FB9 CAN_F3R1_FB9_Msk /*!<Filter bit 9 */
2842#define CAN_F3R1_FB10_Pos (10U)
2843#define CAN_F3R1_FB10_Msk (0x1U << CAN_F3R1_FB10_Pos) /*!< 0x00000400 */
2844#define CAN_F3R1_FB10 CAN_F3R1_FB10_Msk /*!<Filter bit 10 */
2845#define CAN_F3R1_FB11_Pos (11U)
2846#define CAN_F3R1_FB11_Msk (0x1U << CAN_F3R1_FB11_Pos) /*!< 0x00000800 */
2847#define CAN_F3R1_FB11 CAN_F3R1_FB11_Msk /*!<Filter bit 11 */
2848#define CAN_F3R1_FB12_Pos (12U)
2849#define CAN_F3R1_FB12_Msk (0x1U << CAN_F3R1_FB12_Pos) /*!< 0x00001000 */
2850#define CAN_F3R1_FB12 CAN_F3R1_FB12_Msk /*!<Filter bit 12 */
2851#define CAN_F3R1_FB13_Pos (13U)
2852#define CAN_F3R1_FB13_Msk (0x1U << CAN_F3R1_FB13_Pos) /*!< 0x00002000 */
2853#define CAN_F3R1_FB13 CAN_F3R1_FB13_Msk /*!<Filter bit 13 */
2854#define CAN_F3R1_FB14_Pos (14U)
2855#define CAN_F3R1_FB14_Msk (0x1U << CAN_F3R1_FB14_Pos) /*!< 0x00004000 */
2856#define CAN_F3R1_FB14 CAN_F3R1_FB14_Msk /*!<Filter bit 14 */
2857#define CAN_F3R1_FB15_Pos (15U)
2858#define CAN_F3R1_FB15_Msk (0x1U << CAN_F3R1_FB15_Pos) /*!< 0x00008000 */
2859#define CAN_F3R1_FB15 CAN_F3R1_FB15_Msk /*!<Filter bit 15 */
2860#define CAN_F3R1_FB16_Pos (16U)
2861#define CAN_F3R1_FB16_Msk (0x1U << CAN_F3R1_FB16_Pos) /*!< 0x00010000 */
2862#define CAN_F3R1_FB16 CAN_F3R1_FB16_Msk /*!<Filter bit 16 */
2863#define CAN_F3R1_FB17_Pos (17U)
2864#define CAN_F3R1_FB17_Msk (0x1U << CAN_F3R1_FB17_Pos) /*!< 0x00020000 */
2865#define CAN_F3R1_FB17 CAN_F3R1_FB17_Msk /*!<Filter bit 17 */
2866#define CAN_F3R1_FB18_Pos (18U)
2867#define CAN_F3R1_FB18_Msk (0x1U << CAN_F3R1_FB18_Pos) /*!< 0x00040000 */
2868#define CAN_F3R1_FB18 CAN_F3R1_FB18_Msk /*!<Filter bit 18 */
2869#define CAN_F3R1_FB19_Pos (19U)
2870#define CAN_F3R1_FB19_Msk (0x1U << CAN_F3R1_FB19_Pos) /*!< 0x00080000 */
2871#define CAN_F3R1_FB19 CAN_F3R1_FB19_Msk /*!<Filter bit 19 */
2872#define CAN_F3R1_FB20_Pos (20U)
2873#define CAN_F3R1_FB20_Msk (0x1U << CAN_F3R1_FB20_Pos) /*!< 0x00100000 */
2874#define CAN_F3R1_FB20 CAN_F3R1_FB20_Msk /*!<Filter bit 20 */
2875#define CAN_F3R1_FB21_Pos (21U)
2876#define CAN_F3R1_FB21_Msk (0x1U << CAN_F3R1_FB21_Pos) /*!< 0x00200000 */
2877#define CAN_F3R1_FB21 CAN_F3R1_FB21_Msk /*!<Filter bit 21 */
2878#define CAN_F3R1_FB22_Pos (22U)
2879#define CAN_F3R1_FB22_Msk (0x1U << CAN_F3R1_FB22_Pos) /*!< 0x00400000 */
2880#define CAN_F3R1_FB22 CAN_F3R1_FB22_Msk /*!<Filter bit 22 */
2881#define CAN_F3R1_FB23_Pos (23U)
2882#define CAN_F3R1_FB23_Msk (0x1U << CAN_F3R1_FB23_Pos) /*!< 0x00800000 */
2883#define CAN_F3R1_FB23 CAN_F3R1_FB23_Msk /*!<Filter bit 23 */
2884#define CAN_F3R1_FB24_Pos (24U)
2885#define CAN_F3R1_FB24_Msk (0x1U << CAN_F3R1_FB24_Pos) /*!< 0x01000000 */
2886#define CAN_F3R1_FB24 CAN_F3R1_FB24_Msk /*!<Filter bit 24 */
2887#define CAN_F3R1_FB25_Pos (25U)
2888#define CAN_F3R1_FB25_Msk (0x1U << CAN_F3R1_FB25_Pos) /*!< 0x02000000 */
2889#define CAN_F3R1_FB25 CAN_F3R1_FB25_Msk /*!<Filter bit 25 */
2890#define CAN_F3R1_FB26_Pos (26U)
2891#define CAN_F3R1_FB26_Msk (0x1U << CAN_F3R1_FB26_Pos) /*!< 0x04000000 */
2892#define CAN_F3R1_FB26 CAN_F3R1_FB26_Msk /*!<Filter bit 26 */
2893#define CAN_F3R1_FB27_Pos (27U)
2894#define CAN_F3R1_FB27_Msk (0x1U << CAN_F3R1_FB27_Pos) /*!< 0x08000000 */
2895#define CAN_F3R1_FB27 CAN_F3R1_FB27_Msk /*!<Filter bit 27 */
2896#define CAN_F3R1_FB28_Pos (28U)
2897#define CAN_F3R1_FB28_Msk (0x1U << CAN_F3R1_FB28_Pos) /*!< 0x10000000 */
2898#define CAN_F3R1_FB28 CAN_F3R1_FB28_Msk /*!<Filter bit 28 */
2899#define CAN_F3R1_FB29_Pos (29U)
2900#define CAN_F3R1_FB29_Msk (0x1U << CAN_F3R1_FB29_Pos) /*!< 0x20000000 */
2901#define CAN_F3R1_FB29 CAN_F3R1_FB29_Msk /*!<Filter bit 29 */
2902#define CAN_F3R1_FB30_Pos (30U)
2903#define CAN_F3R1_FB30_Msk (0x1U << CAN_F3R1_FB30_Pos) /*!< 0x40000000 */
2904#define CAN_F3R1_FB30 CAN_F3R1_FB30_Msk /*!<Filter bit 30 */
2905#define CAN_F3R1_FB31_Pos (31U)
2906#define CAN_F3R1_FB31_Msk (0x1U << CAN_F3R1_FB31_Pos) /*!< 0x80000000 */
2907#define CAN_F3R1_FB31 CAN_F3R1_FB31_Msk /*!<Filter bit 31 */
2908
2909/******************* Bit definition for CAN_F4R1 register *******************/
2910#define CAN_F4R1_FB0_Pos (0U)
2911#define CAN_F4R1_FB0_Msk (0x1U << CAN_F4R1_FB0_Pos) /*!< 0x00000001 */
2912#define CAN_F4R1_FB0 CAN_F4R1_FB0_Msk /*!<Filter bit 0 */
2913#define CAN_F4R1_FB1_Pos (1U)
2914#define CAN_F4R1_FB1_Msk (0x1U << CAN_F4R1_FB1_Pos) /*!< 0x00000002 */
2915#define CAN_F4R1_FB1 CAN_F4R1_FB1_Msk /*!<Filter bit 1 */
2916#define CAN_F4R1_FB2_Pos (2U)
2917#define CAN_F4R1_FB2_Msk (0x1U << CAN_F4R1_FB2_Pos) /*!< 0x00000004 */
2918#define CAN_F4R1_FB2 CAN_F4R1_FB2_Msk /*!<Filter bit 2 */
2919#define CAN_F4R1_FB3_Pos (3U)
2920#define CAN_F4R1_FB3_Msk (0x1U << CAN_F4R1_FB3_Pos) /*!< 0x00000008 */
2921#define CAN_F4R1_FB3 CAN_F4R1_FB3_Msk /*!<Filter bit 3 */
2922#define CAN_F4R1_FB4_Pos (4U)
2923#define CAN_F4R1_FB4_Msk (0x1U << CAN_F4R1_FB4_Pos) /*!< 0x00000010 */
2924#define CAN_F4R1_FB4 CAN_F4R1_FB4_Msk /*!<Filter bit 4 */
2925#define CAN_F4R1_FB5_Pos (5U)
2926#define CAN_F4R1_FB5_Msk (0x1U << CAN_F4R1_FB5_Pos) /*!< 0x00000020 */
2927#define CAN_F4R1_FB5 CAN_F4R1_FB5_Msk /*!<Filter bit 5 */
2928#define CAN_F4R1_FB6_Pos (6U)
2929#define CAN_F4R1_FB6_Msk (0x1U << CAN_F4R1_FB6_Pos) /*!< 0x00000040 */
2930#define CAN_F4R1_FB6 CAN_F4R1_FB6_Msk /*!<Filter bit 6 */
2931#define CAN_F4R1_FB7_Pos (7U)
2932#define CAN_F4R1_FB7_Msk (0x1U << CAN_F4R1_FB7_Pos) /*!< 0x00000080 */
2933#define CAN_F4R1_FB7 CAN_F4R1_FB7_Msk /*!<Filter bit 7 */
2934#define CAN_F4R1_FB8_Pos (8U)
2935#define CAN_F4R1_FB8_Msk (0x1U << CAN_F4R1_FB8_Pos) /*!< 0x00000100 */
2936#define CAN_F4R1_FB8 CAN_F4R1_FB8_Msk /*!<Filter bit 8 */
2937#define CAN_F4R1_FB9_Pos (9U)
2938#define CAN_F4R1_FB9_Msk (0x1U << CAN_F4R1_FB9_Pos) /*!< 0x00000200 */
2939#define CAN_F4R1_FB9 CAN_F4R1_FB9_Msk /*!<Filter bit 9 */
2940#define CAN_F4R1_FB10_Pos (10U)
2941#define CAN_F4R1_FB10_Msk (0x1U << CAN_F4R1_FB10_Pos) /*!< 0x00000400 */
2942#define CAN_F4R1_FB10 CAN_F4R1_FB10_Msk /*!<Filter bit 10 */
2943#define CAN_F4R1_FB11_Pos (11U)
2944#define CAN_F4R1_FB11_Msk (0x1U << CAN_F4R1_FB11_Pos) /*!< 0x00000800 */
2945#define CAN_F4R1_FB11 CAN_F4R1_FB11_Msk /*!<Filter bit 11 */
2946#define CAN_F4R1_FB12_Pos (12U)
2947#define CAN_F4R1_FB12_Msk (0x1U << CAN_F4R1_FB12_Pos) /*!< 0x00001000 */
2948#define CAN_F4R1_FB12 CAN_F4R1_FB12_Msk /*!<Filter bit 12 */
2949#define CAN_F4R1_FB13_Pos (13U)
2950#define CAN_F4R1_FB13_Msk (0x1U << CAN_F4R1_FB13_Pos) /*!< 0x00002000 */
2951#define CAN_F4R1_FB13 CAN_F4R1_FB13_Msk /*!<Filter bit 13 */
2952#define CAN_F4R1_FB14_Pos (14U)
2953#define CAN_F4R1_FB14_Msk (0x1U << CAN_F4R1_FB14_Pos) /*!< 0x00004000 */
2954#define CAN_F4R1_FB14 CAN_F4R1_FB14_Msk /*!<Filter bit 14 */
2955#define CAN_F4R1_FB15_Pos (15U)
2956#define CAN_F4R1_FB15_Msk (0x1U << CAN_F4R1_FB15_Pos) /*!< 0x00008000 */
2957#define CAN_F4R1_FB15 CAN_F4R1_FB15_Msk /*!<Filter bit 15 */
2958#define CAN_F4R1_FB16_Pos (16U)
2959#define CAN_F4R1_FB16_Msk (0x1U << CAN_F4R1_FB16_Pos) /*!< 0x00010000 */
2960#define CAN_F4R1_FB16 CAN_F4R1_FB16_Msk /*!<Filter bit 16 */
2961#define CAN_F4R1_FB17_Pos (17U)
2962#define CAN_F4R1_FB17_Msk (0x1U << CAN_F4R1_FB17_Pos) /*!< 0x00020000 */
2963#define CAN_F4R1_FB17 CAN_F4R1_FB17_Msk /*!<Filter bit 17 */
2964#define CAN_F4R1_FB18_Pos (18U)
2965#define CAN_F4R1_FB18_Msk (0x1U << CAN_F4R1_FB18_Pos) /*!< 0x00040000 */
2966#define CAN_F4R1_FB18 CAN_F4R1_FB18_Msk /*!<Filter bit 18 */
2967#define CAN_F4R1_FB19_Pos (19U)
2968#define CAN_F4R1_FB19_Msk (0x1U << CAN_F4R1_FB19_Pos) /*!< 0x00080000 */
2969#define CAN_F4R1_FB19 CAN_F4R1_FB19_Msk /*!<Filter bit 19 */
2970#define CAN_F4R1_FB20_Pos (20U)
2971#define CAN_F4R1_FB20_Msk (0x1U << CAN_F4R1_FB20_Pos) /*!< 0x00100000 */
2972#define CAN_F4R1_FB20 CAN_F4R1_FB20_Msk /*!<Filter bit 20 */
2973#define CAN_F4R1_FB21_Pos (21U)
2974#define CAN_F4R1_FB21_Msk (0x1U << CAN_F4R1_FB21_Pos) /*!< 0x00200000 */
2975#define CAN_F4R1_FB21 CAN_F4R1_FB21_Msk /*!<Filter bit 21 */
2976#define CAN_F4R1_FB22_Pos (22U)
2977#define CAN_F4R1_FB22_Msk (0x1U << CAN_F4R1_FB22_Pos) /*!< 0x00400000 */
2978#define CAN_F4R1_FB22 CAN_F4R1_FB22_Msk /*!<Filter bit 22 */
2979#define CAN_F4R1_FB23_Pos (23U)
2980#define CAN_F4R1_FB23_Msk (0x1U << CAN_F4R1_FB23_Pos) /*!< 0x00800000 */
2981#define CAN_F4R1_FB23 CAN_F4R1_FB23_Msk /*!<Filter bit 23 */
2982#define CAN_F4R1_FB24_Pos (24U)
2983#define CAN_F4R1_FB24_Msk (0x1U << CAN_F4R1_FB24_Pos) /*!< 0x01000000 */
2984#define CAN_F4R1_FB24 CAN_F4R1_FB24_Msk /*!<Filter bit 24 */
2985#define CAN_F4R1_FB25_Pos (25U)
2986#define CAN_F4R1_FB25_Msk (0x1U << CAN_F4R1_FB25_Pos) /*!< 0x02000000 */
2987#define CAN_F4R1_FB25 CAN_F4R1_FB25_Msk /*!<Filter bit 25 */
2988#define CAN_F4R1_FB26_Pos (26U)
2989#define CAN_F4R1_FB26_Msk (0x1U << CAN_F4R1_FB26_Pos) /*!< 0x04000000 */
2990#define CAN_F4R1_FB26 CAN_F4R1_FB26_Msk /*!<Filter bit 26 */
2991#define CAN_F4R1_FB27_Pos (27U)
2992#define CAN_F4R1_FB27_Msk (0x1U << CAN_F4R1_FB27_Pos) /*!< 0x08000000 */
2993#define CAN_F4R1_FB27 CAN_F4R1_FB27_Msk /*!<Filter bit 27 */
2994#define CAN_F4R1_FB28_Pos (28U)
2995#define CAN_F4R1_FB28_Msk (0x1U << CAN_F4R1_FB28_Pos) /*!< 0x10000000 */
2996#define CAN_F4R1_FB28 CAN_F4R1_FB28_Msk /*!<Filter bit 28 */
2997#define CAN_F4R1_FB29_Pos (29U)
2998#define CAN_F4R1_FB29_Msk (0x1U << CAN_F4R1_FB29_Pos) /*!< 0x20000000 */
2999#define CAN_F4R1_FB29 CAN_F4R1_FB29_Msk /*!<Filter bit 29 */
3000#define CAN_F4R1_FB30_Pos (30U)
3001#define CAN_F4R1_FB30_Msk (0x1U << CAN_F4R1_FB30_Pos) /*!< 0x40000000 */
3002#define CAN_F4R1_FB30 CAN_F4R1_FB30_Msk /*!<Filter bit 30 */
3003#define CAN_F4R1_FB31_Pos (31U)
3004#define CAN_F4R1_FB31_Msk (0x1U << CAN_F4R1_FB31_Pos) /*!< 0x80000000 */
3005#define CAN_F4R1_FB31 CAN_F4R1_FB31_Msk /*!<Filter bit 31 */
3006
3007/******************* Bit definition for CAN_F5R1 register *******************/
3008#define CAN_F5R1_FB0_Pos (0U)
3009#define CAN_F5R1_FB0_Msk (0x1U << CAN_F5R1_FB0_Pos) /*!< 0x00000001 */
3010#define CAN_F5R1_FB0 CAN_F5R1_FB0_Msk /*!<Filter bit 0 */
3011#define CAN_F5R1_FB1_Pos (1U)
3012#define CAN_F5R1_FB1_Msk (0x1U << CAN_F5R1_FB1_Pos) /*!< 0x00000002 */
3013#define CAN_F5R1_FB1 CAN_F5R1_FB1_Msk /*!<Filter bit 1 */
3014#define CAN_F5R1_FB2_Pos (2U)
3015#define CAN_F5R1_FB2_Msk (0x1U << CAN_F5R1_FB2_Pos) /*!< 0x00000004 */
3016#define CAN_F5R1_FB2 CAN_F5R1_FB2_Msk /*!<Filter bit 2 */
3017#define CAN_F5R1_FB3_Pos (3U)
3018#define CAN_F5R1_FB3_Msk (0x1U << CAN_F5R1_FB3_Pos) /*!< 0x00000008 */
3019#define CAN_F5R1_FB3 CAN_F5R1_FB3_Msk /*!<Filter bit 3 */
3020#define CAN_F5R1_FB4_Pos (4U)
3021#define CAN_F5R1_FB4_Msk (0x1U << CAN_F5R1_FB4_Pos) /*!< 0x00000010 */
3022#define CAN_F5R1_FB4 CAN_F5R1_FB4_Msk /*!<Filter bit 4 */
3023#define CAN_F5R1_FB5_Pos (5U)
3024#define CAN_F5R1_FB5_Msk (0x1U << CAN_F5R1_FB5_Pos) /*!< 0x00000020 */
3025#define CAN_F5R1_FB5 CAN_F5R1_FB5_Msk /*!<Filter bit 5 */
3026#define CAN_F5R1_FB6_Pos (6U)
3027#define CAN_F5R1_FB6_Msk (0x1U << CAN_F5R1_FB6_Pos) /*!< 0x00000040 */
3028#define CAN_F5R1_FB6 CAN_F5R1_FB6_Msk /*!<Filter bit 6 */
3029#define CAN_F5R1_FB7_Pos (7U)
3030#define CAN_F5R1_FB7_Msk (0x1U << CAN_F5R1_FB7_Pos) /*!< 0x00000080 */
3031#define CAN_F5R1_FB7 CAN_F5R1_FB7_Msk /*!<Filter bit 7 */
3032#define CAN_F5R1_FB8_Pos (8U)
3033#define CAN_F5R1_FB8_Msk (0x1U << CAN_F5R1_FB8_Pos) /*!< 0x00000100 */
3034#define CAN_F5R1_FB8 CAN_F5R1_FB8_Msk /*!<Filter bit 8 */
3035#define CAN_F5R1_FB9_Pos (9U)
3036#define CAN_F5R1_FB9_Msk (0x1U << CAN_F5R1_FB9_Pos) /*!< 0x00000200 */
3037#define CAN_F5R1_FB9 CAN_F5R1_FB9_Msk /*!<Filter bit 9 */
3038#define CAN_F5R1_FB10_Pos (10U)
3039#define CAN_F5R1_FB10_Msk (0x1U << CAN_F5R1_FB10_Pos) /*!< 0x00000400 */
3040#define CAN_F5R1_FB10 CAN_F5R1_FB10_Msk /*!<Filter bit 10 */
3041#define CAN_F5R1_FB11_Pos (11U)
3042#define CAN_F5R1_FB11_Msk (0x1U << CAN_F5R1_FB11_Pos) /*!< 0x00000800 */
3043#define CAN_F5R1_FB11 CAN_F5R1_FB11_Msk /*!<Filter bit 11 */
3044#define CAN_F5R1_FB12_Pos (12U)
3045#define CAN_F5R1_FB12_Msk (0x1U << CAN_F5R1_FB12_Pos) /*!< 0x00001000 */
3046#define CAN_F5R1_FB12 CAN_F5R1_FB12_Msk /*!<Filter bit 12 */
3047#define CAN_F5R1_FB13_Pos (13U)
3048#define CAN_F5R1_FB13_Msk (0x1U << CAN_F5R1_FB13_Pos) /*!< 0x00002000 */
3049#define CAN_F5R1_FB13 CAN_F5R1_FB13_Msk /*!<Filter bit 13 */
3050#define CAN_F5R1_FB14_Pos (14U)
3051#define CAN_F5R1_FB14_Msk (0x1U << CAN_F5R1_FB14_Pos) /*!< 0x00004000 */
3052#define CAN_F5R1_FB14 CAN_F5R1_FB14_Msk /*!<Filter bit 14 */
3053#define CAN_F5R1_FB15_Pos (15U)
3054#define CAN_F5R1_FB15_Msk (0x1U << CAN_F5R1_FB15_Pos) /*!< 0x00008000 */
3055#define CAN_F5R1_FB15 CAN_F5R1_FB15_Msk /*!<Filter bit 15 */
3056#define CAN_F5R1_FB16_Pos (16U)
3057#define CAN_F5R1_FB16_Msk (0x1U << CAN_F5R1_FB16_Pos) /*!< 0x00010000 */
3058#define CAN_F5R1_FB16 CAN_F5R1_FB16_Msk /*!<Filter bit 16 */
3059#define CAN_F5R1_FB17_Pos (17U)
3060#define CAN_F5R1_FB17_Msk (0x1U << CAN_F5R1_FB17_Pos) /*!< 0x00020000 */
3061#define CAN_F5R1_FB17 CAN_F5R1_FB17_Msk /*!<Filter bit 17 */
3062#define CAN_F5R1_FB18_Pos (18U)
3063#define CAN_F5R1_FB18_Msk (0x1U << CAN_F5R1_FB18_Pos) /*!< 0x00040000 */
3064#define CAN_F5R1_FB18 CAN_F5R1_FB18_Msk /*!<Filter bit 18 */
3065#define CAN_F5R1_FB19_Pos (19U)
3066#define CAN_F5R1_FB19_Msk (0x1U << CAN_F5R1_FB19_Pos) /*!< 0x00080000 */
3067#define CAN_F5R1_FB19 CAN_F5R1_FB19_Msk /*!<Filter bit 19 */
3068#define CAN_F5R1_FB20_Pos (20U)
3069#define CAN_F5R1_FB20_Msk (0x1U << CAN_F5R1_FB20_Pos) /*!< 0x00100000 */
3070#define CAN_F5R1_FB20 CAN_F5R1_FB20_Msk /*!<Filter bit 20 */
3071#define CAN_F5R1_FB21_Pos (21U)
3072#define CAN_F5R1_FB21_Msk (0x1U << CAN_F5R1_FB21_Pos) /*!< 0x00200000 */
3073#define CAN_F5R1_FB21 CAN_F5R1_FB21_Msk /*!<Filter bit 21 */
3074#define CAN_F5R1_FB22_Pos (22U)
3075#define CAN_F5R1_FB22_Msk (0x1U << CAN_F5R1_FB22_Pos) /*!< 0x00400000 */
3076#define CAN_F5R1_FB22 CAN_F5R1_FB22_Msk /*!<Filter bit 22 */
3077#define CAN_F5R1_FB23_Pos (23U)
3078#define CAN_F5R1_FB23_Msk (0x1U << CAN_F5R1_FB23_Pos) /*!< 0x00800000 */
3079#define CAN_F5R1_FB23 CAN_F5R1_FB23_Msk /*!<Filter bit 23 */
3080#define CAN_F5R1_FB24_Pos (24U)
3081#define CAN_F5R1_FB24_Msk (0x1U << CAN_F5R1_FB24_Pos) /*!< 0x01000000 */
3082#define CAN_F5R1_FB24 CAN_F5R1_FB24_Msk /*!<Filter bit 24 */
3083#define CAN_F5R1_FB25_Pos (25U)
3084#define CAN_F5R1_FB25_Msk (0x1U << CAN_F5R1_FB25_Pos) /*!< 0x02000000 */
3085#define CAN_F5R1_FB25 CAN_F5R1_FB25_Msk /*!<Filter bit 25 */
3086#define CAN_F5R1_FB26_Pos (26U)
3087#define CAN_F5R1_FB26_Msk (0x1U << CAN_F5R1_FB26_Pos) /*!< 0x04000000 */
3088#define CAN_F5R1_FB26 CAN_F5R1_FB26_Msk /*!<Filter bit 26 */
3089#define CAN_F5R1_FB27_Pos (27U)
3090#define CAN_F5R1_FB27_Msk (0x1U << CAN_F5R1_FB27_Pos) /*!< 0x08000000 */
3091#define CAN_F5R1_FB27 CAN_F5R1_FB27_Msk /*!<Filter bit 27 */
3092#define CAN_F5R1_FB28_Pos (28U)
3093#define CAN_F5R1_FB28_Msk (0x1U << CAN_F5R1_FB28_Pos) /*!< 0x10000000 */
3094#define CAN_F5R1_FB28 CAN_F5R1_FB28_Msk /*!<Filter bit 28 */
3095#define CAN_F5R1_FB29_Pos (29U)
3096#define CAN_F5R1_FB29_Msk (0x1U << CAN_F5R1_FB29_Pos) /*!< 0x20000000 */
3097#define CAN_F5R1_FB29 CAN_F5R1_FB29_Msk /*!<Filter bit 29 */
3098#define CAN_F5R1_FB30_Pos (30U)
3099#define CAN_F5R1_FB30_Msk (0x1U << CAN_F5R1_FB30_Pos) /*!< 0x40000000 */
3100#define CAN_F5R1_FB30 CAN_F5R1_FB30_Msk /*!<Filter bit 30 */
3101#define CAN_F5R1_FB31_Pos (31U)
3102#define CAN_F5R1_FB31_Msk (0x1U << CAN_F5R1_FB31_Pos) /*!< 0x80000000 */
3103#define CAN_F5R1_FB31 CAN_F5R1_FB31_Msk /*!<Filter bit 31 */
3104
3105/******************* Bit definition for CAN_F6R1 register *******************/
3106#define CAN_F6R1_FB0_Pos (0U)
3107#define CAN_F6R1_FB0_Msk (0x1U << CAN_F6R1_FB0_Pos) /*!< 0x00000001 */
3108#define CAN_F6R1_FB0 CAN_F6R1_FB0_Msk /*!<Filter bit 0 */
3109#define CAN_F6R1_FB1_Pos (1U)
3110#define CAN_F6R1_FB1_Msk (0x1U << CAN_F6R1_FB1_Pos) /*!< 0x00000002 */
3111#define CAN_F6R1_FB1 CAN_F6R1_FB1_Msk /*!<Filter bit 1 */
3112#define CAN_F6R1_FB2_Pos (2U)
3113#define CAN_F6R1_FB2_Msk (0x1U << CAN_F6R1_FB2_Pos) /*!< 0x00000004 */
3114#define CAN_F6R1_FB2 CAN_F6R1_FB2_Msk /*!<Filter bit 2 */
3115#define CAN_F6R1_FB3_Pos (3U)
3116#define CAN_F6R1_FB3_Msk (0x1U << CAN_F6R1_FB3_Pos) /*!< 0x00000008 */
3117#define CAN_F6R1_FB3 CAN_F6R1_FB3_Msk /*!<Filter bit 3 */
3118#define CAN_F6R1_FB4_Pos (4U)
3119#define CAN_F6R1_FB4_Msk (0x1U << CAN_F6R1_FB4_Pos) /*!< 0x00000010 */
3120#define CAN_F6R1_FB4 CAN_F6R1_FB4_Msk /*!<Filter bit 4 */
3121#define CAN_F6R1_FB5_Pos (5U)
3122#define CAN_F6R1_FB5_Msk (0x1U << CAN_F6R1_FB5_Pos) /*!< 0x00000020 */
3123#define CAN_F6R1_FB5 CAN_F6R1_FB5_Msk /*!<Filter bit 5 */
3124#define CAN_F6R1_FB6_Pos (6U)
3125#define CAN_F6R1_FB6_Msk (0x1U << CAN_F6R1_FB6_Pos) /*!< 0x00000040 */
3126#define CAN_F6R1_FB6 CAN_F6R1_FB6_Msk /*!<Filter bit 6 */
3127#define CAN_F6R1_FB7_Pos (7U)
3128#define CAN_F6R1_FB7_Msk (0x1U << CAN_F6R1_FB7_Pos) /*!< 0x00000080 */
3129#define CAN_F6R1_FB7 CAN_F6R1_FB7_Msk /*!<Filter bit 7 */
3130#define CAN_F6R1_FB8_Pos (8U)
3131#define CAN_F6R1_FB8_Msk (0x1U << CAN_F6R1_FB8_Pos) /*!< 0x00000100 */
3132#define CAN_F6R1_FB8 CAN_F6R1_FB8_Msk /*!<Filter bit 8 */
3133#define CAN_F6R1_FB9_Pos (9U)
3134#define CAN_F6R1_FB9_Msk (0x1U << CAN_F6R1_FB9_Pos) /*!< 0x00000200 */
3135#define CAN_F6R1_FB9 CAN_F6R1_FB9_Msk /*!<Filter bit 9 */
3136#define CAN_F6R1_FB10_Pos (10U)
3137#define CAN_F6R1_FB10_Msk (0x1U << CAN_F6R1_FB10_Pos) /*!< 0x00000400 */
3138#define CAN_F6R1_FB10 CAN_F6R1_FB10_Msk /*!<Filter bit 10 */
3139#define CAN_F6R1_FB11_Pos (11U)
3140#define CAN_F6R1_FB11_Msk (0x1U << CAN_F6R1_FB11_Pos) /*!< 0x00000800 */
3141#define CAN_F6R1_FB11 CAN_F6R1_FB11_Msk /*!<Filter bit 11 */
3142#define CAN_F6R1_FB12_Pos (12U)
3143#define CAN_F6R1_FB12_Msk (0x1U << CAN_F6R1_FB12_Pos) /*!< 0x00001000 */
3144#define CAN_F6R1_FB12 CAN_F6R1_FB12_Msk /*!<Filter bit 12 */
3145#define CAN_F6R1_FB13_Pos (13U)
3146#define CAN_F6R1_FB13_Msk (0x1U << CAN_F6R1_FB13_Pos) /*!< 0x00002000 */
3147#define CAN_F6R1_FB13 CAN_F6R1_FB13_Msk /*!<Filter bit 13 */
3148#define CAN_F6R1_FB14_Pos (14U)
3149#define CAN_F6R1_FB14_Msk (0x1U << CAN_F6R1_FB14_Pos) /*!< 0x00004000 */
3150#define CAN_F6R1_FB14 CAN_F6R1_FB14_Msk /*!<Filter bit 14 */
3151#define CAN_F6R1_FB15_Pos (15U)
3152#define CAN_F6R1_FB15_Msk (0x1U << CAN_F6R1_FB15_Pos) /*!< 0x00008000 */
3153#define CAN_F6R1_FB15 CAN_F6R1_FB15_Msk /*!<Filter bit 15 */
3154#define CAN_F6R1_FB16_Pos (16U)
3155#define CAN_F6R1_FB16_Msk (0x1U << CAN_F6R1_FB16_Pos) /*!< 0x00010000 */
3156#define CAN_F6R1_FB16 CAN_F6R1_FB16_Msk /*!<Filter bit 16 */
3157#define CAN_F6R1_FB17_Pos (17U)
3158#define CAN_F6R1_FB17_Msk (0x1U << CAN_F6R1_FB17_Pos) /*!< 0x00020000 */
3159#define CAN_F6R1_FB17 CAN_F6R1_FB17_Msk /*!<Filter bit 17 */
3160#define CAN_F6R1_FB18_Pos (18U)
3161#define CAN_F6R1_FB18_Msk (0x1U << CAN_F6R1_FB18_Pos) /*!< 0x00040000 */
3162#define CAN_F6R1_FB18 CAN_F6R1_FB18_Msk /*!<Filter bit 18 */
3163#define CAN_F6R1_FB19_Pos (19U)
3164#define CAN_F6R1_FB19_Msk (0x1U << CAN_F6R1_FB19_Pos) /*!< 0x00080000 */
3165#define CAN_F6R1_FB19 CAN_F6R1_FB19_Msk /*!<Filter bit 19 */
3166#define CAN_F6R1_FB20_Pos (20U)
3167#define CAN_F6R1_FB20_Msk (0x1U << CAN_F6R1_FB20_Pos) /*!< 0x00100000 */
3168#define CAN_F6R1_FB20 CAN_F6R1_FB20_Msk /*!<Filter bit 20 */
3169#define CAN_F6R1_FB21_Pos (21U)
3170#define CAN_F6R1_FB21_Msk (0x1U << CAN_F6R1_FB21_Pos) /*!< 0x00200000 */
3171#define CAN_F6R1_FB21 CAN_F6R1_FB21_Msk /*!<Filter bit 21 */
3172#define CAN_F6R1_FB22_Pos (22U)
3173#define CAN_F6R1_FB22_Msk (0x1U << CAN_F6R1_FB22_Pos) /*!< 0x00400000 */
3174#define CAN_F6R1_FB22 CAN_F6R1_FB22_Msk /*!<Filter bit 22 */
3175#define CAN_F6R1_FB23_Pos (23U)
3176#define CAN_F6R1_FB23_Msk (0x1U << CAN_F6R1_FB23_Pos) /*!< 0x00800000 */
3177#define CAN_F6R1_FB23 CAN_F6R1_FB23_Msk /*!<Filter bit 23 */
3178#define CAN_F6R1_FB24_Pos (24U)
3179#define CAN_F6R1_FB24_Msk (0x1U << CAN_F6R1_FB24_Pos) /*!< 0x01000000 */
3180#define CAN_F6R1_FB24 CAN_F6R1_FB24_Msk /*!<Filter bit 24 */
3181#define CAN_F6R1_FB25_Pos (25U)
3182#define CAN_F6R1_FB25_Msk (0x1U << CAN_F6R1_FB25_Pos) /*!< 0x02000000 */
3183#define CAN_F6R1_FB25 CAN_F6R1_FB25_Msk /*!<Filter bit 25 */
3184#define CAN_F6R1_FB26_Pos (26U)
3185#define CAN_F6R1_FB26_Msk (0x1U << CAN_F6R1_FB26_Pos) /*!< 0x04000000 */
3186#define CAN_F6R1_FB26 CAN_F6R1_FB26_Msk /*!<Filter bit 26 */
3187#define CAN_F6R1_FB27_Pos (27U)
3188#define CAN_F6R1_FB27_Msk (0x1U << CAN_F6R1_FB27_Pos) /*!< 0x08000000 */
3189#define CAN_F6R1_FB27 CAN_F6R1_FB27_Msk /*!<Filter bit 27 */
3190#define CAN_F6R1_FB28_Pos (28U)
3191#define CAN_F6R1_FB28_Msk (0x1U << CAN_F6R1_FB28_Pos) /*!< 0x10000000 */
3192#define CAN_F6R1_FB28 CAN_F6R1_FB28_Msk /*!<Filter bit 28 */
3193#define CAN_F6R1_FB29_Pos (29U)
3194#define CAN_F6R1_FB29_Msk (0x1U << CAN_F6R1_FB29_Pos) /*!< 0x20000000 */
3195#define CAN_F6R1_FB29 CAN_F6R1_FB29_Msk /*!<Filter bit 29 */
3196#define CAN_F6R1_FB30_Pos (30U)
3197#define CAN_F6R1_FB30_Msk (0x1U << CAN_F6R1_FB30_Pos) /*!< 0x40000000 */
3198#define CAN_F6R1_FB30 CAN_F6R1_FB30_Msk /*!<Filter bit 30 */
3199#define CAN_F6R1_FB31_Pos (31U)
3200#define CAN_F6R1_FB31_Msk (0x1U << CAN_F6R1_FB31_Pos) /*!< 0x80000000 */
3201#define CAN_F6R1_FB31 CAN_F6R1_FB31_Msk /*!<Filter bit 31 */
3202
3203/******************* Bit definition for CAN_F7R1 register *******************/
3204#define CAN_F7R1_FB0_Pos (0U)
3205#define CAN_F7R1_FB0_Msk (0x1U << CAN_F7R1_FB0_Pos) /*!< 0x00000001 */
3206#define CAN_F7R1_FB0 CAN_F7R1_FB0_Msk /*!<Filter bit 0 */
3207#define CAN_F7R1_FB1_Pos (1U)
3208#define CAN_F7R1_FB1_Msk (0x1U << CAN_F7R1_FB1_Pos) /*!< 0x00000002 */
3209#define CAN_F7R1_FB1 CAN_F7R1_FB1_Msk /*!<Filter bit 1 */
3210#define CAN_F7R1_FB2_Pos (2U)
3211#define CAN_F7R1_FB2_Msk (0x1U << CAN_F7R1_FB2_Pos) /*!< 0x00000004 */
3212#define CAN_F7R1_FB2 CAN_F7R1_FB2_Msk /*!<Filter bit 2 */
3213#define CAN_F7R1_FB3_Pos (3U)
3214#define CAN_F7R1_FB3_Msk (0x1U << CAN_F7R1_FB3_Pos) /*!< 0x00000008 */
3215#define CAN_F7R1_FB3 CAN_F7R1_FB3_Msk /*!<Filter bit 3 */
3216#define CAN_F7R1_FB4_Pos (4U)
3217#define CAN_F7R1_FB4_Msk (0x1U << CAN_F7R1_FB4_Pos) /*!< 0x00000010 */
3218#define CAN_F7R1_FB4 CAN_F7R1_FB4_Msk /*!<Filter bit 4 */
3219#define CAN_F7R1_FB5_Pos (5U)
3220#define CAN_F7R1_FB5_Msk (0x1U << CAN_F7R1_FB5_Pos) /*!< 0x00000020 */
3221#define CAN_F7R1_FB5 CAN_F7R1_FB5_Msk /*!<Filter bit 5 */
3222#define CAN_F7R1_FB6_Pos (6U)
3223#define CAN_F7R1_FB6_Msk (0x1U << CAN_F7R1_FB6_Pos) /*!< 0x00000040 */
3224#define CAN_F7R1_FB6 CAN_F7R1_FB6_Msk /*!<Filter bit 6 */
3225#define CAN_F7R1_FB7_Pos (7U)
3226#define CAN_F7R1_FB7_Msk (0x1U << CAN_F7R1_FB7_Pos) /*!< 0x00000080 */
3227#define CAN_F7R1_FB7 CAN_F7R1_FB7_Msk /*!<Filter bit 7 */
3228#define CAN_F7R1_FB8_Pos (8U)
3229#define CAN_F7R1_FB8_Msk (0x1U << CAN_F7R1_FB8_Pos) /*!< 0x00000100 */
3230#define CAN_F7R1_FB8 CAN_F7R1_FB8_Msk /*!<Filter bit 8 */
3231#define CAN_F7R1_FB9_Pos (9U)
3232#define CAN_F7R1_FB9_Msk (0x1U << CAN_F7R1_FB9_Pos) /*!< 0x00000200 */
3233#define CAN_F7R1_FB9 CAN_F7R1_FB9_Msk /*!<Filter bit 9 */
3234#define CAN_F7R1_FB10_Pos (10U)
3235#define CAN_F7R1_FB10_Msk (0x1U << CAN_F7R1_FB10_Pos) /*!< 0x00000400 */
3236#define CAN_F7R1_FB10 CAN_F7R1_FB10_Msk /*!<Filter bit 10 */
3237#define CAN_F7R1_FB11_Pos (11U)
3238#define CAN_F7R1_FB11_Msk (0x1U << CAN_F7R1_FB11_Pos) /*!< 0x00000800 */
3239#define CAN_F7R1_FB11 CAN_F7R1_FB11_Msk /*!<Filter bit 11 */
3240#define CAN_F7R1_FB12_Pos (12U)
3241#define CAN_F7R1_FB12_Msk (0x1U << CAN_F7R1_FB12_Pos) /*!< 0x00001000 */
3242#define CAN_F7R1_FB12 CAN_F7R1_FB12_Msk /*!<Filter bit 12 */
3243#define CAN_F7R1_FB13_Pos (13U)
3244#define CAN_F7R1_FB13_Msk (0x1U << CAN_F7R1_FB13_Pos) /*!< 0x00002000 */
3245#define CAN_F7R1_FB13 CAN_F7R1_FB13_Msk /*!<Filter bit 13 */
3246#define CAN_F7R1_FB14_Pos (14U)
3247#define CAN_F7R1_FB14_Msk (0x1U << CAN_F7R1_FB14_Pos) /*!< 0x00004000 */
3248#define CAN_F7R1_FB14 CAN_F7R1_FB14_Msk /*!<Filter bit 14 */
3249#define CAN_F7R1_FB15_Pos (15U)
3250#define CAN_F7R1_FB15_Msk (0x1U << CAN_F7R1_FB15_Pos) /*!< 0x00008000 */
3251#define CAN_F7R1_FB15 CAN_F7R1_FB15_Msk /*!<Filter bit 15 */
3252#define CAN_F7R1_FB16_Pos (16U)
3253#define CAN_F7R1_FB16_Msk (0x1U << CAN_F7R1_FB16_Pos) /*!< 0x00010000 */
3254#define CAN_F7R1_FB16 CAN_F7R1_FB16_Msk /*!<Filter bit 16 */
3255#define CAN_F7R1_FB17_Pos (17U)
3256#define CAN_F7R1_FB17_Msk (0x1U << CAN_F7R1_FB17_Pos) /*!< 0x00020000 */
3257#define CAN_F7R1_FB17 CAN_F7R1_FB17_Msk /*!<Filter bit 17 */
3258#define CAN_F7R1_FB18_Pos (18U)
3259#define CAN_F7R1_FB18_Msk (0x1U << CAN_F7R1_FB18_Pos) /*!< 0x00040000 */
3260#define CAN_F7R1_FB18 CAN_F7R1_FB18_Msk /*!<Filter bit 18 */
3261#define CAN_F7R1_FB19_Pos (19U)
3262#define CAN_F7R1_FB19_Msk (0x1U << CAN_F7R1_FB19_Pos) /*!< 0x00080000 */
3263#define CAN_F7R1_FB19 CAN_F7R1_FB19_Msk /*!<Filter bit 19 */
3264#define CAN_F7R1_FB20_Pos (20U)
3265#define CAN_F7R1_FB20_Msk (0x1U << CAN_F7R1_FB20_Pos) /*!< 0x00100000 */
3266#define CAN_F7R1_FB20 CAN_F7R1_FB20_Msk /*!<Filter bit 20 */
3267#define CAN_F7R1_FB21_Pos (21U)
3268#define CAN_F7R1_FB21_Msk (0x1U << CAN_F7R1_FB21_Pos) /*!< 0x00200000 */
3269#define CAN_F7R1_FB21 CAN_F7R1_FB21_Msk /*!<Filter bit 21 */
3270#define CAN_F7R1_FB22_Pos (22U)
3271#define CAN_F7R1_FB22_Msk (0x1U << CAN_F7R1_FB22_Pos) /*!< 0x00400000 */
3272#define CAN_F7R1_FB22 CAN_F7R1_FB22_Msk /*!<Filter bit 22 */
3273#define CAN_F7R1_FB23_Pos (23U)
3274#define CAN_F7R1_FB23_Msk (0x1U << CAN_F7R1_FB23_Pos) /*!< 0x00800000 */
3275#define CAN_F7R1_FB23 CAN_F7R1_FB23_Msk /*!<Filter bit 23 */
3276#define CAN_F7R1_FB24_Pos (24U)
3277#define CAN_F7R1_FB24_Msk (0x1U << CAN_F7R1_FB24_Pos) /*!< 0x01000000 */
3278#define CAN_F7R1_FB24 CAN_F7R1_FB24_Msk /*!<Filter bit 24 */
3279#define CAN_F7R1_FB25_Pos (25U)
3280#define CAN_F7R1_FB25_Msk (0x1U << CAN_F7R1_FB25_Pos) /*!< 0x02000000 */
3281#define CAN_F7R1_FB25 CAN_F7R1_FB25_Msk /*!<Filter bit 25 */
3282#define CAN_F7R1_FB26_Pos (26U)
3283#define CAN_F7R1_FB26_Msk (0x1U << CAN_F7R1_FB26_Pos) /*!< 0x04000000 */
3284#define CAN_F7R1_FB26 CAN_F7R1_FB26_Msk /*!<Filter bit 26 */
3285#define CAN_F7R1_FB27_Pos (27U)
3286#define CAN_F7R1_FB27_Msk (0x1U << CAN_F7R1_FB27_Pos) /*!< 0x08000000 */
3287#define CAN_F7R1_FB27 CAN_F7R1_FB27_Msk /*!<Filter bit 27 */
3288#define CAN_F7R1_FB28_Pos (28U)
3289#define CAN_F7R1_FB28_Msk (0x1U << CAN_F7R1_FB28_Pos) /*!< 0x10000000 */
3290#define CAN_F7R1_FB28 CAN_F7R1_FB28_Msk /*!<Filter bit 28 */
3291#define CAN_F7R1_FB29_Pos (29U)
3292#define CAN_F7R1_FB29_Msk (0x1U << CAN_F7R1_FB29_Pos) /*!< 0x20000000 */
3293#define CAN_F7R1_FB29 CAN_F7R1_FB29_Msk /*!<Filter bit 29 */
3294#define CAN_F7R1_FB30_Pos (30U)
3295#define CAN_F7R1_FB30_Msk (0x1U << CAN_F7R1_FB30_Pos) /*!< 0x40000000 */
3296#define CAN_F7R1_FB30 CAN_F7R1_FB30_Msk /*!<Filter bit 30 */
3297#define CAN_F7R1_FB31_Pos (31U)
3298#define CAN_F7R1_FB31_Msk (0x1U << CAN_F7R1_FB31_Pos) /*!< 0x80000000 */
3299#define CAN_F7R1_FB31 CAN_F7R1_FB31_Msk /*!<Filter bit 31 */
3300
3301/******************* Bit definition for CAN_F8R1 register *******************/
3302#define CAN_F8R1_FB0_Pos (0U)
3303#define CAN_F8R1_FB0_Msk (0x1U << CAN_F8R1_FB0_Pos) /*!< 0x00000001 */
3304#define CAN_F8R1_FB0 CAN_F8R1_FB0_Msk /*!<Filter bit 0 */
3305#define CAN_F8R1_FB1_Pos (1U)
3306#define CAN_F8R1_FB1_Msk (0x1U << CAN_F8R1_FB1_Pos) /*!< 0x00000002 */
3307#define CAN_F8R1_FB1 CAN_F8R1_FB1_Msk /*!<Filter bit 1 */
3308#define CAN_F8R1_FB2_Pos (2U)
3309#define CAN_F8R1_FB2_Msk (0x1U << CAN_F8R1_FB2_Pos) /*!< 0x00000004 */
3310#define CAN_F8R1_FB2 CAN_F8R1_FB2_Msk /*!<Filter bit 2 */
3311#define CAN_F8R1_FB3_Pos (3U)
3312#define CAN_F8R1_FB3_Msk (0x1U << CAN_F8R1_FB3_Pos) /*!< 0x00000008 */
3313#define CAN_F8R1_FB3 CAN_F8R1_FB3_Msk /*!<Filter bit 3 */
3314#define CAN_F8R1_FB4_Pos (4U)
3315#define CAN_F8R1_FB4_Msk (0x1U << CAN_F8R1_FB4_Pos) /*!< 0x00000010 */
3316#define CAN_F8R1_FB4 CAN_F8R1_FB4_Msk /*!<Filter bit 4 */
3317#define CAN_F8R1_FB5_Pos (5U)
3318#define CAN_F8R1_FB5_Msk (0x1U << CAN_F8R1_FB5_Pos) /*!< 0x00000020 */
3319#define CAN_F8R1_FB5 CAN_F8R1_FB5_Msk /*!<Filter bit 5 */
3320#define CAN_F8R1_FB6_Pos (6U)
3321#define CAN_F8R1_FB6_Msk (0x1U << CAN_F8R1_FB6_Pos) /*!< 0x00000040 */
3322#define CAN_F8R1_FB6 CAN_F8R1_FB6_Msk /*!<Filter bit 6 */
3323#define CAN_F8R1_FB7_Pos (7U)
3324#define CAN_F8R1_FB7_Msk (0x1U << CAN_F8R1_FB7_Pos) /*!< 0x00000080 */
3325#define CAN_F8R1_FB7 CAN_F8R1_FB7_Msk /*!<Filter bit 7 */
3326#define CAN_F8R1_FB8_Pos (8U)
3327#define CAN_F8R1_FB8_Msk (0x1U << CAN_F8R1_FB8_Pos) /*!< 0x00000100 */
3328#define CAN_F8R1_FB8 CAN_F8R1_FB8_Msk /*!<Filter bit 8 */
3329#define CAN_F8R1_FB9_Pos (9U)
3330#define CAN_F8R1_FB9_Msk (0x1U << CAN_F8R1_FB9_Pos) /*!< 0x00000200 */
3331#define CAN_F8R1_FB9 CAN_F8R1_FB9_Msk /*!<Filter bit 9 */
3332#define CAN_F8R1_FB10_Pos (10U)
3333#define CAN_F8R1_FB10_Msk (0x1U << CAN_F8R1_FB10_Pos) /*!< 0x00000400 */
3334#define CAN_F8R1_FB10 CAN_F8R1_FB10_Msk /*!<Filter bit 10 */
3335#define CAN_F8R1_FB11_Pos (11U)
3336#define CAN_F8R1_FB11_Msk (0x1U << CAN_F8R1_FB11_Pos) /*!< 0x00000800 */
3337#define CAN_F8R1_FB11 CAN_F8R1_FB11_Msk /*!<Filter bit 11 */
3338#define CAN_F8R1_FB12_Pos (12U)
3339#define CAN_F8R1_FB12_Msk (0x1U << CAN_F8R1_FB12_Pos) /*!< 0x00001000 */
3340#define CAN_F8R1_FB12 CAN_F8R1_FB12_Msk /*!<Filter bit 12 */
3341#define CAN_F8R1_FB13_Pos (13U)
3342#define CAN_F8R1_FB13_Msk (0x1U << CAN_F8R1_FB13_Pos) /*!< 0x00002000 */
3343#define CAN_F8R1_FB13 CAN_F8R1_FB13_Msk /*!<Filter bit 13 */
3344#define CAN_F8R1_FB14_Pos (14U)
3345#define CAN_F8R1_FB14_Msk (0x1U << CAN_F8R1_FB14_Pos) /*!< 0x00004000 */
3346#define CAN_F8R1_FB14 CAN_F8R1_FB14_Msk /*!<Filter bit 14 */
3347#define CAN_F8R1_FB15_Pos (15U)
3348#define CAN_F8R1_FB15_Msk (0x1U << CAN_F8R1_FB15_Pos) /*!< 0x00008000 */
3349#define CAN_F8R1_FB15 CAN_F8R1_FB15_Msk /*!<Filter bit 15 */
3350#define CAN_F8R1_FB16_Pos (16U)
3351#define CAN_F8R1_FB16_Msk (0x1U << CAN_F8R1_FB16_Pos) /*!< 0x00010000 */
3352#define CAN_F8R1_FB16 CAN_F8R1_FB16_Msk /*!<Filter bit 16 */
3353#define CAN_F8R1_FB17_Pos (17U)
3354#define CAN_F8R1_FB17_Msk (0x1U << CAN_F8R1_FB17_Pos) /*!< 0x00020000 */
3355#define CAN_F8R1_FB17 CAN_F8R1_FB17_Msk /*!<Filter bit 17 */
3356#define CAN_F8R1_FB18_Pos (18U)
3357#define CAN_F8R1_FB18_Msk (0x1U << CAN_F8R1_FB18_Pos) /*!< 0x00040000 */
3358#define CAN_F8R1_FB18 CAN_F8R1_FB18_Msk /*!<Filter bit 18 */
3359#define CAN_F8R1_FB19_Pos (19U)
3360#define CAN_F8R1_FB19_Msk (0x1U << CAN_F8R1_FB19_Pos) /*!< 0x00080000 */
3361#define CAN_F8R1_FB19 CAN_F8R1_FB19_Msk /*!<Filter bit 19 */
3362#define CAN_F8R1_FB20_Pos (20U)
3363#define CAN_F8R1_FB20_Msk (0x1U << CAN_F8R1_FB20_Pos) /*!< 0x00100000 */
3364#define CAN_F8R1_FB20 CAN_F8R1_FB20_Msk /*!<Filter bit 20 */
3365#define CAN_F8R1_FB21_Pos (21U)
3366#define CAN_F8R1_FB21_Msk (0x1U << CAN_F8R1_FB21_Pos) /*!< 0x00200000 */
3367#define CAN_F8R1_FB21 CAN_F8R1_FB21_Msk /*!<Filter bit 21 */
3368#define CAN_F8R1_FB22_Pos (22U)
3369#define CAN_F8R1_FB22_Msk (0x1U << CAN_F8R1_FB22_Pos) /*!< 0x00400000 */
3370#define CAN_F8R1_FB22 CAN_F8R1_FB22_Msk /*!<Filter bit 22 */
3371#define CAN_F8R1_FB23_Pos (23U)
3372#define CAN_F8R1_FB23_Msk (0x1U << CAN_F8R1_FB23_Pos) /*!< 0x00800000 */
3373#define CAN_F8R1_FB23 CAN_F8R1_FB23_Msk /*!<Filter bit 23 */
3374#define CAN_F8R1_FB24_Pos (24U)
3375#define CAN_F8R1_FB24_Msk (0x1U << CAN_F8R1_FB24_Pos) /*!< 0x01000000 */
3376#define CAN_F8R1_FB24 CAN_F8R1_FB24_Msk /*!<Filter bit 24 */
3377#define CAN_F8R1_FB25_Pos (25U)
3378#define CAN_F8R1_FB25_Msk (0x1U << CAN_F8R1_FB25_Pos) /*!< 0x02000000 */
3379#define CAN_F8R1_FB25 CAN_F8R1_FB25_Msk /*!<Filter bit 25 */
3380#define CAN_F8R1_FB26_Pos (26U)
3381#define CAN_F8R1_FB26_Msk (0x1U << CAN_F8R1_FB26_Pos) /*!< 0x04000000 */
3382#define CAN_F8R1_FB26 CAN_F8R1_FB26_Msk /*!<Filter bit 26 */
3383#define CAN_F8R1_FB27_Pos (27U)
3384#define CAN_F8R1_FB27_Msk (0x1U << CAN_F8R1_FB27_Pos) /*!< 0x08000000 */
3385#define CAN_F8R1_FB27 CAN_F8R1_FB27_Msk /*!<Filter bit 27 */
3386#define CAN_F8R1_FB28_Pos (28U)
3387#define CAN_F8R1_FB28_Msk (0x1U << CAN_F8R1_FB28_Pos) /*!< 0x10000000 */
3388#define CAN_F8R1_FB28 CAN_F8R1_FB28_Msk /*!<Filter bit 28 */
3389#define CAN_F8R1_FB29_Pos (29U)
3390#define CAN_F8R1_FB29_Msk (0x1U << CAN_F8R1_FB29_Pos) /*!< 0x20000000 */
3391#define CAN_F8R1_FB29 CAN_F8R1_FB29_Msk /*!<Filter bit 29 */
3392#define CAN_F8R1_FB30_Pos (30U)
3393#define CAN_F8R1_FB30_Msk (0x1U << CAN_F8R1_FB30_Pos) /*!< 0x40000000 */
3394#define CAN_F8R1_FB30 CAN_F8R1_FB30_Msk /*!<Filter bit 30 */
3395#define CAN_F8R1_FB31_Pos (31U)
3396#define CAN_F8R1_FB31_Msk (0x1U << CAN_F8R1_FB31_Pos) /*!< 0x80000000 */
3397#define CAN_F8R1_FB31 CAN_F8R1_FB31_Msk /*!<Filter bit 31 */
3398
3399/******************* Bit definition for CAN_F9R1 register *******************/
3400#define CAN_F9R1_FB0_Pos (0U)
3401#define CAN_F9R1_FB0_Msk (0x1U << CAN_F9R1_FB0_Pos) /*!< 0x00000001 */
3402#define CAN_F9R1_FB0 CAN_F9R1_FB0_Msk /*!<Filter bit 0 */
3403#define CAN_F9R1_FB1_Pos (1U)
3404#define CAN_F9R1_FB1_Msk (0x1U << CAN_F9R1_FB1_Pos) /*!< 0x00000002 */
3405#define CAN_F9R1_FB1 CAN_F9R1_FB1_Msk /*!<Filter bit 1 */
3406#define CAN_F9R1_FB2_Pos (2U)
3407#define CAN_F9R1_FB2_Msk (0x1U << CAN_F9R1_FB2_Pos) /*!< 0x00000004 */
3408#define CAN_F9R1_FB2 CAN_F9R1_FB2_Msk /*!<Filter bit 2 */
3409#define CAN_F9R1_FB3_Pos (3U)
3410#define CAN_F9R1_FB3_Msk (0x1U << CAN_F9R1_FB3_Pos) /*!< 0x00000008 */
3411#define CAN_F9R1_FB3 CAN_F9R1_FB3_Msk /*!<Filter bit 3 */
3412#define CAN_F9R1_FB4_Pos (4U)
3413#define CAN_F9R1_FB4_Msk (0x1U << CAN_F9R1_FB4_Pos) /*!< 0x00000010 */
3414#define CAN_F9R1_FB4 CAN_F9R1_FB4_Msk /*!<Filter bit 4 */
3415#define CAN_F9R1_FB5_Pos (5U)
3416#define CAN_F9R1_FB5_Msk (0x1U << CAN_F9R1_FB5_Pos) /*!< 0x00000020 */
3417#define CAN_F9R1_FB5 CAN_F9R1_FB5_Msk /*!<Filter bit 5 */
3418#define CAN_F9R1_FB6_Pos (6U)
3419#define CAN_F9R1_FB6_Msk (0x1U << CAN_F9R1_FB6_Pos) /*!< 0x00000040 */
3420#define CAN_F9R1_FB6 CAN_F9R1_FB6_Msk /*!<Filter bit 6 */
3421#define CAN_F9R1_FB7_Pos (7U)
3422#define CAN_F9R1_FB7_Msk (0x1U << CAN_F9R1_FB7_Pos) /*!< 0x00000080 */
3423#define CAN_F9R1_FB7 CAN_F9R1_FB7_Msk /*!<Filter bit 7 */
3424#define CAN_F9R1_FB8_Pos (8U)
3425#define CAN_F9R1_FB8_Msk (0x1U << CAN_F9R1_FB8_Pos) /*!< 0x00000100 */
3426#define CAN_F9R1_FB8 CAN_F9R1_FB8_Msk /*!<Filter bit 8 */
3427#define CAN_F9R1_FB9_Pos (9U)
3428#define CAN_F9R1_FB9_Msk (0x1U << CAN_F9R1_FB9_Pos) /*!< 0x00000200 */
3429#define CAN_F9R1_FB9 CAN_F9R1_FB9_Msk /*!<Filter bit 9 */
3430#define CAN_F9R1_FB10_Pos (10U)
3431#define CAN_F9R1_FB10_Msk (0x1U << CAN_F9R1_FB10_Pos) /*!< 0x00000400 */
3432#define CAN_F9R1_FB10 CAN_F9R1_FB10_Msk /*!<Filter bit 10 */
3433#define CAN_F9R1_FB11_Pos (11U)
3434#define CAN_F9R1_FB11_Msk (0x1U << CAN_F9R1_FB11_Pos) /*!< 0x00000800 */
3435#define CAN_F9R1_FB11 CAN_F9R1_FB11_Msk /*!<Filter bit 11 */
3436#define CAN_F9R1_FB12_Pos (12U)
3437#define CAN_F9R1_FB12_Msk (0x1U << CAN_F9R1_FB12_Pos) /*!< 0x00001000 */
3438#define CAN_F9R1_FB12 CAN_F9R1_FB12_Msk /*!<Filter bit 12 */
3439#define CAN_F9R1_FB13_Pos (13U)
3440#define CAN_F9R1_FB13_Msk (0x1U << CAN_F9R1_FB13_Pos) /*!< 0x00002000 */
3441#define CAN_F9R1_FB13 CAN_F9R1_FB13_Msk /*!<Filter bit 13 */
3442#define CAN_F9R1_FB14_Pos (14U)
3443#define CAN_F9R1_FB14_Msk (0x1U << CAN_F9R1_FB14_Pos) /*!< 0x00004000 */
3444#define CAN_F9R1_FB14 CAN_F9R1_FB14_Msk /*!<Filter bit 14 */
3445#define CAN_F9R1_FB15_Pos (15U)
3446#define CAN_F9R1_FB15_Msk (0x1U << CAN_F9R1_FB15_Pos) /*!< 0x00008000 */
3447#define CAN_F9R1_FB15 CAN_F9R1_FB15_Msk /*!<Filter bit 15 */
3448#define CAN_F9R1_FB16_Pos (16U)
3449#define CAN_F9R1_FB16_Msk (0x1U << CAN_F9R1_FB16_Pos) /*!< 0x00010000 */
3450#define CAN_F9R1_FB16 CAN_F9R1_FB16_Msk /*!<Filter bit 16 */
3451#define CAN_F9R1_FB17_Pos (17U)
3452#define CAN_F9R1_FB17_Msk (0x1U << CAN_F9R1_FB17_Pos) /*!< 0x00020000 */
3453#define CAN_F9R1_FB17 CAN_F9R1_FB17_Msk /*!<Filter bit 17 */
3454#define CAN_F9R1_FB18_Pos (18U)
3455#define CAN_F9R1_FB18_Msk (0x1U << CAN_F9R1_FB18_Pos) /*!< 0x00040000 */
3456#define CAN_F9R1_FB18 CAN_F9R1_FB18_Msk /*!<Filter bit 18 */
3457#define CAN_F9R1_FB19_Pos (19U)
3458#define CAN_F9R1_FB19_Msk (0x1U << CAN_F9R1_FB19_Pos) /*!< 0x00080000 */
3459#define CAN_F9R1_FB19 CAN_F9R1_FB19_Msk /*!<Filter bit 19 */
3460#define CAN_F9R1_FB20_Pos (20U)
3461#define CAN_F9R1_FB20_Msk (0x1U << CAN_F9R1_FB20_Pos) /*!< 0x00100000 */
3462#define CAN_F9R1_FB20 CAN_F9R1_FB20_Msk /*!<Filter bit 20 */
3463#define CAN_F9R1_FB21_Pos (21U)
3464#define CAN_F9R1_FB21_Msk (0x1U << CAN_F9R1_FB21_Pos) /*!< 0x00200000 */
3465#define CAN_F9R1_FB21 CAN_F9R1_FB21_Msk /*!<Filter bit 21 */
3466#define CAN_F9R1_FB22_Pos (22U)
3467#define CAN_F9R1_FB22_Msk (0x1U << CAN_F9R1_FB22_Pos) /*!< 0x00400000 */
3468#define CAN_F9R1_FB22 CAN_F9R1_FB22_Msk /*!<Filter bit 22 */
3469#define CAN_F9R1_FB23_Pos (23U)
3470#define CAN_F9R1_FB23_Msk (0x1U << CAN_F9R1_FB23_Pos) /*!< 0x00800000 */
3471#define CAN_F9R1_FB23 CAN_F9R1_FB23_Msk /*!<Filter bit 23 */
3472#define CAN_F9R1_FB24_Pos (24U)
3473#define CAN_F9R1_FB24_Msk (0x1U << CAN_F9R1_FB24_Pos) /*!< 0x01000000 */
3474#define CAN_F9R1_FB24 CAN_F9R1_FB24_Msk /*!<Filter bit 24 */
3475#define CAN_F9R1_FB25_Pos (25U)
3476#define CAN_F9R1_FB25_Msk (0x1U << CAN_F9R1_FB25_Pos) /*!< 0x02000000 */
3477#define CAN_F9R1_FB25 CAN_F9R1_FB25_Msk /*!<Filter bit 25 */
3478#define CAN_F9R1_FB26_Pos (26U)
3479#define CAN_F9R1_FB26_Msk (0x1U << CAN_F9R1_FB26_Pos) /*!< 0x04000000 */
3480#define CAN_F9R1_FB26 CAN_F9R1_FB26_Msk /*!<Filter bit 26 */
3481#define CAN_F9R1_FB27_Pos (27U)
3482#define CAN_F9R1_FB27_Msk (0x1U << CAN_F9R1_FB27_Pos) /*!< 0x08000000 */
3483#define CAN_F9R1_FB27 CAN_F9R1_FB27_Msk /*!<Filter bit 27 */
3484#define CAN_F9R1_FB28_Pos (28U)
3485#define CAN_F9R1_FB28_Msk (0x1U << CAN_F9R1_FB28_Pos) /*!< 0x10000000 */
3486#define CAN_F9R1_FB28 CAN_F9R1_FB28_Msk /*!<Filter bit 28 */
3487#define CAN_F9R1_FB29_Pos (29U)
3488#define CAN_F9R1_FB29_Msk (0x1U << CAN_F9R1_FB29_Pos) /*!< 0x20000000 */
3489#define CAN_F9R1_FB29 CAN_F9R1_FB29_Msk /*!<Filter bit 29 */
3490#define CAN_F9R1_FB30_Pos (30U)
3491#define CAN_F9R1_FB30_Msk (0x1U << CAN_F9R1_FB30_Pos) /*!< 0x40000000 */
3492#define CAN_F9R1_FB30 CAN_F9R1_FB30_Msk /*!<Filter bit 30 */
3493#define CAN_F9R1_FB31_Pos (31U)
3494#define CAN_F9R1_FB31_Msk (0x1U << CAN_F9R1_FB31_Pos) /*!< 0x80000000 */
3495#define CAN_F9R1_FB31 CAN_F9R1_FB31_Msk /*!<Filter bit 31 */
3496
3497/******************* Bit definition for CAN_F10R1 register ******************/
3498#define CAN_F10R1_FB0_Pos (0U)
3499#define CAN_F10R1_FB0_Msk (0x1U << CAN_F10R1_FB0_Pos) /*!< 0x00000001 */
3500#define CAN_F10R1_FB0 CAN_F10R1_FB0_Msk /*!<Filter bit 0 */
3501#define CAN_F10R1_FB1_Pos (1U)
3502#define CAN_F10R1_FB1_Msk (0x1U << CAN_F10R1_FB1_Pos) /*!< 0x00000002 */
3503#define CAN_F10R1_FB1 CAN_F10R1_FB1_Msk /*!<Filter bit 1 */
3504#define CAN_F10R1_FB2_Pos (2U)
3505#define CAN_F10R1_FB2_Msk (0x1U << CAN_F10R1_FB2_Pos) /*!< 0x00000004 */
3506#define CAN_F10R1_FB2 CAN_F10R1_FB2_Msk /*!<Filter bit 2 */
3507#define CAN_F10R1_FB3_Pos (3U)
3508#define CAN_F10R1_FB3_Msk (0x1U << CAN_F10R1_FB3_Pos) /*!< 0x00000008 */
3509#define CAN_F10R1_FB3 CAN_F10R1_FB3_Msk /*!<Filter bit 3 */
3510#define CAN_F10R1_FB4_Pos (4U)
3511#define CAN_F10R1_FB4_Msk (0x1U << CAN_F10R1_FB4_Pos) /*!< 0x00000010 */
3512#define CAN_F10R1_FB4 CAN_F10R1_FB4_Msk /*!<Filter bit 4 */
3513#define CAN_F10R1_FB5_Pos (5U)
3514#define CAN_F10R1_FB5_Msk (0x1U << CAN_F10R1_FB5_Pos) /*!< 0x00000020 */
3515#define CAN_F10R1_FB5 CAN_F10R1_FB5_Msk /*!<Filter bit 5 */
3516#define CAN_F10R1_FB6_Pos (6U)
3517#define CAN_F10R1_FB6_Msk (0x1U << CAN_F10R1_FB6_Pos) /*!< 0x00000040 */
3518#define CAN_F10R1_FB6 CAN_F10R1_FB6_Msk /*!<Filter bit 6 */
3519#define CAN_F10R1_FB7_Pos (7U)
3520#define CAN_F10R1_FB7_Msk (0x1U << CAN_F10R1_FB7_Pos) /*!< 0x00000080 */
3521#define CAN_F10R1_FB7 CAN_F10R1_FB7_Msk /*!<Filter bit 7 */
3522#define CAN_F10R1_FB8_Pos (8U)
3523#define CAN_F10R1_FB8_Msk (0x1U << CAN_F10R1_FB8_Pos) /*!< 0x00000100 */
3524#define CAN_F10R1_FB8 CAN_F10R1_FB8_Msk /*!<Filter bit 8 */
3525#define CAN_F10R1_FB9_Pos (9U)
3526#define CAN_F10R1_FB9_Msk (0x1U << CAN_F10R1_FB9_Pos) /*!< 0x00000200 */
3527#define CAN_F10R1_FB9 CAN_F10R1_FB9_Msk /*!<Filter bit 9 */
3528#define CAN_F10R1_FB10_Pos (10U)
3529#define CAN_F10R1_FB10_Msk (0x1U << CAN_F10R1_FB10_Pos) /*!< 0x00000400 */
3530#define CAN_F10R1_FB10 CAN_F10R1_FB10_Msk /*!<Filter bit 10 */
3531#define CAN_F10R1_FB11_Pos (11U)
3532#define CAN_F10R1_FB11_Msk (0x1U << CAN_F10R1_FB11_Pos) /*!< 0x00000800 */
3533#define CAN_F10R1_FB11 CAN_F10R1_FB11_Msk /*!<Filter bit 11 */
3534#define CAN_F10R1_FB12_Pos (12U)
3535#define CAN_F10R1_FB12_Msk (0x1U << CAN_F10R1_FB12_Pos) /*!< 0x00001000 */
3536#define CAN_F10R1_FB12 CAN_F10R1_FB12_Msk /*!<Filter bit 12 */
3537#define CAN_F10R1_FB13_Pos (13U)
3538#define CAN_F10R1_FB13_Msk (0x1U << CAN_F10R1_FB13_Pos) /*!< 0x00002000 */
3539#define CAN_F10R1_FB13 CAN_F10R1_FB13_Msk /*!<Filter bit 13 */
3540#define CAN_F10R1_FB14_Pos (14U)
3541#define CAN_F10R1_FB14_Msk (0x1U << CAN_F10R1_FB14_Pos) /*!< 0x00004000 */
3542#define CAN_F10R1_FB14 CAN_F10R1_FB14_Msk /*!<Filter bit 14 */
3543#define CAN_F10R1_FB15_Pos (15U)
3544#define CAN_F10R1_FB15_Msk (0x1U << CAN_F10R1_FB15_Pos) /*!< 0x00008000 */
3545#define CAN_F10R1_FB15 CAN_F10R1_FB15_Msk /*!<Filter bit 15 */
3546#define CAN_F10R1_FB16_Pos (16U)
3547#define CAN_F10R1_FB16_Msk (0x1U << CAN_F10R1_FB16_Pos) /*!< 0x00010000 */
3548#define CAN_F10R1_FB16 CAN_F10R1_FB16_Msk /*!<Filter bit 16 */
3549#define CAN_F10R1_FB17_Pos (17U)
3550#define CAN_F10R1_FB17_Msk (0x1U << CAN_F10R1_FB17_Pos) /*!< 0x00020000 */
3551#define CAN_F10R1_FB17 CAN_F10R1_FB17_Msk /*!<Filter bit 17 */
3552#define CAN_F10R1_FB18_Pos (18U)
3553#define CAN_F10R1_FB18_Msk (0x1U << CAN_F10R1_FB18_Pos) /*!< 0x00040000 */
3554#define CAN_F10R1_FB18 CAN_F10R1_FB18_Msk /*!<Filter bit 18 */
3555#define CAN_F10R1_FB19_Pos (19U)
3556#define CAN_F10R1_FB19_Msk (0x1U << CAN_F10R1_FB19_Pos) /*!< 0x00080000 */
3557#define CAN_F10R1_FB19 CAN_F10R1_FB19_Msk /*!<Filter bit 19 */
3558#define CAN_F10R1_FB20_Pos (20U)
3559#define CAN_F10R1_FB20_Msk (0x1U << CAN_F10R1_FB20_Pos) /*!< 0x00100000 */
3560#define CAN_F10R1_FB20 CAN_F10R1_FB20_Msk /*!<Filter bit 20 */
3561#define CAN_F10R1_FB21_Pos (21U)
3562#define CAN_F10R1_FB21_Msk (0x1U << CAN_F10R1_FB21_Pos) /*!< 0x00200000 */
3563#define CAN_F10R1_FB21 CAN_F10R1_FB21_Msk /*!<Filter bit 21 */
3564#define CAN_F10R1_FB22_Pos (22U)
3565#define CAN_F10R1_FB22_Msk (0x1U << CAN_F10R1_FB22_Pos) /*!< 0x00400000 */
3566#define CAN_F10R1_FB22 CAN_F10R1_FB22_Msk /*!<Filter bit 22 */
3567#define CAN_F10R1_FB23_Pos (23U)
3568#define CAN_F10R1_FB23_Msk (0x1U << CAN_F10R1_FB23_Pos) /*!< 0x00800000 */
3569#define CAN_F10R1_FB23 CAN_F10R1_FB23_Msk /*!<Filter bit 23 */
3570#define CAN_F10R1_FB24_Pos (24U)
3571#define CAN_F10R1_FB24_Msk (0x1U << CAN_F10R1_FB24_Pos) /*!< 0x01000000 */
3572#define CAN_F10R1_FB24 CAN_F10R1_FB24_Msk /*!<Filter bit 24 */
3573#define CAN_F10R1_FB25_Pos (25U)
3574#define CAN_F10R1_FB25_Msk (0x1U << CAN_F10R1_FB25_Pos) /*!< 0x02000000 */
3575#define CAN_F10R1_FB25 CAN_F10R1_FB25_Msk /*!<Filter bit 25 */
3576#define CAN_F10R1_FB26_Pos (26U)
3577#define CAN_F10R1_FB26_Msk (0x1U << CAN_F10R1_FB26_Pos) /*!< 0x04000000 */
3578#define CAN_F10R1_FB26 CAN_F10R1_FB26_Msk /*!<Filter bit 26 */
3579#define CAN_F10R1_FB27_Pos (27U)
3580#define CAN_F10R1_FB27_Msk (0x1U << CAN_F10R1_FB27_Pos) /*!< 0x08000000 */
3581#define CAN_F10R1_FB27 CAN_F10R1_FB27_Msk /*!<Filter bit 27 */
3582#define CAN_F10R1_FB28_Pos (28U)
3583#define CAN_F10R1_FB28_Msk (0x1U << CAN_F10R1_FB28_Pos) /*!< 0x10000000 */
3584#define CAN_F10R1_FB28 CAN_F10R1_FB28_Msk /*!<Filter bit 28 */
3585#define CAN_F10R1_FB29_Pos (29U)
3586#define CAN_F10R1_FB29_Msk (0x1U << CAN_F10R1_FB29_Pos) /*!< 0x20000000 */
3587#define CAN_F10R1_FB29 CAN_F10R1_FB29_Msk /*!<Filter bit 29 */
3588#define CAN_F10R1_FB30_Pos (30U)
3589#define CAN_F10R1_FB30_Msk (0x1U << CAN_F10R1_FB30_Pos) /*!< 0x40000000 */
3590#define CAN_F10R1_FB30 CAN_F10R1_FB30_Msk /*!<Filter bit 30 */
3591#define CAN_F10R1_FB31_Pos (31U)
3592#define CAN_F10R1_FB31_Msk (0x1U << CAN_F10R1_FB31_Pos) /*!< 0x80000000 */
3593#define CAN_F10R1_FB31 CAN_F10R1_FB31_Msk /*!<Filter bit 31 */
3594
3595/******************* Bit definition for CAN_F11R1 register ******************/
3596#define CAN_F11R1_FB0_Pos (0U)
3597#define CAN_F11R1_FB0_Msk (0x1U << CAN_F11R1_FB0_Pos) /*!< 0x00000001 */
3598#define CAN_F11R1_FB0 CAN_F11R1_FB0_Msk /*!<Filter bit 0 */
3599#define CAN_F11R1_FB1_Pos (1U)
3600#define CAN_F11R1_FB1_Msk (0x1U << CAN_F11R1_FB1_Pos) /*!< 0x00000002 */
3601#define CAN_F11R1_FB1 CAN_F11R1_FB1_Msk /*!<Filter bit 1 */
3602#define CAN_F11R1_FB2_Pos (2U)
3603#define CAN_F11R1_FB2_Msk (0x1U << CAN_F11R1_FB2_Pos) /*!< 0x00000004 */
3604#define CAN_F11R1_FB2 CAN_F11R1_FB2_Msk /*!<Filter bit 2 */
3605#define CAN_F11R1_FB3_Pos (3U)
3606#define CAN_F11R1_FB3_Msk (0x1U << CAN_F11R1_FB3_Pos) /*!< 0x00000008 */
3607#define CAN_F11R1_FB3 CAN_F11R1_FB3_Msk /*!<Filter bit 3 */
3608#define CAN_F11R1_FB4_Pos (4U)
3609#define CAN_F11R1_FB4_Msk (0x1U << CAN_F11R1_FB4_Pos) /*!< 0x00000010 */
3610#define CAN_F11R1_FB4 CAN_F11R1_FB4_Msk /*!<Filter bit 4 */
3611#define CAN_F11R1_FB5_Pos (5U)
3612#define CAN_F11R1_FB5_Msk (0x1U << CAN_F11R1_FB5_Pos) /*!< 0x00000020 */
3613#define CAN_F11R1_FB5 CAN_F11R1_FB5_Msk /*!<Filter bit 5 */
3614#define CAN_F11R1_FB6_Pos (6U)
3615#define CAN_F11R1_FB6_Msk (0x1U << CAN_F11R1_FB6_Pos) /*!< 0x00000040 */
3616#define CAN_F11R1_FB6 CAN_F11R1_FB6_Msk /*!<Filter bit 6 */
3617#define CAN_F11R1_FB7_Pos (7U)
3618#define CAN_F11R1_FB7_Msk (0x1U << CAN_F11R1_FB7_Pos) /*!< 0x00000080 */
3619#define CAN_F11R1_FB7 CAN_F11R1_FB7_Msk /*!<Filter bit 7 */
3620#define CAN_F11R1_FB8_Pos (8U)
3621#define CAN_F11R1_FB8_Msk (0x1U << CAN_F11R1_FB8_Pos) /*!< 0x00000100 */
3622#define CAN_F11R1_FB8 CAN_F11R1_FB8_Msk /*!<Filter bit 8 */
3623#define CAN_F11R1_FB9_Pos (9U)
3624#define CAN_F11R1_FB9_Msk (0x1U << CAN_F11R1_FB9_Pos) /*!< 0x00000200 */
3625#define CAN_F11R1_FB9 CAN_F11R1_FB9_Msk /*!<Filter bit 9 */
3626#define CAN_F11R1_FB10_Pos (10U)
3627#define CAN_F11R1_FB10_Msk (0x1U << CAN_F11R1_FB10_Pos) /*!< 0x00000400 */
3628#define CAN_F11R1_FB10 CAN_F11R1_FB10_Msk /*!<Filter bit 10 */
3629#define CAN_F11R1_FB11_Pos (11U)
3630#define CAN_F11R1_FB11_Msk (0x1U << CAN_F11R1_FB11_Pos) /*!< 0x00000800 */
3631#define CAN_F11R1_FB11 CAN_F11R1_FB11_Msk /*!<Filter bit 11 */
3632#define CAN_F11R1_FB12_Pos (12U)
3633#define CAN_F11R1_FB12_Msk (0x1U << CAN_F11R1_FB12_Pos) /*!< 0x00001000 */
3634#define CAN_F11R1_FB12 CAN_F11R1_FB12_Msk /*!<Filter bit 12 */
3635#define CAN_F11R1_FB13_Pos (13U)
3636#define CAN_F11R1_FB13_Msk (0x1U << CAN_F11R1_FB13_Pos) /*!< 0x00002000 */
3637#define CAN_F11R1_FB13 CAN_F11R1_FB13_Msk /*!<Filter bit 13 */
3638#define CAN_F11R1_FB14_Pos (14U)
3639#define CAN_F11R1_FB14_Msk (0x1U << CAN_F11R1_FB14_Pos) /*!< 0x00004000 */
3640#define CAN_F11R1_FB14 CAN_F11R1_FB14_Msk /*!<Filter bit 14 */
3641#define CAN_F11R1_FB15_Pos (15U)
3642#define CAN_F11R1_FB15_Msk (0x1U << CAN_F11R1_FB15_Pos) /*!< 0x00008000 */
3643#define CAN_F11R1_FB15 CAN_F11R1_FB15_Msk /*!<Filter bit 15 */
3644#define CAN_F11R1_FB16_Pos (16U)
3645#define CAN_F11R1_FB16_Msk (0x1U << CAN_F11R1_FB16_Pos) /*!< 0x00010000 */
3646#define CAN_F11R1_FB16 CAN_F11R1_FB16_Msk /*!<Filter bit 16 */
3647#define CAN_F11R1_FB17_Pos (17U)
3648#define CAN_F11R1_FB17_Msk (0x1U << CAN_F11R1_FB17_Pos) /*!< 0x00020000 */
3649#define CAN_F11R1_FB17 CAN_F11R1_FB17_Msk /*!<Filter bit 17 */
3650#define CAN_F11R1_FB18_Pos (18U)
3651#define CAN_F11R1_FB18_Msk (0x1U << CAN_F11R1_FB18_Pos) /*!< 0x00040000 */
3652#define CAN_F11R1_FB18 CAN_F11R1_FB18_Msk /*!<Filter bit 18 */
3653#define CAN_F11R1_FB19_Pos (19U)
3654#define CAN_F11R1_FB19_Msk (0x1U << CAN_F11R1_FB19_Pos) /*!< 0x00080000 */
3655#define CAN_F11R1_FB19 CAN_F11R1_FB19_Msk /*!<Filter bit 19 */
3656#define CAN_F11R1_FB20_Pos (20U)
3657#define CAN_F11R1_FB20_Msk (0x1U << CAN_F11R1_FB20_Pos) /*!< 0x00100000 */
3658#define CAN_F11R1_FB20 CAN_F11R1_FB20_Msk /*!<Filter bit 20 */
3659#define CAN_F11R1_FB21_Pos (21U)
3660#define CAN_F11R1_FB21_Msk (0x1U << CAN_F11R1_FB21_Pos) /*!< 0x00200000 */
3661#define CAN_F11R1_FB21 CAN_F11R1_FB21_Msk /*!<Filter bit 21 */
3662#define CAN_F11R1_FB22_Pos (22U)
3663#define CAN_F11R1_FB22_Msk (0x1U << CAN_F11R1_FB22_Pos) /*!< 0x00400000 */
3664#define CAN_F11R1_FB22 CAN_F11R1_FB22_Msk /*!<Filter bit 22 */
3665#define CAN_F11R1_FB23_Pos (23U)
3666#define CAN_F11R1_FB23_Msk (0x1U << CAN_F11R1_FB23_Pos) /*!< 0x00800000 */
3667#define CAN_F11R1_FB23 CAN_F11R1_FB23_Msk /*!<Filter bit 23 */
3668#define CAN_F11R1_FB24_Pos (24U)
3669#define CAN_F11R1_FB24_Msk (0x1U << CAN_F11R1_FB24_Pos) /*!< 0x01000000 */
3670#define CAN_F11R1_FB24 CAN_F11R1_FB24_Msk /*!<Filter bit 24 */
3671#define CAN_F11R1_FB25_Pos (25U)
3672#define CAN_F11R1_FB25_Msk (0x1U << CAN_F11R1_FB25_Pos) /*!< 0x02000000 */
3673#define CAN_F11R1_FB25 CAN_F11R1_FB25_Msk /*!<Filter bit 25 */
3674#define CAN_F11R1_FB26_Pos (26U)
3675#define CAN_F11R1_FB26_Msk (0x1U << CAN_F11R1_FB26_Pos) /*!< 0x04000000 */
3676#define CAN_F11R1_FB26 CAN_F11R1_FB26_Msk /*!<Filter bit 26 */
3677#define CAN_F11R1_FB27_Pos (27U)
3678#define CAN_F11R1_FB27_Msk (0x1U << CAN_F11R1_FB27_Pos) /*!< 0x08000000 */
3679#define CAN_F11R1_FB27 CAN_F11R1_FB27_Msk /*!<Filter bit 27 */
3680#define CAN_F11R1_FB28_Pos (28U)
3681#define CAN_F11R1_FB28_Msk (0x1U << CAN_F11R1_FB28_Pos) /*!< 0x10000000 */
3682#define CAN_F11R1_FB28 CAN_F11R1_FB28_Msk /*!<Filter bit 28 */
3683#define CAN_F11R1_FB29_Pos (29U)
3684#define CAN_F11R1_FB29_Msk (0x1U << CAN_F11R1_FB29_Pos) /*!< 0x20000000 */
3685#define CAN_F11R1_FB29 CAN_F11R1_FB29_Msk /*!<Filter bit 29 */
3686#define CAN_F11R1_FB30_Pos (30U)
3687#define CAN_F11R1_FB30_Msk (0x1U << CAN_F11R1_FB30_Pos) /*!< 0x40000000 */
3688#define CAN_F11R1_FB30 CAN_F11R1_FB30_Msk /*!<Filter bit 30 */
3689#define CAN_F11R1_FB31_Pos (31U)
3690#define CAN_F11R1_FB31_Msk (0x1U << CAN_F11R1_FB31_Pos) /*!< 0x80000000 */
3691#define CAN_F11R1_FB31 CAN_F11R1_FB31_Msk /*!<Filter bit 31 */
3692
3693/******************* Bit definition for CAN_F12R1 register ******************/
3694#define CAN_F12R1_FB0_Pos (0U)
3695#define CAN_F12R1_FB0_Msk (0x1U << CAN_F12R1_FB0_Pos) /*!< 0x00000001 */
3696#define CAN_F12R1_FB0 CAN_F12R1_FB0_Msk /*!<Filter bit 0 */
3697#define CAN_F12R1_FB1_Pos (1U)
3698#define CAN_F12R1_FB1_Msk (0x1U << CAN_F12R1_FB1_Pos) /*!< 0x00000002 */
3699#define CAN_F12R1_FB1 CAN_F12R1_FB1_Msk /*!<Filter bit 1 */
3700#define CAN_F12R1_FB2_Pos (2U)
3701#define CAN_F12R1_FB2_Msk (0x1U << CAN_F12R1_FB2_Pos) /*!< 0x00000004 */
3702#define CAN_F12R1_FB2 CAN_F12R1_FB2_Msk /*!<Filter bit 2 */
3703#define CAN_F12R1_FB3_Pos (3U)
3704#define CAN_F12R1_FB3_Msk (0x1U << CAN_F12R1_FB3_Pos) /*!< 0x00000008 */
3705#define CAN_F12R1_FB3 CAN_F12R1_FB3_Msk /*!<Filter bit 3 */
3706#define CAN_F12R1_FB4_Pos (4U)
3707#define CAN_F12R1_FB4_Msk (0x1U << CAN_F12R1_FB4_Pos) /*!< 0x00000010 */
3708#define CAN_F12R1_FB4 CAN_F12R1_FB4_Msk /*!<Filter bit 4 */
3709#define CAN_F12R1_FB5_Pos (5U)
3710#define CAN_F12R1_FB5_Msk (0x1U << CAN_F12R1_FB5_Pos) /*!< 0x00000020 */
3711#define CAN_F12R1_FB5 CAN_F12R1_FB5_Msk /*!<Filter bit 5 */
3712#define CAN_F12R1_FB6_Pos (6U)
3713#define CAN_F12R1_FB6_Msk (0x1U << CAN_F12R1_FB6_Pos) /*!< 0x00000040 */
3714#define CAN_F12R1_FB6 CAN_F12R1_FB6_Msk /*!<Filter bit 6 */
3715#define CAN_F12R1_FB7_Pos (7U)
3716#define CAN_F12R1_FB7_Msk (0x1U << CAN_F12R1_FB7_Pos) /*!< 0x00000080 */
3717#define CAN_F12R1_FB7 CAN_F12R1_FB7_Msk /*!<Filter bit 7 */
3718#define CAN_F12R1_FB8_Pos (8U)
3719#define CAN_F12R1_FB8_Msk (0x1U << CAN_F12R1_FB8_Pos) /*!< 0x00000100 */
3720#define CAN_F12R1_FB8 CAN_F12R1_FB8_Msk /*!<Filter bit 8 */
3721#define CAN_F12R1_FB9_Pos (9U)
3722#define CAN_F12R1_FB9_Msk (0x1U << CAN_F12R1_FB9_Pos) /*!< 0x00000200 */
3723#define CAN_F12R1_FB9 CAN_F12R1_FB9_Msk /*!<Filter bit 9 */
3724#define CAN_F12R1_FB10_Pos (10U)
3725#define CAN_F12R1_FB10_Msk (0x1U << CAN_F12R1_FB10_Pos) /*!< 0x00000400 */
3726#define CAN_F12R1_FB10 CAN_F12R1_FB10_Msk /*!<Filter bit 10 */
3727#define CAN_F12R1_FB11_Pos (11U)
3728#define CAN_F12R1_FB11_Msk (0x1U << CAN_F12R1_FB11_Pos) /*!< 0x00000800 */
3729#define CAN_F12R1_FB11 CAN_F12R1_FB11_Msk /*!<Filter bit 11 */
3730#define CAN_F12R1_FB12_Pos (12U)
3731#define CAN_F12R1_FB12_Msk (0x1U << CAN_F12R1_FB12_Pos) /*!< 0x00001000 */
3732#define CAN_F12R1_FB12 CAN_F12R1_FB12_Msk /*!<Filter bit 12 */
3733#define CAN_F12R1_FB13_Pos (13U)
3734#define CAN_F12R1_FB13_Msk (0x1U << CAN_F12R1_FB13_Pos) /*!< 0x00002000 */
3735#define CAN_F12R1_FB13 CAN_F12R1_FB13_Msk /*!<Filter bit 13 */
3736#define CAN_F12R1_FB14_Pos (14U)
3737#define CAN_F12R1_FB14_Msk (0x1U << CAN_F12R1_FB14_Pos) /*!< 0x00004000 */
3738#define CAN_F12R1_FB14 CAN_F12R1_FB14_Msk /*!<Filter bit 14 */
3739#define CAN_F12R1_FB15_Pos (15U)
3740#define CAN_F12R1_FB15_Msk (0x1U << CAN_F12R1_FB15_Pos) /*!< 0x00008000 */
3741#define CAN_F12R1_FB15 CAN_F12R1_FB15_Msk /*!<Filter bit 15 */
3742#define CAN_F12R1_FB16_Pos (16U)
3743#define CAN_F12R1_FB16_Msk (0x1U << CAN_F12R1_FB16_Pos) /*!< 0x00010000 */
3744#define CAN_F12R1_FB16 CAN_F12R1_FB16_Msk /*!<Filter bit 16 */
3745#define CAN_F12R1_FB17_Pos (17U)
3746#define CAN_F12R1_FB17_Msk (0x1U << CAN_F12R1_FB17_Pos) /*!< 0x00020000 */
3747#define CAN_F12R1_FB17 CAN_F12R1_FB17_Msk /*!<Filter bit 17 */
3748#define CAN_F12R1_FB18_Pos (18U)
3749#define CAN_F12R1_FB18_Msk (0x1U << CAN_F12R1_FB18_Pos) /*!< 0x00040000 */
3750#define CAN_F12R1_FB18 CAN_F12R1_FB18_Msk /*!<Filter bit 18 */
3751#define CAN_F12R1_FB19_Pos (19U)
3752#define CAN_F12R1_FB19_Msk (0x1U << CAN_F12R1_FB19_Pos) /*!< 0x00080000 */
3753#define CAN_F12R1_FB19 CAN_F12R1_FB19_Msk /*!<Filter bit 19 */
3754#define CAN_F12R1_FB20_Pos (20U)
3755#define CAN_F12R1_FB20_Msk (0x1U << CAN_F12R1_FB20_Pos) /*!< 0x00100000 */
3756#define CAN_F12R1_FB20 CAN_F12R1_FB20_Msk /*!<Filter bit 20 */
3757#define CAN_F12R1_FB21_Pos (21U)
3758#define CAN_F12R1_FB21_Msk (0x1U << CAN_F12R1_FB21_Pos) /*!< 0x00200000 */
3759#define CAN_F12R1_FB21 CAN_F12R1_FB21_Msk /*!<Filter bit 21 */
3760#define CAN_F12R1_FB22_Pos (22U)
3761#define CAN_F12R1_FB22_Msk (0x1U << CAN_F12R1_FB22_Pos) /*!< 0x00400000 */
3762#define CAN_F12R1_FB22 CAN_F12R1_FB22_Msk /*!<Filter bit 22 */
3763#define CAN_F12R1_FB23_Pos (23U)
3764#define CAN_F12R1_FB23_Msk (0x1U << CAN_F12R1_FB23_Pos) /*!< 0x00800000 */
3765#define CAN_F12R1_FB23 CAN_F12R1_FB23_Msk /*!<Filter bit 23 */
3766#define CAN_F12R1_FB24_Pos (24U)
3767#define CAN_F12R1_FB24_Msk (0x1U << CAN_F12R1_FB24_Pos) /*!< 0x01000000 */
3768#define CAN_F12R1_FB24 CAN_F12R1_FB24_Msk /*!<Filter bit 24 */
3769#define CAN_F12R1_FB25_Pos (25U)
3770#define CAN_F12R1_FB25_Msk (0x1U << CAN_F12R1_FB25_Pos) /*!< 0x02000000 */
3771#define CAN_F12R1_FB25 CAN_F12R1_FB25_Msk /*!<Filter bit 25 */
3772#define CAN_F12R1_FB26_Pos (26U)
3773#define CAN_F12R1_FB26_Msk (0x1U << CAN_F12R1_FB26_Pos) /*!< 0x04000000 */
3774#define CAN_F12R1_FB26 CAN_F12R1_FB26_Msk /*!<Filter bit 26 */
3775#define CAN_F12R1_FB27_Pos (27U)
3776#define CAN_F12R1_FB27_Msk (0x1U << CAN_F12R1_FB27_Pos) /*!< 0x08000000 */
3777#define CAN_F12R1_FB27 CAN_F12R1_FB27_Msk /*!<Filter bit 27 */
3778#define CAN_F12R1_FB28_Pos (28U)
3779#define CAN_F12R1_FB28_Msk (0x1U << CAN_F12R1_FB28_Pos) /*!< 0x10000000 */
3780#define CAN_F12R1_FB28 CAN_F12R1_FB28_Msk /*!<Filter bit 28 */
3781#define CAN_F12R1_FB29_Pos (29U)
3782#define CAN_F12R1_FB29_Msk (0x1U << CAN_F12R1_FB29_Pos) /*!< 0x20000000 */
3783#define CAN_F12R1_FB29 CAN_F12R1_FB29_Msk /*!<Filter bit 29 */
3784#define CAN_F12R1_FB30_Pos (30U)
3785#define CAN_F12R1_FB30_Msk (0x1U << CAN_F12R1_FB30_Pos) /*!< 0x40000000 */
3786#define CAN_F12R1_FB30 CAN_F12R1_FB30_Msk /*!<Filter bit 30 */
3787#define CAN_F12R1_FB31_Pos (31U)
3788#define CAN_F12R1_FB31_Msk (0x1U << CAN_F12R1_FB31_Pos) /*!< 0x80000000 */
3789#define CAN_F12R1_FB31 CAN_F12R1_FB31_Msk /*!<Filter bit 31 */
3790
3791/******************* Bit definition for CAN_F13R1 register ******************/
3792#define CAN_F13R1_FB0_Pos (0U)
3793#define CAN_F13R1_FB0_Msk (0x1U << CAN_F13R1_FB0_Pos) /*!< 0x00000001 */
3794#define CAN_F13R1_FB0 CAN_F13R1_FB0_Msk /*!<Filter bit 0 */
3795#define CAN_F13R1_FB1_Pos (1U)
3796#define CAN_F13R1_FB1_Msk (0x1U << CAN_F13R1_FB1_Pos) /*!< 0x00000002 */
3797#define CAN_F13R1_FB1 CAN_F13R1_FB1_Msk /*!<Filter bit 1 */
3798#define CAN_F13R1_FB2_Pos (2U)
3799#define CAN_F13R1_FB2_Msk (0x1U << CAN_F13R1_FB2_Pos) /*!< 0x00000004 */
3800#define CAN_F13R1_FB2 CAN_F13R1_FB2_Msk /*!<Filter bit 2 */
3801#define CAN_F13R1_FB3_Pos (3U)
3802#define CAN_F13R1_FB3_Msk (0x1U << CAN_F13R1_FB3_Pos) /*!< 0x00000008 */
3803#define CAN_F13R1_FB3 CAN_F13R1_FB3_Msk /*!<Filter bit 3 */
3804#define CAN_F13R1_FB4_Pos (4U)
3805#define CAN_F13R1_FB4_Msk (0x1U << CAN_F13R1_FB4_Pos) /*!< 0x00000010 */
3806#define CAN_F13R1_FB4 CAN_F13R1_FB4_Msk /*!<Filter bit 4 */
3807#define CAN_F13R1_FB5_Pos (5U)
3808#define CAN_F13R1_FB5_Msk (0x1U << CAN_F13R1_FB5_Pos) /*!< 0x00000020 */
3809#define CAN_F13R1_FB5 CAN_F13R1_FB5_Msk /*!<Filter bit 5 */
3810#define CAN_F13R1_FB6_Pos (6U)
3811#define CAN_F13R1_FB6_Msk (0x1U << CAN_F13R1_FB6_Pos) /*!< 0x00000040 */
3812#define CAN_F13R1_FB6 CAN_F13R1_FB6_Msk /*!<Filter bit 6 */
3813#define CAN_F13R1_FB7_Pos (7U)
3814#define CAN_F13R1_FB7_Msk (0x1U << CAN_F13R1_FB7_Pos) /*!< 0x00000080 */
3815#define CAN_F13R1_FB7 CAN_F13R1_FB7_Msk /*!<Filter bit 7 */
3816#define CAN_F13R1_FB8_Pos (8U)
3817#define CAN_F13R1_FB8_Msk (0x1U << CAN_F13R1_FB8_Pos) /*!< 0x00000100 */
3818#define CAN_F13R1_FB8 CAN_F13R1_FB8_Msk /*!<Filter bit 8 */
3819#define CAN_F13R1_FB9_Pos (9U)
3820#define CAN_F13R1_FB9_Msk (0x1U << CAN_F13R1_FB9_Pos) /*!< 0x00000200 */
3821#define CAN_F13R1_FB9 CAN_F13R1_FB9_Msk /*!<Filter bit 9 */
3822#define CAN_F13R1_FB10_Pos (10U)
3823#define CAN_F13R1_FB10_Msk (0x1U << CAN_F13R1_FB10_Pos) /*!< 0x00000400 */
3824#define CAN_F13R1_FB10 CAN_F13R1_FB10_Msk /*!<Filter bit 10 */
3825#define CAN_F13R1_FB11_Pos (11U)
3826#define CAN_F13R1_FB11_Msk (0x1U << CAN_F13R1_FB11_Pos) /*!< 0x00000800 */
3827#define CAN_F13R1_FB11 CAN_F13R1_FB11_Msk /*!<Filter bit 11 */
3828#define CAN_F13R1_FB12_Pos (12U)
3829#define CAN_F13R1_FB12_Msk (0x1U << CAN_F13R1_FB12_Pos) /*!< 0x00001000 */
3830#define CAN_F13R1_FB12 CAN_F13R1_FB12_Msk /*!<Filter bit 12 */
3831#define CAN_F13R1_FB13_Pos (13U)
3832#define CAN_F13R1_FB13_Msk (0x1U << CAN_F13R1_FB13_Pos) /*!< 0x00002000 */
3833#define CAN_F13R1_FB13 CAN_F13R1_FB13_Msk /*!<Filter bit 13 */
3834#define CAN_F13R1_FB14_Pos (14U)
3835#define CAN_F13R1_FB14_Msk (0x1U << CAN_F13R1_FB14_Pos) /*!< 0x00004000 */
3836#define CAN_F13R1_FB14 CAN_F13R1_FB14_Msk /*!<Filter bit 14 */
3837#define CAN_F13R1_FB15_Pos (15U)
3838#define CAN_F13R1_FB15_Msk (0x1U << CAN_F13R1_FB15_Pos) /*!< 0x00008000 */
3839#define CAN_F13R1_FB15 CAN_F13R1_FB15_Msk /*!<Filter bit 15 */
3840#define CAN_F13R1_FB16_Pos (16U)
3841#define CAN_F13R1_FB16_Msk (0x1U << CAN_F13R1_FB16_Pos) /*!< 0x00010000 */
3842#define CAN_F13R1_FB16 CAN_F13R1_FB16_Msk /*!<Filter bit 16 */
3843#define CAN_F13R1_FB17_Pos (17U)
3844#define CAN_F13R1_FB17_Msk (0x1U << CAN_F13R1_FB17_Pos) /*!< 0x00020000 */
3845#define CAN_F13R1_FB17 CAN_F13R1_FB17_Msk /*!<Filter bit 17 */
3846#define CAN_F13R1_FB18_Pos (18U)
3847#define CAN_F13R1_FB18_Msk (0x1U << CAN_F13R1_FB18_Pos) /*!< 0x00040000 */
3848#define CAN_F13R1_FB18 CAN_F13R1_FB18_Msk /*!<Filter bit 18 */
3849#define CAN_F13R1_FB19_Pos (19U)
3850#define CAN_F13R1_FB19_Msk (0x1U << CAN_F13R1_FB19_Pos) /*!< 0x00080000 */
3851#define CAN_F13R1_FB19 CAN_F13R1_FB19_Msk /*!<Filter bit 19 */
3852#define CAN_F13R1_FB20_Pos (20U)
3853#define CAN_F13R1_FB20_Msk (0x1U << CAN_F13R1_FB20_Pos) /*!< 0x00100000 */
3854#define CAN_F13R1_FB20 CAN_F13R1_FB20_Msk /*!<Filter bit 20 */
3855#define CAN_F13R1_FB21_Pos (21U)
3856#define CAN_F13R1_FB21_Msk (0x1U << CAN_F13R1_FB21_Pos) /*!< 0x00200000 */
3857#define CAN_F13R1_FB21 CAN_F13R1_FB21_Msk /*!<Filter bit 21 */
3858#define CAN_F13R1_FB22_Pos (22U)
3859#define CAN_F13R1_FB22_Msk (0x1U << CAN_F13R1_FB22_Pos) /*!< 0x00400000 */
3860#define CAN_F13R1_FB22 CAN_F13R1_FB22_Msk /*!<Filter bit 22 */
3861#define CAN_F13R1_FB23_Pos (23U)
3862#define CAN_F13R1_FB23_Msk (0x1U << CAN_F13R1_FB23_Pos) /*!< 0x00800000 */
3863#define CAN_F13R1_FB23 CAN_F13R1_FB23_Msk /*!<Filter bit 23 */
3864#define CAN_F13R1_FB24_Pos (24U)
3865#define CAN_F13R1_FB24_Msk (0x1U << CAN_F13R1_FB24_Pos) /*!< 0x01000000 */
3866#define CAN_F13R1_FB24 CAN_F13R1_FB24_Msk /*!<Filter bit 24 */
3867#define CAN_F13R1_FB25_Pos (25U)
3868#define CAN_F13R1_FB25_Msk (0x1U << CAN_F13R1_FB25_Pos) /*!< 0x02000000 */
3869#define CAN_F13R1_FB25 CAN_F13R1_FB25_Msk /*!<Filter bit 25 */
3870#define CAN_F13R1_FB26_Pos (26U)
3871#define CAN_F13R1_FB26_Msk (0x1U << CAN_F13R1_FB26_Pos) /*!< 0x04000000 */
3872#define CAN_F13R1_FB26 CAN_F13R1_FB26_Msk /*!<Filter bit 26 */
3873#define CAN_F13R1_FB27_Pos (27U)
3874#define CAN_F13R1_FB27_Msk (0x1U << CAN_F13R1_FB27_Pos) /*!< 0x08000000 */
3875#define CAN_F13R1_FB27 CAN_F13R1_FB27_Msk /*!<Filter bit 27 */
3876#define CAN_F13R1_FB28_Pos (28U)
3877#define CAN_F13R1_FB28_Msk (0x1U << CAN_F13R1_FB28_Pos) /*!< 0x10000000 */
3878#define CAN_F13R1_FB28 CAN_F13R1_FB28_Msk /*!<Filter bit 28 */
3879#define CAN_F13R1_FB29_Pos (29U)
3880#define CAN_F13R1_FB29_Msk (0x1U << CAN_F13R1_FB29_Pos) /*!< 0x20000000 */
3881#define CAN_F13R1_FB29 CAN_F13R1_FB29_Msk /*!<Filter bit 29 */
3882#define CAN_F13R1_FB30_Pos (30U)
3883#define CAN_F13R1_FB30_Msk (0x1U << CAN_F13R1_FB30_Pos) /*!< 0x40000000 */
3884#define CAN_F13R1_FB30 CAN_F13R1_FB30_Msk /*!<Filter bit 30 */
3885#define CAN_F13R1_FB31_Pos (31U)
3886#define CAN_F13R1_FB31_Msk (0x1U << CAN_F13R1_FB31_Pos) /*!< 0x80000000 */
3887#define CAN_F13R1_FB31 CAN_F13R1_FB31_Msk /*!<Filter bit 31 */
3888
3889/******************* Bit definition for CAN_F0R2 register *******************/
3890#define CAN_F0R2_FB0_Pos (0U)
3891#define CAN_F0R2_FB0_Msk (0x1U << CAN_F0R2_FB0_Pos) /*!< 0x00000001 */
3892#define CAN_F0R2_FB0 CAN_F0R2_FB0_Msk /*!<Filter bit 0 */
3893#define CAN_F0R2_FB1_Pos (1U)
3894#define CAN_F0R2_FB1_Msk (0x1U << CAN_F0R2_FB1_Pos) /*!< 0x00000002 */
3895#define CAN_F0R2_FB1 CAN_F0R2_FB1_Msk /*!<Filter bit 1 */
3896#define CAN_F0R2_FB2_Pos (2U)
3897#define CAN_F0R2_FB2_Msk (0x1U << CAN_F0R2_FB2_Pos) /*!< 0x00000004 */
3898#define CAN_F0R2_FB2 CAN_F0R2_FB2_Msk /*!<Filter bit 2 */
3899#define CAN_F0R2_FB3_Pos (3U)
3900#define CAN_F0R2_FB3_Msk (0x1U << CAN_F0R2_FB3_Pos) /*!< 0x00000008 */
3901#define CAN_F0R2_FB3 CAN_F0R2_FB3_Msk /*!<Filter bit 3 */
3902#define CAN_F0R2_FB4_Pos (4U)
3903#define CAN_F0R2_FB4_Msk (0x1U << CAN_F0R2_FB4_Pos) /*!< 0x00000010 */
3904#define CAN_F0R2_FB4 CAN_F0R2_FB4_Msk /*!<Filter bit 4 */
3905#define CAN_F0R2_FB5_Pos (5U)
3906#define CAN_F0R2_FB5_Msk (0x1U << CAN_F0R2_FB5_Pos) /*!< 0x00000020 */
3907#define CAN_F0R2_FB5 CAN_F0R2_FB5_Msk /*!<Filter bit 5 */
3908#define CAN_F0R2_FB6_Pos (6U)
3909#define CAN_F0R2_FB6_Msk (0x1U << CAN_F0R2_FB6_Pos) /*!< 0x00000040 */
3910#define CAN_F0R2_FB6 CAN_F0R2_FB6_Msk /*!<Filter bit 6 */
3911#define CAN_F0R2_FB7_Pos (7U)
3912#define CAN_F0R2_FB7_Msk (0x1U << CAN_F0R2_FB7_Pos) /*!< 0x00000080 */
3913#define CAN_F0R2_FB7 CAN_F0R2_FB7_Msk /*!<Filter bit 7 */
3914#define CAN_F0R2_FB8_Pos (8U)
3915#define CAN_F0R2_FB8_Msk (0x1U << CAN_F0R2_FB8_Pos) /*!< 0x00000100 */
3916#define CAN_F0R2_FB8 CAN_F0R2_FB8_Msk /*!<Filter bit 8 */
3917#define CAN_F0R2_FB9_Pos (9U)
3918#define CAN_F0R2_FB9_Msk (0x1U << CAN_F0R2_FB9_Pos) /*!< 0x00000200 */
3919#define CAN_F0R2_FB9 CAN_F0R2_FB9_Msk /*!<Filter bit 9 */
3920#define CAN_F0R2_FB10_Pos (10U)
3921#define CAN_F0R2_FB10_Msk (0x1U << CAN_F0R2_FB10_Pos) /*!< 0x00000400 */
3922#define CAN_F0R2_FB10 CAN_F0R2_FB10_Msk /*!<Filter bit 10 */
3923#define CAN_F0R2_FB11_Pos (11U)
3924#define CAN_F0R2_FB11_Msk (0x1U << CAN_F0R2_FB11_Pos) /*!< 0x00000800 */
3925#define CAN_F0R2_FB11 CAN_F0R2_FB11_Msk /*!<Filter bit 11 */
3926#define CAN_F0R2_FB12_Pos (12U)
3927#define CAN_F0R2_FB12_Msk (0x1U << CAN_F0R2_FB12_Pos) /*!< 0x00001000 */
3928#define CAN_F0R2_FB12 CAN_F0R2_FB12_Msk /*!<Filter bit 12 */
3929#define CAN_F0R2_FB13_Pos (13U)
3930#define CAN_F0R2_FB13_Msk (0x1U << CAN_F0R2_FB13_Pos) /*!< 0x00002000 */
3931#define CAN_F0R2_FB13 CAN_F0R2_FB13_Msk /*!<Filter bit 13 */
3932#define CAN_F0R2_FB14_Pos (14U)
3933#define CAN_F0R2_FB14_Msk (0x1U << CAN_F0R2_FB14_Pos) /*!< 0x00004000 */
3934#define CAN_F0R2_FB14 CAN_F0R2_FB14_Msk /*!<Filter bit 14 */
3935#define CAN_F0R2_FB15_Pos (15U)
3936#define CAN_F0R2_FB15_Msk (0x1U << CAN_F0R2_FB15_Pos) /*!< 0x00008000 */
3937#define CAN_F0R2_FB15 CAN_F0R2_FB15_Msk /*!<Filter bit 15 */
3938#define CAN_F0R2_FB16_Pos (16U)
3939#define CAN_F0R2_FB16_Msk (0x1U << CAN_F0R2_FB16_Pos) /*!< 0x00010000 */
3940#define CAN_F0R2_FB16 CAN_F0R2_FB16_Msk /*!<Filter bit 16 */
3941#define CAN_F0R2_FB17_Pos (17U)
3942#define CAN_F0R2_FB17_Msk (0x1U << CAN_F0R2_FB17_Pos) /*!< 0x00020000 */
3943#define CAN_F0R2_FB17 CAN_F0R2_FB17_Msk /*!<Filter bit 17 */
3944#define CAN_F0R2_FB18_Pos (18U)
3945#define CAN_F0R2_FB18_Msk (0x1U << CAN_F0R2_FB18_Pos) /*!< 0x00040000 */
3946#define CAN_F0R2_FB18 CAN_F0R2_FB18_Msk /*!<Filter bit 18 */
3947#define CAN_F0R2_FB19_Pos (19U)
3948#define CAN_F0R2_FB19_Msk (0x1U << CAN_F0R2_FB19_Pos) /*!< 0x00080000 */
3949#define CAN_F0R2_FB19 CAN_F0R2_FB19_Msk /*!<Filter bit 19 */
3950#define CAN_F0R2_FB20_Pos (20U)
3951#define CAN_F0R2_FB20_Msk (0x1U << CAN_F0R2_FB20_Pos) /*!< 0x00100000 */
3952#define CAN_F0R2_FB20 CAN_F0R2_FB20_Msk /*!<Filter bit 20 */
3953#define CAN_F0R2_FB21_Pos (21U)
3954#define CAN_F0R2_FB21_Msk (0x1U << CAN_F0R2_FB21_Pos) /*!< 0x00200000 */
3955#define CAN_F0R2_FB21 CAN_F0R2_FB21_Msk /*!<Filter bit 21 */
3956#define CAN_F0R2_FB22_Pos (22U)
3957#define CAN_F0R2_FB22_Msk (0x1U << CAN_F0R2_FB22_Pos) /*!< 0x00400000 */
3958#define CAN_F0R2_FB22 CAN_F0R2_FB22_Msk /*!<Filter bit 22 */
3959#define CAN_F0R2_FB23_Pos (23U)
3960#define CAN_F0R2_FB23_Msk (0x1U << CAN_F0R2_FB23_Pos) /*!< 0x00800000 */
3961#define CAN_F0R2_FB23 CAN_F0R2_FB23_Msk /*!<Filter bit 23 */
3962#define CAN_F0R2_FB24_Pos (24U)
3963#define CAN_F0R2_FB24_Msk (0x1U << CAN_F0R2_FB24_Pos) /*!< 0x01000000 */
3964#define CAN_F0R2_FB24 CAN_F0R2_FB24_Msk /*!<Filter bit 24 */
3965#define CAN_F0R2_FB25_Pos (25U)
3966#define CAN_F0R2_FB25_Msk (0x1U << CAN_F0R2_FB25_Pos) /*!< 0x02000000 */
3967#define CAN_F0R2_FB25 CAN_F0R2_FB25_Msk /*!<Filter bit 25 */
3968#define CAN_F0R2_FB26_Pos (26U)
3969#define CAN_F0R2_FB26_Msk (0x1U << CAN_F0R2_FB26_Pos) /*!< 0x04000000 */
3970#define CAN_F0R2_FB26 CAN_F0R2_FB26_Msk /*!<Filter bit 26 */
3971#define CAN_F0R2_FB27_Pos (27U)
3972#define CAN_F0R2_FB27_Msk (0x1U << CAN_F0R2_FB27_Pos) /*!< 0x08000000 */
3973#define CAN_F0R2_FB27 CAN_F0R2_FB27_Msk /*!<Filter bit 27 */
3974#define CAN_F0R2_FB28_Pos (28U)
3975#define CAN_F0R2_FB28_Msk (0x1U << CAN_F0R2_FB28_Pos) /*!< 0x10000000 */
3976#define CAN_F0R2_FB28 CAN_F0R2_FB28_Msk /*!<Filter bit 28 */
3977#define CAN_F0R2_FB29_Pos (29U)
3978#define CAN_F0R2_FB29_Msk (0x1U << CAN_F0R2_FB29_Pos) /*!< 0x20000000 */
3979#define CAN_F0R2_FB29 CAN_F0R2_FB29_Msk /*!<Filter bit 29 */
3980#define CAN_F0R2_FB30_Pos (30U)
3981#define CAN_F0R2_FB30_Msk (0x1U << CAN_F0R2_FB30_Pos) /*!< 0x40000000 */
3982#define CAN_F0R2_FB30 CAN_F0R2_FB30_Msk /*!<Filter bit 30 */
3983#define CAN_F0R2_FB31_Pos (31U)
3984#define CAN_F0R2_FB31_Msk (0x1U << CAN_F0R2_FB31_Pos) /*!< 0x80000000 */
3985#define CAN_F0R2_FB31 CAN_F0R2_FB31_Msk /*!<Filter bit 31 */
3986
3987/******************* Bit definition for CAN_F1R2 register *******************/
3988#define CAN_F1R2_FB0_Pos (0U)
3989#define CAN_F1R2_FB0_Msk (0x1U << CAN_F1R2_FB0_Pos) /*!< 0x00000001 */
3990#define CAN_F1R2_FB0 CAN_F1R2_FB0_Msk /*!<Filter bit 0 */
3991#define CAN_F1R2_FB1_Pos (1U)
3992#define CAN_F1R2_FB1_Msk (0x1U << CAN_F1R2_FB1_Pos) /*!< 0x00000002 */
3993#define CAN_F1R2_FB1 CAN_F1R2_FB1_Msk /*!<Filter bit 1 */
3994#define CAN_F1R2_FB2_Pos (2U)
3995#define CAN_F1R2_FB2_Msk (0x1U << CAN_F1R2_FB2_Pos) /*!< 0x00000004 */
3996#define CAN_F1R2_FB2 CAN_F1R2_FB2_Msk /*!<Filter bit 2 */
3997#define CAN_F1R2_FB3_Pos (3U)
3998#define CAN_F1R2_FB3_Msk (0x1U << CAN_F1R2_FB3_Pos) /*!< 0x00000008 */
3999#define CAN_F1R2_FB3 CAN_F1R2_FB3_Msk /*!<Filter bit 3 */
4000#define CAN_F1R2_FB4_Pos (4U)
4001#define CAN_F1R2_FB4_Msk (0x1U << CAN_F1R2_FB4_Pos) /*!< 0x00000010 */
4002#define CAN_F1R2_FB4 CAN_F1R2_FB4_Msk /*!<Filter bit 4 */
4003#define CAN_F1R2_FB5_Pos (5U)
4004#define CAN_F1R2_FB5_Msk (0x1U << CAN_F1R2_FB5_Pos) /*!< 0x00000020 */
4005#define CAN_F1R2_FB5 CAN_F1R2_FB5_Msk /*!<Filter bit 5 */
4006#define CAN_F1R2_FB6_Pos (6U)
4007#define CAN_F1R2_FB6_Msk (0x1U << CAN_F1R2_FB6_Pos) /*!< 0x00000040 */
4008#define CAN_F1R2_FB6 CAN_F1R2_FB6_Msk /*!<Filter bit 6 */
4009#define CAN_F1R2_FB7_Pos (7U)
4010#define CAN_F1R2_FB7_Msk (0x1U << CAN_F1R2_FB7_Pos) /*!< 0x00000080 */
4011#define CAN_F1R2_FB7 CAN_F1R2_FB7_Msk /*!<Filter bit 7 */
4012#define CAN_F1R2_FB8_Pos (8U)
4013#define CAN_F1R2_FB8_Msk (0x1U << CAN_F1R2_FB8_Pos) /*!< 0x00000100 */
4014#define CAN_F1R2_FB8 CAN_F1R2_FB8_Msk /*!<Filter bit 8 */
4015#define CAN_F1R2_FB9_Pos (9U)
4016#define CAN_F1R2_FB9_Msk (0x1U << CAN_F1R2_FB9_Pos) /*!< 0x00000200 */
4017#define CAN_F1R2_FB9 CAN_F1R2_FB9_Msk /*!<Filter bit 9 */
4018#define CAN_F1R2_FB10_Pos (10U)
4019#define CAN_F1R2_FB10_Msk (0x1U << CAN_F1R2_FB10_Pos) /*!< 0x00000400 */
4020#define CAN_F1R2_FB10 CAN_F1R2_FB10_Msk /*!<Filter bit 10 */
4021#define CAN_F1R2_FB11_Pos (11U)
4022#define CAN_F1R2_FB11_Msk (0x1U << CAN_F1R2_FB11_Pos) /*!< 0x00000800 */
4023#define CAN_F1R2_FB11 CAN_F1R2_FB11_Msk /*!<Filter bit 11 */
4024#define CAN_F1R2_FB12_Pos (12U)
4025#define CAN_F1R2_FB12_Msk (0x1U << CAN_F1R2_FB12_Pos) /*!< 0x00001000 */
4026#define CAN_F1R2_FB12 CAN_F1R2_FB12_Msk /*!<Filter bit 12 */
4027#define CAN_F1R2_FB13_Pos (13U)
4028#define CAN_F1R2_FB13_Msk (0x1U << CAN_F1R2_FB13_Pos) /*!< 0x00002000 */
4029#define CAN_F1R2_FB13 CAN_F1R2_FB13_Msk /*!<Filter bit 13 */
4030#define CAN_F1R2_FB14_Pos (14U)
4031#define CAN_F1R2_FB14_Msk (0x1U << CAN_F1R2_FB14_Pos) /*!< 0x00004000 */
4032#define CAN_F1R2_FB14 CAN_F1R2_FB14_Msk /*!<Filter bit 14 */
4033#define CAN_F1R2_FB15_Pos (15U)
4034#define CAN_F1R2_FB15_Msk (0x1U << CAN_F1R2_FB15_Pos) /*!< 0x00008000 */
4035#define CAN_F1R2_FB15 CAN_F1R2_FB15_Msk /*!<Filter bit 15 */
4036#define CAN_F1R2_FB16_Pos (16U)
4037#define CAN_F1R2_FB16_Msk (0x1U << CAN_F1R2_FB16_Pos) /*!< 0x00010000 */
4038#define CAN_F1R2_FB16 CAN_F1R2_FB16_Msk /*!<Filter bit 16 */
4039#define CAN_F1R2_FB17_Pos (17U)
4040#define CAN_F1R2_FB17_Msk (0x1U << CAN_F1R2_FB17_Pos) /*!< 0x00020000 */
4041#define CAN_F1R2_FB17 CAN_F1R2_FB17_Msk /*!<Filter bit 17 */
4042#define CAN_F1R2_FB18_Pos (18U)
4043#define CAN_F1R2_FB18_Msk (0x1U << CAN_F1R2_FB18_Pos) /*!< 0x00040000 */
4044#define CAN_F1R2_FB18 CAN_F1R2_FB18_Msk /*!<Filter bit 18 */
4045#define CAN_F1R2_FB19_Pos (19U)
4046#define CAN_F1R2_FB19_Msk (0x1U << CAN_F1R2_FB19_Pos) /*!< 0x00080000 */
4047#define CAN_F1R2_FB19 CAN_F1R2_FB19_Msk /*!<Filter bit 19 */
4048#define CAN_F1R2_FB20_Pos (20U)
4049#define CAN_F1R2_FB20_Msk (0x1U << CAN_F1R2_FB20_Pos) /*!< 0x00100000 */
4050#define CAN_F1R2_FB20 CAN_F1R2_FB20_Msk /*!<Filter bit 20 */
4051#define CAN_F1R2_FB21_Pos (21U)
4052#define CAN_F1R2_FB21_Msk (0x1U << CAN_F1R2_FB21_Pos) /*!< 0x00200000 */
4053#define CAN_F1R2_FB21 CAN_F1R2_FB21_Msk /*!<Filter bit 21 */
4054#define CAN_F1R2_FB22_Pos (22U)
4055#define CAN_F1R2_FB22_Msk (0x1U << CAN_F1R2_FB22_Pos) /*!< 0x00400000 */
4056#define CAN_F1R2_FB22 CAN_F1R2_FB22_Msk /*!<Filter bit 22 */
4057#define CAN_F1R2_FB23_Pos (23U)
4058#define CAN_F1R2_FB23_Msk (0x1U << CAN_F1R2_FB23_Pos) /*!< 0x00800000 */
4059#define CAN_F1R2_FB23 CAN_F1R2_FB23_Msk /*!<Filter bit 23 */
4060#define CAN_F1R2_FB24_Pos (24U)
4061#define CAN_F1R2_FB24_Msk (0x1U << CAN_F1R2_FB24_Pos) /*!< 0x01000000 */
4062#define CAN_F1R2_FB24 CAN_F1R2_FB24_Msk /*!<Filter bit 24 */
4063#define CAN_F1R2_FB25_Pos (25U)
4064#define CAN_F1R2_FB25_Msk (0x1U << CAN_F1R2_FB25_Pos) /*!< 0x02000000 */
4065#define CAN_F1R2_FB25 CAN_F1R2_FB25_Msk /*!<Filter bit 25 */
4066#define CAN_F1R2_FB26_Pos (26U)
4067#define CAN_F1R2_FB26_Msk (0x1U << CAN_F1R2_FB26_Pos) /*!< 0x04000000 */
4068#define CAN_F1R2_FB26 CAN_F1R2_FB26_Msk /*!<Filter bit 26 */
4069#define CAN_F1R2_FB27_Pos (27U)
4070#define CAN_F1R2_FB27_Msk (0x1U << CAN_F1R2_FB27_Pos) /*!< 0x08000000 */
4071#define CAN_F1R2_FB27 CAN_F1R2_FB27_Msk /*!<Filter bit 27 */
4072#define CAN_F1R2_FB28_Pos (28U)
4073#define CAN_F1R2_FB28_Msk (0x1U << CAN_F1R2_FB28_Pos) /*!< 0x10000000 */
4074#define CAN_F1R2_FB28 CAN_F1R2_FB28_Msk /*!<Filter bit 28 */
4075#define CAN_F1R2_FB29_Pos (29U)
4076#define CAN_F1R2_FB29_Msk (0x1U << CAN_F1R2_FB29_Pos) /*!< 0x20000000 */
4077#define CAN_F1R2_FB29 CAN_F1R2_FB29_Msk /*!<Filter bit 29 */
4078#define CAN_F1R2_FB30_Pos (30U)
4079#define CAN_F1R2_FB30_Msk (0x1U << CAN_F1R2_FB30_Pos) /*!< 0x40000000 */
4080#define CAN_F1R2_FB30 CAN_F1R2_FB30_Msk /*!<Filter bit 30 */
4081#define CAN_F1R2_FB31_Pos (31U)
4082#define CAN_F1R2_FB31_Msk (0x1U << CAN_F1R2_FB31_Pos) /*!< 0x80000000 */
4083#define CAN_F1R2_FB31 CAN_F1R2_FB31_Msk /*!<Filter bit 31 */
4084
4085/******************* Bit definition for CAN_F2R2 register *******************/
4086#define CAN_F2R2_FB0_Pos (0U)
4087#define CAN_F2R2_FB0_Msk (0x1U << CAN_F2R2_FB0_Pos) /*!< 0x00000001 */
4088#define CAN_F2R2_FB0 CAN_F2R2_FB0_Msk /*!<Filter bit 0 */
4089#define CAN_F2R2_FB1_Pos (1U)
4090#define CAN_F2R2_FB1_Msk (0x1U << CAN_F2R2_FB1_Pos) /*!< 0x00000002 */
4091#define CAN_F2R2_FB1 CAN_F2R2_FB1_Msk /*!<Filter bit 1 */
4092#define CAN_F2R2_FB2_Pos (2U)
4093#define CAN_F2R2_FB2_Msk (0x1U << CAN_F2R2_FB2_Pos) /*!< 0x00000004 */
4094#define CAN_F2R2_FB2 CAN_F2R2_FB2_Msk /*!<Filter bit 2 */
4095#define CAN_F2R2_FB3_Pos (3U)
4096#define CAN_F2R2_FB3_Msk (0x1U << CAN_F2R2_FB3_Pos) /*!< 0x00000008 */
4097#define CAN_F2R2_FB3 CAN_F2R2_FB3_Msk /*!<Filter bit 3 */
4098#define CAN_F2R2_FB4_Pos (4U)
4099#define CAN_F2R2_FB4_Msk (0x1U << CAN_F2R2_FB4_Pos) /*!< 0x00000010 */
4100#define CAN_F2R2_FB4 CAN_F2R2_FB4_Msk /*!<Filter bit 4 */
4101#define CAN_F2R2_FB5_Pos (5U)
4102#define CAN_F2R2_FB5_Msk (0x1U << CAN_F2R2_FB5_Pos) /*!< 0x00000020 */
4103#define CAN_F2R2_FB5 CAN_F2R2_FB5_Msk /*!<Filter bit 5 */
4104#define CAN_F2R2_FB6_Pos (6U)
4105#define CAN_F2R2_FB6_Msk (0x1U << CAN_F2R2_FB6_Pos) /*!< 0x00000040 */
4106#define CAN_F2R2_FB6 CAN_F2R2_FB6_Msk /*!<Filter bit 6 */
4107#define CAN_F2R2_FB7_Pos (7U)
4108#define CAN_F2R2_FB7_Msk (0x1U << CAN_F2R2_FB7_Pos) /*!< 0x00000080 */
4109#define CAN_F2R2_FB7 CAN_F2R2_FB7_Msk /*!<Filter bit 7 */
4110#define CAN_F2R2_FB8_Pos (8U)
4111#define CAN_F2R2_FB8_Msk (0x1U << CAN_F2R2_FB8_Pos) /*!< 0x00000100 */
4112#define CAN_F2R2_FB8 CAN_F2R2_FB8_Msk /*!<Filter bit 8 */
4113#define CAN_F2R2_FB9_Pos (9U)
4114#define CAN_F2R2_FB9_Msk (0x1U << CAN_F2R2_FB9_Pos) /*!< 0x00000200 */
4115#define CAN_F2R2_FB9 CAN_F2R2_FB9_Msk /*!<Filter bit 9 */
4116#define CAN_F2R2_FB10_Pos (10U)
4117#define CAN_F2R2_FB10_Msk (0x1U << CAN_F2R2_FB10_Pos) /*!< 0x00000400 */
4118#define CAN_F2R2_FB10 CAN_F2R2_FB10_Msk /*!<Filter bit 10 */
4119#define CAN_F2R2_FB11_Pos (11U)
4120#define CAN_F2R2_FB11_Msk (0x1U << CAN_F2R2_FB11_Pos) /*!< 0x00000800 */
4121#define CAN_F2R2_FB11 CAN_F2R2_FB11_Msk /*!<Filter bit 11 */
4122#define CAN_F2R2_FB12_Pos (12U)
4123#define CAN_F2R2_FB12_Msk (0x1U << CAN_F2R2_FB12_Pos) /*!< 0x00001000 */
4124#define CAN_F2R2_FB12 CAN_F2R2_FB12_Msk /*!<Filter bit 12 */
4125#define CAN_F2R2_FB13_Pos (13U)
4126#define CAN_F2R2_FB13_Msk (0x1U << CAN_F2R2_FB13_Pos) /*!< 0x00002000 */
4127#define CAN_F2R2_FB13 CAN_F2R2_FB13_Msk /*!<Filter bit 13 */
4128#define CAN_F2R2_FB14_Pos (14U)
4129#define CAN_F2R2_FB14_Msk (0x1U << CAN_F2R2_FB14_Pos) /*!< 0x00004000 */
4130#define CAN_F2R2_FB14 CAN_F2R2_FB14_Msk /*!<Filter bit 14 */
4131#define CAN_F2R2_FB15_Pos (15U)
4132#define CAN_F2R2_FB15_Msk (0x1U << CAN_F2R2_FB15_Pos) /*!< 0x00008000 */
4133#define CAN_F2R2_FB15 CAN_F2R2_FB15_Msk /*!<Filter bit 15 */
4134#define CAN_F2R2_FB16_Pos (16U)
4135#define CAN_F2R2_FB16_Msk (0x1U << CAN_F2R2_FB16_Pos) /*!< 0x00010000 */
4136#define CAN_F2R2_FB16 CAN_F2R2_FB16_Msk /*!<Filter bit 16 */
4137#define CAN_F2R2_FB17_Pos (17U)
4138#define CAN_F2R2_FB17_Msk (0x1U << CAN_F2R2_FB17_Pos) /*!< 0x00020000 */
4139#define CAN_F2R2_FB17 CAN_F2R2_FB17_Msk /*!<Filter bit 17 */
4140#define CAN_F2R2_FB18_Pos (18U)
4141#define CAN_F2R2_FB18_Msk (0x1U << CAN_F2R2_FB18_Pos) /*!< 0x00040000 */
4142#define CAN_F2R2_FB18 CAN_F2R2_FB18_Msk /*!<Filter bit 18 */
4143#define CAN_F2R2_FB19_Pos (19U)
4144#define CAN_F2R2_FB19_Msk (0x1U << CAN_F2R2_FB19_Pos) /*!< 0x00080000 */
4145#define CAN_F2R2_FB19 CAN_F2R2_FB19_Msk /*!<Filter bit 19 */
4146#define CAN_F2R2_FB20_Pos (20U)
4147#define CAN_F2R2_FB20_Msk (0x1U << CAN_F2R2_FB20_Pos) /*!< 0x00100000 */
4148#define CAN_F2R2_FB20 CAN_F2R2_FB20_Msk /*!<Filter bit 20 */
4149#define CAN_F2R2_FB21_Pos (21U)
4150#define CAN_F2R2_FB21_Msk (0x1U << CAN_F2R2_FB21_Pos) /*!< 0x00200000 */
4151#define CAN_F2R2_FB21 CAN_F2R2_FB21_Msk /*!<Filter bit 21 */
4152#define CAN_F2R2_FB22_Pos (22U)
4153#define CAN_F2R2_FB22_Msk (0x1U << CAN_F2R2_FB22_Pos) /*!< 0x00400000 */
4154#define CAN_F2R2_FB22 CAN_F2R2_FB22_Msk /*!<Filter bit 22 */
4155#define CAN_F2R2_FB23_Pos (23U)
4156#define CAN_F2R2_FB23_Msk (0x1U << CAN_F2R2_FB23_Pos) /*!< 0x00800000 */
4157#define CAN_F2R2_FB23 CAN_F2R2_FB23_Msk /*!<Filter bit 23 */
4158#define CAN_F2R2_FB24_Pos (24U)
4159#define CAN_F2R2_FB24_Msk (0x1U << CAN_F2R2_FB24_Pos) /*!< 0x01000000 */
4160#define CAN_F2R2_FB24 CAN_F2R2_FB24_Msk /*!<Filter bit 24 */
4161#define CAN_F2R2_FB25_Pos (25U)
4162#define CAN_F2R2_FB25_Msk (0x1U << CAN_F2R2_FB25_Pos) /*!< 0x02000000 */
4163#define CAN_F2R2_FB25 CAN_F2R2_FB25_Msk /*!<Filter bit 25 */
4164#define CAN_F2R2_FB26_Pos (26U)
4165#define CAN_F2R2_FB26_Msk (0x1U << CAN_F2R2_FB26_Pos) /*!< 0x04000000 */
4166#define CAN_F2R2_FB26 CAN_F2R2_FB26_Msk /*!<Filter bit 26 */
4167#define CAN_F2R2_FB27_Pos (27U)
4168#define CAN_F2R2_FB27_Msk (0x1U << CAN_F2R2_FB27_Pos) /*!< 0x08000000 */
4169#define CAN_F2R2_FB27 CAN_F2R2_FB27_Msk /*!<Filter bit 27 */
4170#define CAN_F2R2_FB28_Pos (28U)
4171#define CAN_F2R2_FB28_Msk (0x1U << CAN_F2R2_FB28_Pos) /*!< 0x10000000 */
4172#define CAN_F2R2_FB28 CAN_F2R2_FB28_Msk /*!<Filter bit 28 */
4173#define CAN_F2R2_FB29_Pos (29U)
4174#define CAN_F2R2_FB29_Msk (0x1U << CAN_F2R2_FB29_Pos) /*!< 0x20000000 */
4175#define CAN_F2R2_FB29 CAN_F2R2_FB29_Msk /*!<Filter bit 29 */
4176#define CAN_F2R2_FB30_Pos (30U)
4177#define CAN_F2R2_FB30_Msk (0x1U << CAN_F2R2_FB30_Pos) /*!< 0x40000000 */
4178#define CAN_F2R2_FB30 CAN_F2R2_FB30_Msk /*!<Filter bit 30 */
4179#define CAN_F2R2_FB31_Pos (31U)
4180#define CAN_F2R2_FB31_Msk (0x1U << CAN_F2R2_FB31_Pos) /*!< 0x80000000 */
4181#define CAN_F2R2_FB31 CAN_F2R2_FB31_Msk /*!<Filter bit 31 */
4182
4183/******************* Bit definition for CAN_F3R2 register *******************/
4184#define CAN_F3R2_FB0_Pos (0U)
4185#define CAN_F3R2_FB0_Msk (0x1U << CAN_F3R2_FB0_Pos) /*!< 0x00000001 */
4186#define CAN_F3R2_FB0 CAN_F3R2_FB0_Msk /*!<Filter bit 0 */
4187#define CAN_F3R2_FB1_Pos (1U)
4188#define CAN_F3R2_FB1_Msk (0x1U << CAN_F3R2_FB1_Pos) /*!< 0x00000002 */
4189#define CAN_F3R2_FB1 CAN_F3R2_FB1_Msk /*!<Filter bit 1 */
4190#define CAN_F3R2_FB2_Pos (2U)
4191#define CAN_F3R2_FB2_Msk (0x1U << CAN_F3R2_FB2_Pos) /*!< 0x00000004 */
4192#define CAN_F3R2_FB2 CAN_F3R2_FB2_Msk /*!<Filter bit 2 */
4193#define CAN_F3R2_FB3_Pos (3U)
4194#define CAN_F3R2_FB3_Msk (0x1U << CAN_F3R2_FB3_Pos) /*!< 0x00000008 */
4195#define CAN_F3R2_FB3 CAN_F3R2_FB3_Msk /*!<Filter bit 3 */
4196#define CAN_F3R2_FB4_Pos (4U)
4197#define CAN_F3R2_FB4_Msk (0x1U << CAN_F3R2_FB4_Pos) /*!< 0x00000010 */
4198#define CAN_F3R2_FB4 CAN_F3R2_FB4_Msk /*!<Filter bit 4 */
4199#define CAN_F3R2_FB5_Pos (5U)
4200#define CAN_F3R2_FB5_Msk (0x1U << CAN_F3R2_FB5_Pos) /*!< 0x00000020 */
4201#define CAN_F3R2_FB5 CAN_F3R2_FB5_Msk /*!<Filter bit 5 */
4202#define CAN_F3R2_FB6_Pos (6U)
4203#define CAN_F3R2_FB6_Msk (0x1U << CAN_F3R2_FB6_Pos) /*!< 0x00000040 */
4204#define CAN_F3R2_FB6 CAN_F3R2_FB6_Msk /*!<Filter bit 6 */
4205#define CAN_F3R2_FB7_Pos (7U)
4206#define CAN_F3R2_FB7_Msk (0x1U << CAN_F3R2_FB7_Pos) /*!< 0x00000080 */
4207#define CAN_F3R2_FB7 CAN_F3R2_FB7_Msk /*!<Filter bit 7 */
4208#define CAN_F3R2_FB8_Pos (8U)
4209#define CAN_F3R2_FB8_Msk (0x1U << CAN_F3R2_FB8_Pos) /*!< 0x00000100 */
4210#define CAN_F3R2_FB8 CAN_F3R2_FB8_Msk /*!<Filter bit 8 */
4211#define CAN_F3R2_FB9_Pos (9U)
4212#define CAN_F3R2_FB9_Msk (0x1U << CAN_F3R2_FB9_Pos) /*!< 0x00000200 */
4213#define CAN_F3R2_FB9 CAN_F3R2_FB9_Msk /*!<Filter bit 9 */
4214#define CAN_F3R2_FB10_Pos (10U)
4215#define CAN_F3R2_FB10_Msk (0x1U << CAN_F3R2_FB10_Pos) /*!< 0x00000400 */
4216#define CAN_F3R2_FB10 CAN_F3R2_FB10_Msk /*!<Filter bit 10 */
4217#define CAN_F3R2_FB11_Pos (11U)
4218#define CAN_F3R2_FB11_Msk (0x1U << CAN_F3R2_FB11_Pos) /*!< 0x00000800 */
4219#define CAN_F3R2_FB11 CAN_F3R2_FB11_Msk /*!<Filter bit 11 */
4220#define CAN_F3R2_FB12_Pos (12U)
4221#define CAN_F3R2_FB12_Msk (0x1U << CAN_F3R2_FB12_Pos) /*!< 0x00001000 */
4222#define CAN_F3R2_FB12 CAN_F3R2_FB12_Msk /*!<Filter bit 12 */
4223#define CAN_F3R2_FB13_Pos (13U)
4224#define CAN_F3R2_FB13_Msk (0x1U << CAN_F3R2_FB13_Pos) /*!< 0x00002000 */
4225#define CAN_F3R2_FB13 CAN_F3R2_FB13_Msk /*!<Filter bit 13 */
4226#define CAN_F3R2_FB14_Pos (14U)
4227#define CAN_F3R2_FB14_Msk (0x1U << CAN_F3R2_FB14_Pos) /*!< 0x00004000 */
4228#define CAN_F3R2_FB14 CAN_F3R2_FB14_Msk /*!<Filter bit 14 */
4229#define CAN_F3R2_FB15_Pos (15U)
4230#define CAN_F3R2_FB15_Msk (0x1U << CAN_F3R2_FB15_Pos) /*!< 0x00008000 */
4231#define CAN_F3R2_FB15 CAN_F3R2_FB15_Msk /*!<Filter bit 15 */
4232#define CAN_F3R2_FB16_Pos (16U)
4233#define CAN_F3R2_FB16_Msk (0x1U << CAN_F3R2_FB16_Pos) /*!< 0x00010000 */
4234#define CAN_F3R2_FB16 CAN_F3R2_FB16_Msk /*!<Filter bit 16 */
4235#define CAN_F3R2_FB17_Pos (17U)
4236#define CAN_F3R2_FB17_Msk (0x1U << CAN_F3R2_FB17_Pos) /*!< 0x00020000 */
4237#define CAN_F3R2_FB17 CAN_F3R2_FB17_Msk /*!<Filter bit 17 */
4238#define CAN_F3R2_FB18_Pos (18U)
4239#define CAN_F3R2_FB18_Msk (0x1U << CAN_F3R2_FB18_Pos) /*!< 0x00040000 */
4240#define CAN_F3R2_FB18 CAN_F3R2_FB18_Msk /*!<Filter bit 18 */
4241#define CAN_F3R2_FB19_Pos (19U)
4242#define CAN_F3R2_FB19_Msk (0x1U << CAN_F3R2_FB19_Pos) /*!< 0x00080000 */
4243#define CAN_F3R2_FB19 CAN_F3R2_FB19_Msk /*!<Filter bit 19 */
4244#define CAN_F3R2_FB20_Pos (20U)
4245#define CAN_F3R2_FB20_Msk (0x1U << CAN_F3R2_FB20_Pos) /*!< 0x00100000 */
4246#define CAN_F3R2_FB20 CAN_F3R2_FB20_Msk /*!<Filter bit 20 */
4247#define CAN_F3R2_FB21_Pos (21U)
4248#define CAN_F3R2_FB21_Msk (0x1U << CAN_F3R2_FB21_Pos) /*!< 0x00200000 */
4249#define CAN_F3R2_FB21 CAN_F3R2_FB21_Msk /*!<Filter bit 21 */
4250#define CAN_F3R2_FB22_Pos (22U)
4251#define CAN_F3R2_FB22_Msk (0x1U << CAN_F3R2_FB22_Pos) /*!< 0x00400000 */
4252#define CAN_F3R2_FB22 CAN_F3R2_FB22_Msk /*!<Filter bit 22 */
4253#define CAN_F3R2_FB23_Pos (23U)
4254#define CAN_F3R2_FB23_Msk (0x1U << CAN_F3R2_FB23_Pos) /*!< 0x00800000 */
4255#define CAN_F3R2_FB23 CAN_F3R2_FB23_Msk /*!<Filter bit 23 */
4256#define CAN_F3R2_FB24_Pos (24U)
4257#define CAN_F3R2_FB24_Msk (0x1U << CAN_F3R2_FB24_Pos) /*!< 0x01000000 */
4258#define CAN_F3R2_FB24 CAN_F3R2_FB24_Msk /*!<Filter bit 24 */
4259#define CAN_F3R2_FB25_Pos (25U)
4260#define CAN_F3R2_FB25_Msk (0x1U << CAN_F3R2_FB25_Pos) /*!< 0x02000000 */
4261#define CAN_F3R2_FB25 CAN_F3R2_FB25_Msk /*!<Filter bit 25 */
4262#define CAN_F3R2_FB26_Pos (26U)
4263#define CAN_F3R2_FB26_Msk (0x1U << CAN_F3R2_FB26_Pos) /*!< 0x04000000 */
4264#define CAN_F3R2_FB26 CAN_F3R2_FB26_Msk /*!<Filter bit 26 */
4265#define CAN_F3R2_FB27_Pos (27U)
4266#define CAN_F3R2_FB27_Msk (0x1U << CAN_F3R2_FB27_Pos) /*!< 0x08000000 */
4267#define CAN_F3R2_FB27 CAN_F3R2_FB27_Msk /*!<Filter bit 27 */
4268#define CAN_F3R2_FB28_Pos (28U)
4269#define CAN_F3R2_FB28_Msk (0x1U << CAN_F3R2_FB28_Pos) /*!< 0x10000000 */
4270#define CAN_F3R2_FB28 CAN_F3R2_FB28_Msk /*!<Filter bit 28 */
4271#define CAN_F3R2_FB29_Pos (29U)
4272#define CAN_F3R2_FB29_Msk (0x1U << CAN_F3R2_FB29_Pos) /*!< 0x20000000 */
4273#define CAN_F3R2_FB29 CAN_F3R2_FB29_Msk /*!<Filter bit 29 */
4274#define CAN_F3R2_FB30_Pos (30U)
4275#define CAN_F3R2_FB30_Msk (0x1U << CAN_F3R2_FB30_Pos) /*!< 0x40000000 */
4276#define CAN_F3R2_FB30 CAN_F3R2_FB30_Msk /*!<Filter bit 30 */
4277#define CAN_F3R2_FB31_Pos (31U)
4278#define CAN_F3R2_FB31_Msk (0x1U << CAN_F3R2_FB31_Pos) /*!< 0x80000000 */
4279#define CAN_F3R2_FB31 CAN_F3R2_FB31_Msk /*!<Filter bit 31 */
4280
4281/******************* Bit definition for CAN_F4R2 register *******************/
4282#define CAN_F4R2_FB0_Pos (0U)
4283#define CAN_F4R2_FB0_Msk (0x1U << CAN_F4R2_FB0_Pos) /*!< 0x00000001 */
4284#define CAN_F4R2_FB0 CAN_F4R2_FB0_Msk /*!<Filter bit 0 */
4285#define CAN_F4R2_FB1_Pos (1U)
4286#define CAN_F4R2_FB1_Msk (0x1U << CAN_F4R2_FB1_Pos) /*!< 0x00000002 */
4287#define CAN_F4R2_FB1 CAN_F4R2_FB1_Msk /*!<Filter bit 1 */
4288#define CAN_F4R2_FB2_Pos (2U)
4289#define CAN_F4R2_FB2_Msk (0x1U << CAN_F4R2_FB2_Pos) /*!< 0x00000004 */
4290#define CAN_F4R2_FB2 CAN_F4R2_FB2_Msk /*!<Filter bit 2 */
4291#define CAN_F4R2_FB3_Pos (3U)
4292#define CAN_F4R2_FB3_Msk (0x1U << CAN_F4R2_FB3_Pos) /*!< 0x00000008 */
4293#define CAN_F4R2_FB3 CAN_F4R2_FB3_Msk /*!<Filter bit 3 */
4294#define CAN_F4R2_FB4_Pos (4U)
4295#define CAN_F4R2_FB4_Msk (0x1U << CAN_F4R2_FB4_Pos) /*!< 0x00000010 */
4296#define CAN_F4R2_FB4 CAN_F4R2_FB4_Msk /*!<Filter bit 4 */
4297#define CAN_F4R2_FB5_Pos (5U)
4298#define CAN_F4R2_FB5_Msk (0x1U << CAN_F4R2_FB5_Pos) /*!< 0x00000020 */
4299#define CAN_F4R2_FB5 CAN_F4R2_FB5_Msk /*!<Filter bit 5 */
4300#define CAN_F4R2_FB6_Pos (6U)
4301#define CAN_F4R2_FB6_Msk (0x1U << CAN_F4R2_FB6_Pos) /*!< 0x00000040 */
4302#define CAN_F4R2_FB6 CAN_F4R2_FB6_Msk /*!<Filter bit 6 */
4303#define CAN_F4R2_FB7_Pos (7U)
4304#define CAN_F4R2_FB7_Msk (0x1U << CAN_F4R2_FB7_Pos) /*!< 0x00000080 */
4305#define CAN_F4R2_FB7 CAN_F4R2_FB7_Msk /*!<Filter bit 7 */
4306#define CAN_F4R2_FB8_Pos (8U)
4307#define CAN_F4R2_FB8_Msk (0x1U << CAN_F4R2_FB8_Pos) /*!< 0x00000100 */
4308#define CAN_F4R2_FB8 CAN_F4R2_FB8_Msk /*!<Filter bit 8 */
4309#define CAN_F4R2_FB9_Pos (9U)
4310#define CAN_F4R2_FB9_Msk (0x1U << CAN_F4R2_FB9_Pos) /*!< 0x00000200 */
4311#define CAN_F4R2_FB9 CAN_F4R2_FB9_Msk /*!<Filter bit 9 */
4312#define CAN_F4R2_FB10_Pos (10U)
4313#define CAN_F4R2_FB10_Msk (0x1U << CAN_F4R2_FB10_Pos) /*!< 0x00000400 */
4314#define CAN_F4R2_FB10 CAN_F4R2_FB10_Msk /*!<Filter bit 10 */
4315#define CAN_F4R2_FB11_Pos (11U)
4316#define CAN_F4R2_FB11_Msk (0x1U << CAN_F4R2_FB11_Pos) /*!< 0x00000800 */
4317#define CAN_F4R2_FB11 CAN_F4R2_FB11_Msk /*!<Filter bit 11 */
4318#define CAN_F4R2_FB12_Pos (12U)
4319#define CAN_F4R2_FB12_Msk (0x1U << CAN_F4R2_FB12_Pos) /*!< 0x00001000 */
4320#define CAN_F4R2_FB12 CAN_F4R2_FB12_Msk /*!<Filter bit 12 */
4321#define CAN_F4R2_FB13_Pos (13U)
4322#define CAN_F4R2_FB13_Msk (0x1U << CAN_F4R2_FB13_Pos) /*!< 0x00002000 */
4323#define CAN_F4R2_FB13 CAN_F4R2_FB13_Msk /*!<Filter bit 13 */
4324#define CAN_F4R2_FB14_Pos (14U)
4325#define CAN_F4R2_FB14_Msk (0x1U << CAN_F4R2_FB14_Pos) /*!< 0x00004000 */
4326#define CAN_F4R2_FB14 CAN_F4R2_FB14_Msk /*!<Filter bit 14 */
4327#define CAN_F4R2_FB15_Pos (15U)
4328#define CAN_F4R2_FB15_Msk (0x1U << CAN_F4R2_FB15_Pos) /*!< 0x00008000 */
4329#define CAN_F4R2_FB15 CAN_F4R2_FB15_Msk /*!<Filter bit 15 */
4330#define CAN_F4R2_FB16_Pos (16U)
4331#define CAN_F4R2_FB16_Msk (0x1U << CAN_F4R2_FB16_Pos) /*!< 0x00010000 */
4332#define CAN_F4R2_FB16 CAN_F4R2_FB16_Msk /*!<Filter bit 16 */
4333#define CAN_F4R2_FB17_Pos (17U)
4334#define CAN_F4R2_FB17_Msk (0x1U << CAN_F4R2_FB17_Pos) /*!< 0x00020000 */
4335#define CAN_F4R2_FB17 CAN_F4R2_FB17_Msk /*!<Filter bit 17 */
4336#define CAN_F4R2_FB18_Pos (18U)
4337#define CAN_F4R2_FB18_Msk (0x1U << CAN_F4R2_FB18_Pos) /*!< 0x00040000 */
4338#define CAN_F4R2_FB18 CAN_F4R2_FB18_Msk /*!<Filter bit 18 */
4339#define CAN_F4R2_FB19_Pos (19U)
4340#define CAN_F4R2_FB19_Msk (0x1U << CAN_F4R2_FB19_Pos) /*!< 0x00080000 */
4341#define CAN_F4R2_FB19 CAN_F4R2_FB19_Msk /*!<Filter bit 19 */
4342#define CAN_F4R2_FB20_Pos (20U)
4343#define CAN_F4R2_FB20_Msk (0x1U << CAN_F4R2_FB20_Pos) /*!< 0x00100000 */
4344#define CAN_F4R2_FB20 CAN_F4R2_FB20_Msk /*!<Filter bit 20 */
4345#define CAN_F4R2_FB21_Pos (21U)
4346#define CAN_F4R2_FB21_Msk (0x1U << CAN_F4R2_FB21_Pos) /*!< 0x00200000 */
4347#define CAN_F4R2_FB21 CAN_F4R2_FB21_Msk /*!<Filter bit 21 */
4348#define CAN_F4R2_FB22_Pos (22U)
4349#define CAN_F4R2_FB22_Msk (0x1U << CAN_F4R2_FB22_Pos) /*!< 0x00400000 */
4350#define CAN_F4R2_FB22 CAN_F4R2_FB22_Msk /*!<Filter bit 22 */
4351#define CAN_F4R2_FB23_Pos (23U)
4352#define CAN_F4R2_FB23_Msk (0x1U << CAN_F4R2_FB23_Pos) /*!< 0x00800000 */
4353#define CAN_F4R2_FB23 CAN_F4R2_FB23_Msk /*!<Filter bit 23 */
4354#define CAN_F4R2_FB24_Pos (24U)
4355#define CAN_F4R2_FB24_Msk (0x1U << CAN_F4R2_FB24_Pos) /*!< 0x01000000 */
4356#define CAN_F4R2_FB24 CAN_F4R2_FB24_Msk /*!<Filter bit 24 */
4357#define CAN_F4R2_FB25_Pos (25U)
4358#define CAN_F4R2_FB25_Msk (0x1U << CAN_F4R2_FB25_Pos) /*!< 0x02000000 */
4359#define CAN_F4R2_FB25 CAN_F4R2_FB25_Msk /*!<Filter bit 25 */
4360#define CAN_F4R2_FB26_Pos (26U)
4361#define CAN_F4R2_FB26_Msk (0x1U << CAN_F4R2_FB26_Pos) /*!< 0x04000000 */
4362#define CAN_F4R2_FB26 CAN_F4R2_FB26_Msk /*!<Filter bit 26 */
4363#define CAN_F4R2_FB27_Pos (27U)
4364#define CAN_F4R2_FB27_Msk (0x1U << CAN_F4R2_FB27_Pos) /*!< 0x08000000 */
4365#define CAN_F4R2_FB27 CAN_F4R2_FB27_Msk /*!<Filter bit 27 */
4366#define CAN_F4R2_FB28_Pos (28U)
4367#define CAN_F4R2_FB28_Msk (0x1U << CAN_F4R2_FB28_Pos) /*!< 0x10000000 */
4368#define CAN_F4R2_FB28 CAN_F4R2_FB28_Msk /*!<Filter bit 28 */
4369#define CAN_F4R2_FB29_Pos (29U)
4370#define CAN_F4R2_FB29_Msk (0x1U << CAN_F4R2_FB29_Pos) /*!< 0x20000000 */
4371#define CAN_F4R2_FB29 CAN_F4R2_FB29_Msk /*!<Filter bit 29 */
4372#define CAN_F4R2_FB30_Pos (30U)
4373#define CAN_F4R2_FB30_Msk (0x1U << CAN_F4R2_FB30_Pos) /*!< 0x40000000 */
4374#define CAN_F4R2_FB30 CAN_F4R2_FB30_Msk /*!<Filter bit 30 */
4375#define CAN_F4R2_FB31_Pos (31U)
4376#define CAN_F4R2_FB31_Msk (0x1U << CAN_F4R2_FB31_Pos) /*!< 0x80000000 */
4377#define CAN_F4R2_FB31 CAN_F4R2_FB31_Msk /*!<Filter bit 31 */
4378
4379/******************* Bit definition for CAN_F5R2 register *******************/
4380#define CAN_F5R2_FB0_Pos (0U)
4381#define CAN_F5R2_FB0_Msk (0x1U << CAN_F5R2_FB0_Pos) /*!< 0x00000001 */
4382#define CAN_F5R2_FB0 CAN_F5R2_FB0_Msk /*!<Filter bit 0 */
4383#define CAN_F5R2_FB1_Pos (1U)
4384#define CAN_F5R2_FB1_Msk (0x1U << CAN_F5R2_FB1_Pos) /*!< 0x00000002 */
4385#define CAN_F5R2_FB1 CAN_F5R2_FB1_Msk /*!<Filter bit 1 */
4386#define CAN_F5R2_FB2_Pos (2U)
4387#define CAN_F5R2_FB2_Msk (0x1U << CAN_F5R2_FB2_Pos) /*!< 0x00000004 */
4388#define CAN_F5R2_FB2 CAN_F5R2_FB2_Msk /*!<Filter bit 2 */
4389#define CAN_F5R2_FB3_Pos (3U)
4390#define CAN_F5R2_FB3_Msk (0x1U << CAN_F5R2_FB3_Pos) /*!< 0x00000008 */
4391#define CAN_F5R2_FB3 CAN_F5R2_FB3_Msk /*!<Filter bit 3 */
4392#define CAN_F5R2_FB4_Pos (4U)
4393#define CAN_F5R2_FB4_Msk (0x1U << CAN_F5R2_FB4_Pos) /*!< 0x00000010 */
4394#define CAN_F5R2_FB4 CAN_F5R2_FB4_Msk /*!<Filter bit 4 */
4395#define CAN_F5R2_FB5_Pos (5U)
4396#define CAN_F5R2_FB5_Msk (0x1U << CAN_F5R2_FB5_Pos) /*!< 0x00000020 */
4397#define CAN_F5R2_FB5 CAN_F5R2_FB5_Msk /*!<Filter bit 5 */
4398#define CAN_F5R2_FB6_Pos (6U)
4399#define CAN_F5R2_FB6_Msk (0x1U << CAN_F5R2_FB6_Pos) /*!< 0x00000040 */
4400#define CAN_F5R2_FB6 CAN_F5R2_FB6_Msk /*!<Filter bit 6 */
4401#define CAN_F5R2_FB7_Pos (7U)
4402#define CAN_F5R2_FB7_Msk (0x1U << CAN_F5R2_FB7_Pos) /*!< 0x00000080 */
4403#define CAN_F5R2_FB7 CAN_F5R2_FB7_Msk /*!<Filter bit 7 */
4404#define CAN_F5R2_FB8_Pos (8U)
4405#define CAN_F5R2_FB8_Msk (0x1U << CAN_F5R2_FB8_Pos) /*!< 0x00000100 */
4406#define CAN_F5R2_FB8 CAN_F5R2_FB8_Msk /*!<Filter bit 8 */
4407#define CAN_F5R2_FB9_Pos (9U)
4408#define CAN_F5R2_FB9_Msk (0x1U << CAN_F5R2_FB9_Pos) /*!< 0x00000200 */
4409#define CAN_F5R2_FB9 CAN_F5R2_FB9_Msk /*!<Filter bit 9 */
4410#define CAN_F5R2_FB10_Pos (10U)
4411#define CAN_F5R2_FB10_Msk (0x1U << CAN_F5R2_FB10_Pos) /*!< 0x00000400 */
4412#define CAN_F5R2_FB10 CAN_F5R2_FB10_Msk /*!<Filter bit 10 */
4413#define CAN_F5R2_FB11_Pos (11U)
4414#define CAN_F5R2_FB11_Msk (0x1U << CAN_F5R2_FB11_Pos) /*!< 0x00000800 */
4415#define CAN_F5R2_FB11 CAN_F5R2_FB11_Msk /*!<Filter bit 11 */
4416#define CAN_F5R2_FB12_Pos (12U)
4417#define CAN_F5R2_FB12_Msk (0x1U << CAN_F5R2_FB12_Pos) /*!< 0x00001000 */
4418#define CAN_F5R2_FB12 CAN_F5R2_FB12_Msk /*!<Filter bit 12 */
4419#define CAN_F5R2_FB13_Pos (13U)
4420#define CAN_F5R2_FB13_Msk (0x1U << CAN_F5R2_FB13_Pos) /*!< 0x00002000 */
4421#define CAN_F5R2_FB13 CAN_F5R2_FB13_Msk /*!<Filter bit 13 */
4422#define CAN_F5R2_FB14_Pos (14U)
4423#define CAN_F5R2_FB14_Msk (0x1U << CAN_F5R2_FB14_Pos) /*!< 0x00004000 */
4424#define CAN_F5R2_FB14 CAN_F5R2_FB14_Msk /*!<Filter bit 14 */
4425#define CAN_F5R2_FB15_Pos (15U)
4426#define CAN_F5R2_FB15_Msk (0x1U << CAN_F5R2_FB15_Pos) /*!< 0x00008000 */
4427#define CAN_F5R2_FB15 CAN_F5R2_FB15_Msk /*!<Filter bit 15 */
4428#define CAN_F5R2_FB16_Pos (16U)
4429#define CAN_F5R2_FB16_Msk (0x1U << CAN_F5R2_FB16_Pos) /*!< 0x00010000 */
4430#define CAN_F5R2_FB16 CAN_F5R2_FB16_Msk /*!<Filter bit 16 */
4431#define CAN_F5R2_FB17_Pos (17U)
4432#define CAN_F5R2_FB17_Msk (0x1U << CAN_F5R2_FB17_Pos) /*!< 0x00020000 */
4433#define CAN_F5R2_FB17 CAN_F5R2_FB17_Msk /*!<Filter bit 17 */
4434#define CAN_F5R2_FB18_Pos (18U)
4435#define CAN_F5R2_FB18_Msk (0x1U << CAN_F5R2_FB18_Pos) /*!< 0x00040000 */
4436#define CAN_F5R2_FB18 CAN_F5R2_FB18_Msk /*!<Filter bit 18 */
4437#define CAN_F5R2_FB19_Pos (19U)
4438#define CAN_F5R2_FB19_Msk (0x1U << CAN_F5R2_FB19_Pos) /*!< 0x00080000 */
4439#define CAN_F5R2_FB19 CAN_F5R2_FB19_Msk /*!<Filter bit 19 */
4440#define CAN_F5R2_FB20_Pos (20U)
4441#define CAN_F5R2_FB20_Msk (0x1U << CAN_F5R2_FB20_Pos) /*!< 0x00100000 */
4442#define CAN_F5R2_FB20 CAN_F5R2_FB20_Msk /*!<Filter bit 20 */
4443#define CAN_F5R2_FB21_Pos (21U)
4444#define CAN_F5R2_FB21_Msk (0x1U << CAN_F5R2_FB21_Pos) /*!< 0x00200000 */
4445#define CAN_F5R2_FB21 CAN_F5R2_FB21_Msk /*!<Filter bit 21 */
4446#define CAN_F5R2_FB22_Pos (22U)
4447#define CAN_F5R2_FB22_Msk (0x1U << CAN_F5R2_FB22_Pos) /*!< 0x00400000 */
4448#define CAN_F5R2_FB22 CAN_F5R2_FB22_Msk /*!<Filter bit 22 */
4449#define CAN_F5R2_FB23_Pos (23U)
4450#define CAN_F5R2_FB23_Msk (0x1U << CAN_F5R2_FB23_Pos) /*!< 0x00800000 */
4451#define CAN_F5R2_FB23 CAN_F5R2_FB23_Msk /*!<Filter bit 23 */
4452#define CAN_F5R2_FB24_Pos (24U)
4453#define CAN_F5R2_FB24_Msk (0x1U << CAN_F5R2_FB24_Pos) /*!< 0x01000000 */
4454#define CAN_F5R2_FB24 CAN_F5R2_FB24_Msk /*!<Filter bit 24 */
4455#define CAN_F5R2_FB25_Pos (25U)
4456#define CAN_F5R2_FB25_Msk (0x1U << CAN_F5R2_FB25_Pos) /*!< 0x02000000 */
4457#define CAN_F5R2_FB25 CAN_F5R2_FB25_Msk /*!<Filter bit 25 */
4458#define CAN_F5R2_FB26_Pos (26U)
4459#define CAN_F5R2_FB26_Msk (0x1U << CAN_F5R2_FB26_Pos) /*!< 0x04000000 */
4460#define CAN_F5R2_FB26 CAN_F5R2_FB26_Msk /*!<Filter bit 26 */
4461#define CAN_F5R2_FB27_Pos (27U)
4462#define CAN_F5R2_FB27_Msk (0x1U << CAN_F5R2_FB27_Pos) /*!< 0x08000000 */
4463#define CAN_F5R2_FB27 CAN_F5R2_FB27_Msk /*!<Filter bit 27 */
4464#define CAN_F5R2_FB28_Pos (28U)
4465#define CAN_F5R2_FB28_Msk (0x1U << CAN_F5R2_FB28_Pos) /*!< 0x10000000 */
4466#define CAN_F5R2_FB28 CAN_F5R2_FB28_Msk /*!<Filter bit 28 */
4467#define CAN_F5R2_FB29_Pos (29U)
4468#define CAN_F5R2_FB29_Msk (0x1U << CAN_F5R2_FB29_Pos) /*!< 0x20000000 */
4469#define CAN_F5R2_FB29 CAN_F5R2_FB29_Msk /*!<Filter bit 29 */
4470#define CAN_F5R2_FB30_Pos (30U)
4471#define CAN_F5R2_FB30_Msk (0x1U << CAN_F5R2_FB30_Pos) /*!< 0x40000000 */
4472#define CAN_F5R2_FB30 CAN_F5R2_FB30_Msk /*!<Filter bit 30 */
4473#define CAN_F5R2_FB31_Pos (31U)
4474#define CAN_F5R2_FB31_Msk (0x1U << CAN_F5R2_FB31_Pos) /*!< 0x80000000 */
4475#define CAN_F5R2_FB31 CAN_F5R2_FB31_Msk /*!<Filter bit 31 */
4476
4477/******************* Bit definition for CAN_F6R2 register *******************/
4478#define CAN_F6R2_FB0_Pos (0U)
4479#define CAN_F6R2_FB0_Msk (0x1U << CAN_F6R2_FB0_Pos) /*!< 0x00000001 */
4480#define CAN_F6R2_FB0 CAN_F6R2_FB0_Msk /*!<Filter bit 0 */
4481#define CAN_F6R2_FB1_Pos (1U)
4482#define CAN_F6R2_FB1_Msk (0x1U << CAN_F6R2_FB1_Pos) /*!< 0x00000002 */
4483#define CAN_F6R2_FB1 CAN_F6R2_FB1_Msk /*!<Filter bit 1 */
4484#define CAN_F6R2_FB2_Pos (2U)
4485#define CAN_F6R2_FB2_Msk (0x1U << CAN_F6R2_FB2_Pos) /*!< 0x00000004 */
4486#define CAN_F6R2_FB2 CAN_F6R2_FB2_Msk /*!<Filter bit 2 */
4487#define CAN_F6R2_FB3_Pos (3U)
4488#define CAN_F6R2_FB3_Msk (0x1U << CAN_F6R2_FB3_Pos) /*!< 0x00000008 */
4489#define CAN_F6R2_FB3 CAN_F6R2_FB3_Msk /*!<Filter bit 3 */
4490#define CAN_F6R2_FB4_Pos (4U)
4491#define CAN_F6R2_FB4_Msk (0x1U << CAN_F6R2_FB4_Pos) /*!< 0x00000010 */
4492#define CAN_F6R2_FB4 CAN_F6R2_FB4_Msk /*!<Filter bit 4 */
4493#define CAN_F6R2_FB5_Pos (5U)
4494#define CAN_F6R2_FB5_Msk (0x1U << CAN_F6R2_FB5_Pos) /*!< 0x00000020 */
4495#define CAN_F6R2_FB5 CAN_F6R2_FB5_Msk /*!<Filter bit 5 */
4496#define CAN_F6R2_FB6_Pos (6U)
4497#define CAN_F6R2_FB6_Msk (0x1U << CAN_F6R2_FB6_Pos) /*!< 0x00000040 */
4498#define CAN_F6R2_FB6 CAN_F6R2_FB6_Msk /*!<Filter bit 6 */
4499#define CAN_F6R2_FB7_Pos (7U)
4500#define CAN_F6R2_FB7_Msk (0x1U << CAN_F6R2_FB7_Pos) /*!< 0x00000080 */
4501#define CAN_F6R2_FB7 CAN_F6R2_FB7_Msk /*!<Filter bit 7 */
4502#define CAN_F6R2_FB8_Pos (8U)
4503#define CAN_F6R2_FB8_Msk (0x1U << CAN_F6R2_FB8_Pos) /*!< 0x00000100 */
4504#define CAN_F6R2_FB8 CAN_F6R2_FB8_Msk /*!<Filter bit 8 */
4505#define CAN_F6R2_FB9_Pos (9U)
4506#define CAN_F6R2_FB9_Msk (0x1U << CAN_F6R2_FB9_Pos) /*!< 0x00000200 */
4507#define CAN_F6R2_FB9 CAN_F6R2_FB9_Msk /*!<Filter bit 9 */
4508#define CAN_F6R2_FB10_Pos (10U)
4509#define CAN_F6R2_FB10_Msk (0x1U << CAN_F6R2_FB10_Pos) /*!< 0x00000400 */
4510#define CAN_F6R2_FB10 CAN_F6R2_FB10_Msk /*!<Filter bit 10 */
4511#define CAN_F6R2_FB11_Pos (11U)
4512#define CAN_F6R2_FB11_Msk (0x1U << CAN_F6R2_FB11_Pos) /*!< 0x00000800 */
4513#define CAN_F6R2_FB11 CAN_F6R2_FB11_Msk /*!<Filter bit 11 */
4514#define CAN_F6R2_FB12_Pos (12U)
4515#define CAN_F6R2_FB12_Msk (0x1U << CAN_F6R2_FB12_Pos) /*!< 0x00001000 */
4516#define CAN_F6R2_FB12 CAN_F6R2_FB12_Msk /*!<Filter bit 12 */
4517#define CAN_F6R2_FB13_Pos (13U)
4518#define CAN_F6R2_FB13_Msk (0x1U << CAN_F6R2_FB13_Pos) /*!< 0x00002000 */
4519#define CAN_F6R2_FB13 CAN_F6R2_FB13_Msk /*!<Filter bit 13 */
4520#define CAN_F6R2_FB14_Pos (14U)
4521#define CAN_F6R2_FB14_Msk (0x1U << CAN_F6R2_FB14_Pos) /*!< 0x00004000 */
4522#define CAN_F6R2_FB14 CAN_F6R2_FB14_Msk /*!<Filter bit 14 */
4523#define CAN_F6R2_FB15_Pos (15U)
4524#define CAN_F6R2_FB15_Msk (0x1U << CAN_F6R2_FB15_Pos) /*!< 0x00008000 */
4525#define CAN_F6R2_FB15 CAN_F6R2_FB15_Msk /*!<Filter bit 15 */
4526#define CAN_F6R2_FB16_Pos (16U)
4527#define CAN_F6R2_FB16_Msk (0x1U << CAN_F6R2_FB16_Pos) /*!< 0x00010000 */
4528#define CAN_F6R2_FB16 CAN_F6R2_FB16_Msk /*!<Filter bit 16 */
4529#define CAN_F6R2_FB17_Pos (17U)
4530#define CAN_F6R2_FB17_Msk (0x1U << CAN_F6R2_FB17_Pos) /*!< 0x00020000 */
4531#define CAN_F6R2_FB17 CAN_F6R2_FB17_Msk /*!<Filter bit 17 */
4532#define CAN_F6R2_FB18_Pos (18U)
4533#define CAN_F6R2_FB18_Msk (0x1U << CAN_F6R2_FB18_Pos) /*!< 0x00040000 */
4534#define CAN_F6R2_FB18 CAN_F6R2_FB18_Msk /*!<Filter bit 18 */
4535#define CAN_F6R2_FB19_Pos (19U)
4536#define CAN_F6R2_FB19_Msk (0x1U << CAN_F6R2_FB19_Pos) /*!< 0x00080000 */
4537#define CAN_F6R2_FB19 CAN_F6R2_FB19_Msk /*!<Filter bit 19 */
4538#define CAN_F6R2_FB20_Pos (20U)
4539#define CAN_F6R2_FB20_Msk (0x1U << CAN_F6R2_FB20_Pos) /*!< 0x00100000 */
4540#define CAN_F6R2_FB20 CAN_F6R2_FB20_Msk /*!<Filter bit 20 */
4541#define CAN_F6R2_FB21_Pos (21U)
4542#define CAN_F6R2_FB21_Msk (0x1U << CAN_F6R2_FB21_Pos) /*!< 0x00200000 */
4543#define CAN_F6R2_FB21 CAN_F6R2_FB21_Msk /*!<Filter bit 21 */
4544#define CAN_F6R2_FB22_Pos (22U)
4545#define CAN_F6R2_FB22_Msk (0x1U << CAN_F6R2_FB22_Pos) /*!< 0x00400000 */
4546#define CAN_F6R2_FB22 CAN_F6R2_FB22_Msk /*!<Filter bit 22 */
4547#define CAN_F6R2_FB23_Pos (23U)
4548#define CAN_F6R2_FB23_Msk (0x1U << CAN_F6R2_FB23_Pos) /*!< 0x00800000 */
4549#define CAN_F6R2_FB23 CAN_F6R2_FB23_Msk /*!<Filter bit 23 */
4550#define CAN_F6R2_FB24_Pos (24U)
4551#define CAN_F6R2_FB24_Msk (0x1U << CAN_F6R2_FB24_Pos) /*!< 0x01000000 */
4552#define CAN_F6R2_FB24 CAN_F6R2_FB24_Msk /*!<Filter bit 24 */
4553#define CAN_F6R2_FB25_Pos (25U)
4554#define CAN_F6R2_FB25_Msk (0x1U << CAN_F6R2_FB25_Pos) /*!< 0x02000000 */
4555#define CAN_F6R2_FB25 CAN_F6R2_FB25_Msk /*!<Filter bit 25 */
4556#define CAN_F6R2_FB26_Pos (26U)
4557#define CAN_F6R2_FB26_Msk (0x1U << CAN_F6R2_FB26_Pos) /*!< 0x04000000 */
4558#define CAN_F6R2_FB26 CAN_F6R2_FB26_Msk /*!<Filter bit 26 */
4559#define CAN_F6R2_FB27_Pos (27U)
4560#define CAN_F6R2_FB27_Msk (0x1U << CAN_F6R2_FB27_Pos) /*!< 0x08000000 */
4561#define CAN_F6R2_FB27 CAN_F6R2_FB27_Msk /*!<Filter bit 27 */
4562#define CAN_F6R2_FB28_Pos (28U)
4563#define CAN_F6R2_FB28_Msk (0x1U << CAN_F6R2_FB28_Pos) /*!< 0x10000000 */
4564#define CAN_F6R2_FB28 CAN_F6R2_FB28_Msk /*!<Filter bit 28 */
4565#define CAN_F6R2_FB29_Pos (29U)
4566#define CAN_F6R2_FB29_Msk (0x1U << CAN_F6R2_FB29_Pos) /*!< 0x20000000 */
4567#define CAN_F6R2_FB29 CAN_F6R2_FB29_Msk /*!<Filter bit 29 */
4568#define CAN_F6R2_FB30_Pos (30U)
4569#define CAN_F6R2_FB30_Msk (0x1U << CAN_F6R2_FB30_Pos) /*!< 0x40000000 */
4570#define CAN_F6R2_FB30 CAN_F6R2_FB30_Msk /*!<Filter bit 30 */
4571#define CAN_F6R2_FB31_Pos (31U)
4572#define CAN_F6R2_FB31_Msk (0x1U << CAN_F6R2_FB31_Pos) /*!< 0x80000000 */
4573#define CAN_F6R2_FB31 CAN_F6R2_FB31_Msk /*!<Filter bit 31 */
4574
4575/******************* Bit definition for CAN_F7R2 register *******************/
4576#define CAN_F7R2_FB0_Pos (0U)
4577#define CAN_F7R2_FB0_Msk (0x1U << CAN_F7R2_FB0_Pos) /*!< 0x00000001 */
4578#define CAN_F7R2_FB0 CAN_F7R2_FB0_Msk /*!<Filter bit 0 */
4579#define CAN_F7R2_FB1_Pos (1U)
4580#define CAN_F7R2_FB1_Msk (0x1U << CAN_F7R2_FB1_Pos) /*!< 0x00000002 */
4581#define CAN_F7R2_FB1 CAN_F7R2_FB1_Msk /*!<Filter bit 1 */
4582#define CAN_F7R2_FB2_Pos (2U)
4583#define CAN_F7R2_FB2_Msk (0x1U << CAN_F7R2_FB2_Pos) /*!< 0x00000004 */
4584#define CAN_F7R2_FB2 CAN_F7R2_FB2_Msk /*!<Filter bit 2 */
4585#define CAN_F7R2_FB3_Pos (3U)
4586#define CAN_F7R2_FB3_Msk (0x1U << CAN_F7R2_FB3_Pos) /*!< 0x00000008 */
4587#define CAN_F7R2_FB3 CAN_F7R2_FB3_Msk /*!<Filter bit 3 */
4588#define CAN_F7R2_FB4_Pos (4U)
4589#define CAN_F7R2_FB4_Msk (0x1U << CAN_F7R2_FB4_Pos) /*!< 0x00000010 */
4590#define CAN_F7R2_FB4 CAN_F7R2_FB4_Msk /*!<Filter bit 4 */
4591#define CAN_F7R2_FB5_Pos (5U)
4592#define CAN_F7R2_FB5_Msk (0x1U << CAN_F7R2_FB5_Pos) /*!< 0x00000020 */
4593#define CAN_F7R2_FB5 CAN_F7R2_FB5_Msk /*!<Filter bit 5 */
4594#define CAN_F7R2_FB6_Pos (6U)
4595#define CAN_F7R2_FB6_Msk (0x1U << CAN_F7R2_FB6_Pos) /*!< 0x00000040 */
4596#define CAN_F7R2_FB6 CAN_F7R2_FB6_Msk /*!<Filter bit 6 */
4597#define CAN_F7R2_FB7_Pos (7U)
4598#define CAN_F7R2_FB7_Msk (0x1U << CAN_F7R2_FB7_Pos) /*!< 0x00000080 */
4599#define CAN_F7R2_FB7 CAN_F7R2_FB7_Msk /*!<Filter bit 7 */
4600#define CAN_F7R2_FB8_Pos (8U)
4601#define CAN_F7R2_FB8_Msk (0x1U << CAN_F7R2_FB8_Pos) /*!< 0x00000100 */
4602#define CAN_F7R2_FB8 CAN_F7R2_FB8_Msk /*!<Filter bit 8 */
4603#define CAN_F7R2_FB9_Pos (9U)
4604#define CAN_F7R2_FB9_Msk (0x1U << CAN_F7R2_FB9_Pos) /*!< 0x00000200 */
4605#define CAN_F7R2_FB9 CAN_F7R2_FB9_Msk /*!<Filter bit 9 */
4606#define CAN_F7R2_FB10_Pos (10U)
4607#define CAN_F7R2_FB10_Msk (0x1U << CAN_F7R2_FB10_Pos) /*!< 0x00000400 */
4608#define CAN_F7R2_FB10 CAN_F7R2_FB10_Msk /*!<Filter bit 10 */
4609#define CAN_F7R2_FB11_Pos (11U)
4610#define CAN_F7R2_FB11_Msk (0x1U << CAN_F7R2_FB11_Pos) /*!< 0x00000800 */
4611#define CAN_F7R2_FB11 CAN_F7R2_FB11_Msk /*!<Filter bit 11 */
4612#define CAN_F7R2_FB12_Pos (12U)
4613#define CAN_F7R2_FB12_Msk (0x1U << CAN_F7R2_FB12_Pos) /*!< 0x00001000 */
4614#define CAN_F7R2_FB12 CAN_F7R2_FB12_Msk /*!<Filter bit 12 */
4615#define CAN_F7R2_FB13_Pos (13U)
4616#define CAN_F7R2_FB13_Msk (0x1U << CAN_F7R2_FB13_Pos) /*!< 0x00002000 */
4617#define CAN_F7R2_FB13 CAN_F7R2_FB13_Msk /*!<Filter bit 13 */
4618#define CAN_F7R2_FB14_Pos (14U)
4619#define CAN_F7R2_FB14_Msk (0x1U << CAN_F7R2_FB14_Pos) /*!< 0x00004000 */
4620#define CAN_F7R2_FB14 CAN_F7R2_FB14_Msk /*!<Filter bit 14 */
4621#define CAN_F7R2_FB15_Pos (15U)
4622#define CAN_F7R2_FB15_Msk (0x1U << CAN_F7R2_FB15_Pos) /*!< 0x00008000 */
4623#define CAN_F7R2_FB15 CAN_F7R2_FB15_Msk /*!<Filter bit 15 */
4624#define CAN_F7R2_FB16_Pos (16U)
4625#define CAN_F7R2_FB16_Msk (0x1U << CAN_F7R2_FB16_Pos) /*!< 0x00010000 */
4626#define CAN_F7R2_FB16 CAN_F7R2_FB16_Msk /*!<Filter bit 16 */
4627#define CAN_F7R2_FB17_Pos (17U)
4628#define CAN_F7R2_FB17_Msk (0x1U << CAN_F7R2_FB17_Pos) /*!< 0x00020000 */
4629#define CAN_F7R2_FB17 CAN_F7R2_FB17_Msk /*!<Filter bit 17 */
4630#define CAN_F7R2_FB18_Pos (18U)
4631#define CAN_F7R2_FB18_Msk (0x1U << CAN_F7R2_FB18_Pos) /*!< 0x00040000 */
4632#define CAN_F7R2_FB18 CAN_F7R2_FB18_Msk /*!<Filter bit 18 */
4633#define CAN_F7R2_FB19_Pos (19U)
4634#define CAN_F7R2_FB19_Msk (0x1U << CAN_F7R2_FB19_Pos) /*!< 0x00080000 */
4635#define CAN_F7R2_FB19 CAN_F7R2_FB19_Msk /*!<Filter bit 19 */
4636#define CAN_F7R2_FB20_Pos (20U)
4637#define CAN_F7R2_FB20_Msk (0x1U << CAN_F7R2_FB20_Pos) /*!< 0x00100000 */
4638#define CAN_F7R2_FB20 CAN_F7R2_FB20_Msk /*!<Filter bit 20 */
4639#define CAN_F7R2_FB21_Pos (21U)
4640#define CAN_F7R2_FB21_Msk (0x1U << CAN_F7R2_FB21_Pos) /*!< 0x00200000 */
4641#define CAN_F7R2_FB21 CAN_F7R2_FB21_Msk /*!<Filter bit 21 */
4642#define CAN_F7R2_FB22_Pos (22U)
4643#define CAN_F7R2_FB22_Msk (0x1U << CAN_F7R2_FB22_Pos) /*!< 0x00400000 */
4644#define CAN_F7R2_FB22 CAN_F7R2_FB22_Msk /*!<Filter bit 22 */
4645#define CAN_F7R2_FB23_Pos (23U)
4646#define CAN_F7R2_FB23_Msk (0x1U << CAN_F7R2_FB23_Pos) /*!< 0x00800000 */
4647#define CAN_F7R2_FB23 CAN_F7R2_FB23_Msk /*!<Filter bit 23 */
4648#define CAN_F7R2_FB24_Pos (24U)
4649#define CAN_F7R2_FB24_Msk (0x1U << CAN_F7R2_FB24_Pos) /*!< 0x01000000 */
4650#define CAN_F7R2_FB24 CAN_F7R2_FB24_Msk /*!<Filter bit 24 */
4651#define CAN_F7R2_FB25_Pos (25U)
4652#define CAN_F7R2_FB25_Msk (0x1U << CAN_F7R2_FB25_Pos) /*!< 0x02000000 */
4653#define CAN_F7R2_FB25 CAN_F7R2_FB25_Msk /*!<Filter bit 25 */
4654#define CAN_F7R2_FB26_Pos (26U)
4655#define CAN_F7R2_FB26_Msk (0x1U << CAN_F7R2_FB26_Pos) /*!< 0x04000000 */
4656#define CAN_F7R2_FB26 CAN_F7R2_FB26_Msk /*!<Filter bit 26 */
4657#define CAN_F7R2_FB27_Pos (27U)
4658#define CAN_F7R2_FB27_Msk (0x1U << CAN_F7R2_FB27_Pos) /*!< 0x08000000 */
4659#define CAN_F7R2_FB27 CAN_F7R2_FB27_Msk /*!<Filter bit 27 */
4660#define CAN_F7R2_FB28_Pos (28U)
4661#define CAN_F7R2_FB28_Msk (0x1U << CAN_F7R2_FB28_Pos) /*!< 0x10000000 */
4662#define CAN_F7R2_FB28 CAN_F7R2_FB28_Msk /*!<Filter bit 28 */
4663#define CAN_F7R2_FB29_Pos (29U)
4664#define CAN_F7R2_FB29_Msk (0x1U << CAN_F7R2_FB29_Pos) /*!< 0x20000000 */
4665#define CAN_F7R2_FB29 CAN_F7R2_FB29_Msk /*!<Filter bit 29 */
4666#define CAN_F7R2_FB30_Pos (30U)
4667#define CAN_F7R2_FB30_Msk (0x1U << CAN_F7R2_FB30_Pos) /*!< 0x40000000 */
4668#define CAN_F7R2_FB30 CAN_F7R2_FB30_Msk /*!<Filter bit 30 */
4669#define CAN_F7R2_FB31_Pos (31U)
4670#define CAN_F7R2_FB31_Msk (0x1U << CAN_F7R2_FB31_Pos) /*!< 0x80000000 */
4671#define CAN_F7R2_FB31 CAN_F7R2_FB31_Msk /*!<Filter bit 31 */
4672
4673/******************* Bit definition for CAN_F8R2 register *******************/
4674#define CAN_F8R2_FB0_Pos (0U)
4675#define CAN_F8R2_FB0_Msk (0x1U << CAN_F8R2_FB0_Pos) /*!< 0x00000001 */
4676#define CAN_F8R2_FB0 CAN_F8R2_FB0_Msk /*!<Filter bit 0 */
4677#define CAN_F8R2_FB1_Pos (1U)
4678#define CAN_F8R2_FB1_Msk (0x1U << CAN_F8R2_FB1_Pos) /*!< 0x00000002 */
4679#define CAN_F8R2_FB1 CAN_F8R2_FB1_Msk /*!<Filter bit 1 */
4680#define CAN_F8R2_FB2_Pos (2U)
4681#define CAN_F8R2_FB2_Msk (0x1U << CAN_F8R2_FB2_Pos) /*!< 0x00000004 */
4682#define CAN_F8R2_FB2 CAN_F8R2_FB2_Msk /*!<Filter bit 2 */
4683#define CAN_F8R2_FB3_Pos (3U)
4684#define CAN_F8R2_FB3_Msk (0x1U << CAN_F8R2_FB3_Pos) /*!< 0x00000008 */
4685#define CAN_F8R2_FB3 CAN_F8R2_FB3_Msk /*!<Filter bit 3 */
4686#define CAN_F8R2_FB4_Pos (4U)
4687#define CAN_F8R2_FB4_Msk (0x1U << CAN_F8R2_FB4_Pos) /*!< 0x00000010 */
4688#define CAN_F8R2_FB4 CAN_F8R2_FB4_Msk /*!<Filter bit 4 */
4689#define CAN_F8R2_FB5_Pos (5U)
4690#define CAN_F8R2_FB5_Msk (0x1U << CAN_F8R2_FB5_Pos) /*!< 0x00000020 */
4691#define CAN_F8R2_FB5 CAN_F8R2_FB5_Msk /*!<Filter bit 5 */
4692#define CAN_F8R2_FB6_Pos (6U)
4693#define CAN_F8R2_FB6_Msk (0x1U << CAN_F8R2_FB6_Pos) /*!< 0x00000040 */
4694#define CAN_F8R2_FB6 CAN_F8R2_FB6_Msk /*!<Filter bit 6 */
4695#define CAN_F8R2_FB7_Pos (7U)
4696#define CAN_F8R2_FB7_Msk (0x1U << CAN_F8R2_FB7_Pos) /*!< 0x00000080 */
4697#define CAN_F8R2_FB7 CAN_F8R2_FB7_Msk /*!<Filter bit 7 */
4698#define CAN_F8R2_FB8_Pos (8U)
4699#define CAN_F8R2_FB8_Msk (0x1U << CAN_F8R2_FB8_Pos) /*!< 0x00000100 */
4700#define CAN_F8R2_FB8 CAN_F8R2_FB8_Msk /*!<Filter bit 8 */
4701#define CAN_F8R2_FB9_Pos (9U)
4702#define CAN_F8R2_FB9_Msk (0x1U << CAN_F8R2_FB9_Pos) /*!< 0x00000200 */
4703#define CAN_F8R2_FB9 CAN_F8R2_FB9_Msk /*!<Filter bit 9 */
4704#define CAN_F8R2_FB10_Pos (10U)
4705#define CAN_F8R2_FB10_Msk (0x1U << CAN_F8R2_FB10_Pos) /*!< 0x00000400 */
4706#define CAN_F8R2_FB10 CAN_F8R2_FB10_Msk /*!<Filter bit 10 */
4707#define CAN_F8R2_FB11_Pos (11U)
4708#define CAN_F8R2_FB11_Msk (0x1U << CAN_F8R2_FB11_Pos) /*!< 0x00000800 */
4709#define CAN_F8R2_FB11 CAN_F8R2_FB11_Msk /*!<Filter bit 11 */
4710#define CAN_F8R2_FB12_Pos (12U)
4711#define CAN_F8R2_FB12_Msk (0x1U << CAN_F8R2_FB12_Pos) /*!< 0x00001000 */
4712#define CAN_F8R2_FB12 CAN_F8R2_FB12_Msk /*!<Filter bit 12 */
4713#define CAN_F8R2_FB13_Pos (13U)
4714#define CAN_F8R2_FB13_Msk (0x1U << CAN_F8R2_FB13_Pos) /*!< 0x00002000 */
4715#define CAN_F8R2_FB13 CAN_F8R2_FB13_Msk /*!<Filter bit 13 */
4716#define CAN_F8R2_FB14_Pos (14U)
4717#define CAN_F8R2_FB14_Msk (0x1U << CAN_F8R2_FB14_Pos) /*!< 0x00004000 */
4718#define CAN_F8R2_FB14 CAN_F8R2_FB14_Msk /*!<Filter bit 14 */
4719#define CAN_F8R2_FB15_Pos (15U)
4720#define CAN_F8R2_FB15_Msk (0x1U << CAN_F8R2_FB15_Pos) /*!< 0x00008000 */
4721#define CAN_F8R2_FB15 CAN_F8R2_FB15_Msk /*!<Filter bit 15 */
4722#define CAN_F8R2_FB16_Pos (16U)
4723#define CAN_F8R2_FB16_Msk (0x1U << CAN_F8R2_FB16_Pos) /*!< 0x00010000 */
4724#define CAN_F8R2_FB16 CAN_F8R2_FB16_Msk /*!<Filter bit 16 */
4725#define CAN_F8R2_FB17_Pos (17U)
4726#define CAN_F8R2_FB17_Msk (0x1U << CAN_F8R2_FB17_Pos) /*!< 0x00020000 */
4727#define CAN_F8R2_FB17 CAN_F8R2_FB17_Msk /*!<Filter bit 17 */
4728#define CAN_F8R2_FB18_Pos (18U)
4729#define CAN_F8R2_FB18_Msk (0x1U << CAN_F8R2_FB18_Pos) /*!< 0x00040000 */
4730#define CAN_F8R2_FB18 CAN_F8R2_FB18_Msk /*!<Filter bit 18 */
4731#define CAN_F8R2_FB19_Pos (19U)
4732#define CAN_F8R2_FB19_Msk (0x1U << CAN_F8R2_FB19_Pos) /*!< 0x00080000 */
4733#define CAN_F8R2_FB19 CAN_F8R2_FB19_Msk /*!<Filter bit 19 */
4734#define CAN_F8R2_FB20_Pos (20U)
4735#define CAN_F8R2_FB20_Msk (0x1U << CAN_F8R2_FB20_Pos) /*!< 0x00100000 */
4736#define CAN_F8R2_FB20 CAN_F8R2_FB20_Msk /*!<Filter bit 20 */
4737#define CAN_F8R2_FB21_Pos (21U)
4738#define CAN_F8R2_FB21_Msk (0x1U << CAN_F8R2_FB21_Pos) /*!< 0x00200000 */
4739#define CAN_F8R2_FB21 CAN_F8R2_FB21_Msk /*!<Filter bit 21 */
4740#define CAN_F8R2_FB22_Pos (22U)
4741#define CAN_F8R2_FB22_Msk (0x1U << CAN_F8R2_FB22_Pos) /*!< 0x00400000 */
4742#define CAN_F8R2_FB22 CAN_F8R2_FB22_Msk /*!<Filter bit 22 */
4743#define CAN_F8R2_FB23_Pos (23U)
4744#define CAN_F8R2_FB23_Msk (0x1U << CAN_F8R2_FB23_Pos) /*!< 0x00800000 */
4745#define CAN_F8R2_FB23 CAN_F8R2_FB23_Msk /*!<Filter bit 23 */
4746#define CAN_F8R2_FB24_Pos (24U)
4747#define CAN_F8R2_FB24_Msk (0x1U << CAN_F8R2_FB24_Pos) /*!< 0x01000000 */
4748#define CAN_F8R2_FB24 CAN_F8R2_FB24_Msk /*!<Filter bit 24 */
4749#define CAN_F8R2_FB25_Pos (25U)
4750#define CAN_F8R2_FB25_Msk (0x1U << CAN_F8R2_FB25_Pos) /*!< 0x02000000 */
4751#define CAN_F8R2_FB25 CAN_F8R2_FB25_Msk /*!<Filter bit 25 */
4752#define CAN_F8R2_FB26_Pos (26U)
4753#define CAN_F8R2_FB26_Msk (0x1U << CAN_F8R2_FB26_Pos) /*!< 0x04000000 */
4754#define CAN_F8R2_FB26 CAN_F8R2_FB26_Msk /*!<Filter bit 26 */
4755#define CAN_F8R2_FB27_Pos (27U)
4756#define CAN_F8R2_FB27_Msk (0x1U << CAN_F8R2_FB27_Pos) /*!< 0x08000000 */
4757#define CAN_F8R2_FB27 CAN_F8R2_FB27_Msk /*!<Filter bit 27 */
4758#define CAN_F8R2_FB28_Pos (28U)
4759#define CAN_F8R2_FB28_Msk (0x1U << CAN_F8R2_FB28_Pos) /*!< 0x10000000 */
4760#define CAN_F8R2_FB28 CAN_F8R2_FB28_Msk /*!<Filter bit 28 */
4761#define CAN_F8R2_FB29_Pos (29U)
4762#define CAN_F8R2_FB29_Msk (0x1U << CAN_F8R2_FB29_Pos) /*!< 0x20000000 */
4763#define CAN_F8R2_FB29 CAN_F8R2_FB29_Msk /*!<Filter bit 29 */
4764#define CAN_F8R2_FB30_Pos (30U)
4765#define CAN_F8R2_FB30_Msk (0x1U << CAN_F8R2_FB30_Pos) /*!< 0x40000000 */
4766#define CAN_F8R2_FB30 CAN_F8R2_FB30_Msk /*!<Filter bit 30 */
4767#define CAN_F8R2_FB31_Pos (31U)
4768#define CAN_F8R2_FB31_Msk (0x1U << CAN_F8R2_FB31_Pos) /*!< 0x80000000 */
4769#define CAN_F8R2_FB31 CAN_F8R2_FB31_Msk /*!<Filter bit 31 */
4770
4771/******************* Bit definition for CAN_F9R2 register *******************/
4772#define CAN_F9R2_FB0_Pos (0U)
4773#define CAN_F9R2_FB0_Msk (0x1U << CAN_F9R2_FB0_Pos) /*!< 0x00000001 */
4774#define CAN_F9R2_FB0 CAN_F9R2_FB0_Msk /*!<Filter bit 0 */
4775#define CAN_F9R2_FB1_Pos (1U)
4776#define CAN_F9R2_FB1_Msk (0x1U << CAN_F9R2_FB1_Pos) /*!< 0x00000002 */
4777#define CAN_F9R2_FB1 CAN_F9R2_FB1_Msk /*!<Filter bit 1 */
4778#define CAN_F9R2_FB2_Pos (2U)
4779#define CAN_F9R2_FB2_Msk (0x1U << CAN_F9R2_FB2_Pos) /*!< 0x00000004 */
4780#define CAN_F9R2_FB2 CAN_F9R2_FB2_Msk /*!<Filter bit 2 */
4781#define CAN_F9R2_FB3_Pos (3U)
4782#define CAN_F9R2_FB3_Msk (0x1U << CAN_F9R2_FB3_Pos) /*!< 0x00000008 */
4783#define CAN_F9R2_FB3 CAN_F9R2_FB3_Msk /*!<Filter bit 3 */
4784#define CAN_F9R2_FB4_Pos (4U)
4785#define CAN_F9R2_FB4_Msk (0x1U << CAN_F9R2_FB4_Pos) /*!< 0x00000010 */
4786#define CAN_F9R2_FB4 CAN_F9R2_FB4_Msk /*!<Filter bit 4 */
4787#define CAN_F9R2_FB5_Pos (5U)
4788#define CAN_F9R2_FB5_Msk (0x1U << CAN_F9R2_FB5_Pos) /*!< 0x00000020 */
4789#define CAN_F9R2_FB5 CAN_F9R2_FB5_Msk /*!<Filter bit 5 */
4790#define CAN_F9R2_FB6_Pos (6U)
4791#define CAN_F9R2_FB6_Msk (0x1U << CAN_F9R2_FB6_Pos) /*!< 0x00000040 */
4792#define CAN_F9R2_FB6 CAN_F9R2_FB6_Msk /*!<Filter bit 6 */
4793#define CAN_F9R2_FB7_Pos (7U)
4794#define CAN_F9R2_FB7_Msk (0x1U << CAN_F9R2_FB7_Pos) /*!< 0x00000080 */
4795#define CAN_F9R2_FB7 CAN_F9R2_FB7_Msk /*!<Filter bit 7 */
4796#define CAN_F9R2_FB8_Pos (8U)
4797#define CAN_F9R2_FB8_Msk (0x1U << CAN_F9R2_FB8_Pos) /*!< 0x00000100 */
4798#define CAN_F9R2_FB8 CAN_F9R2_FB8_Msk /*!<Filter bit 8 */
4799#define CAN_F9R2_FB9_Pos (9U)
4800#define CAN_F9R2_FB9_Msk (0x1U << CAN_F9R2_FB9_Pos) /*!< 0x00000200 */
4801#define CAN_F9R2_FB9 CAN_F9R2_FB9_Msk /*!<Filter bit 9 */
4802#define CAN_F9R2_FB10_Pos (10U)
4803#define CAN_F9R2_FB10_Msk (0x1U << CAN_F9R2_FB10_Pos) /*!< 0x00000400 */
4804#define CAN_F9R2_FB10 CAN_F9R2_FB10_Msk /*!<Filter bit 10 */
4805#define CAN_F9R2_FB11_Pos (11U)
4806#define CAN_F9R2_FB11_Msk (0x1U << CAN_F9R2_FB11_Pos) /*!< 0x00000800 */
4807#define CAN_F9R2_FB11 CAN_F9R2_FB11_Msk /*!<Filter bit 11 */
4808#define CAN_F9R2_FB12_Pos (12U)
4809#define CAN_F9R2_FB12_Msk (0x1U << CAN_F9R2_FB12_Pos) /*!< 0x00001000 */
4810#define CAN_F9R2_FB12 CAN_F9R2_FB12_Msk /*!<Filter bit 12 */
4811#define CAN_F9R2_FB13_Pos (13U)
4812#define CAN_F9R2_FB13_Msk (0x1U << CAN_F9R2_FB13_Pos) /*!< 0x00002000 */
4813#define CAN_F9R2_FB13 CAN_F9R2_FB13_Msk /*!<Filter bit 13 */
4814#define CAN_F9R2_FB14_Pos (14U)
4815#define CAN_F9R2_FB14_Msk (0x1U << CAN_F9R2_FB14_Pos) /*!< 0x00004000 */
4816#define CAN_F9R2_FB14 CAN_F9R2_FB14_Msk /*!<Filter bit 14 */
4817#define CAN_F9R2_FB15_Pos (15U)
4818#define CAN_F9R2_FB15_Msk (0x1U << CAN_F9R2_FB15_Pos) /*!< 0x00008000 */
4819#define CAN_F9R2_FB15 CAN_F9R2_FB15_Msk /*!<Filter bit 15 */
4820#define CAN_F9R2_FB16_Pos (16U)
4821#define CAN_F9R2_FB16_Msk (0x1U << CAN_F9R2_FB16_Pos) /*!< 0x00010000 */
4822#define CAN_F9R2_FB16 CAN_F9R2_FB16_Msk /*!<Filter bit 16 */
4823#define CAN_F9R2_FB17_Pos (17U)
4824#define CAN_F9R2_FB17_Msk (0x1U << CAN_F9R2_FB17_Pos) /*!< 0x00020000 */
4825#define CAN_F9R2_FB17 CAN_F9R2_FB17_Msk /*!<Filter bit 17 */
4826#define CAN_F9R2_FB18_Pos (18U)
4827#define CAN_F9R2_FB18_Msk (0x1U << CAN_F9R2_FB18_Pos) /*!< 0x00040000 */
4828#define CAN_F9R2_FB18 CAN_F9R2_FB18_Msk /*!<Filter bit 18 */
4829#define CAN_F9R2_FB19_Pos (19U)
4830#define CAN_F9R2_FB19_Msk (0x1U << CAN_F9R2_FB19_Pos) /*!< 0x00080000 */
4831#define CAN_F9R2_FB19 CAN_F9R2_FB19_Msk /*!<Filter bit 19 */
4832#define CAN_F9R2_FB20_Pos (20U)
4833#define CAN_F9R2_FB20_Msk (0x1U << CAN_F9R2_FB20_Pos) /*!< 0x00100000 */
4834#define CAN_F9R2_FB20 CAN_F9R2_FB20_Msk /*!<Filter bit 20 */
4835#define CAN_F9R2_FB21_Pos (21U)
4836#define CAN_F9R2_FB21_Msk (0x1U << CAN_F9R2_FB21_Pos) /*!< 0x00200000 */
4837#define CAN_F9R2_FB21 CAN_F9R2_FB21_Msk /*!<Filter bit 21 */
4838#define CAN_F9R2_FB22_Pos (22U)
4839#define CAN_F9R2_FB22_Msk (0x1U << CAN_F9R2_FB22_Pos) /*!< 0x00400000 */
4840#define CAN_F9R2_FB22 CAN_F9R2_FB22_Msk /*!<Filter bit 22 */
4841#define CAN_F9R2_FB23_Pos (23U)
4842#define CAN_F9R2_FB23_Msk (0x1U << CAN_F9R2_FB23_Pos) /*!< 0x00800000 */
4843#define CAN_F9R2_FB23 CAN_F9R2_FB23_Msk /*!<Filter bit 23 */
4844#define CAN_F9R2_FB24_Pos (24U)
4845#define CAN_F9R2_FB24_Msk (0x1U << CAN_F9R2_FB24_Pos) /*!< 0x01000000 */
4846#define CAN_F9R2_FB24 CAN_F9R2_FB24_Msk /*!<Filter bit 24 */
4847#define CAN_F9R2_FB25_Pos (25U)
4848#define CAN_F9R2_FB25_Msk (0x1U << CAN_F9R2_FB25_Pos) /*!< 0x02000000 */
4849#define CAN_F9R2_FB25 CAN_F9R2_FB25_Msk /*!<Filter bit 25 */
4850#define CAN_F9R2_FB26_Pos (26U)
4851#define CAN_F9R2_FB26_Msk (0x1U << CAN_F9R2_FB26_Pos) /*!< 0x04000000 */
4852#define CAN_F9R2_FB26 CAN_F9R2_FB26_Msk /*!<Filter bit 26 */
4853#define CAN_F9R2_FB27_Pos (27U)
4854#define CAN_F9R2_FB27_Msk (0x1U << CAN_F9R2_FB27_Pos) /*!< 0x08000000 */
4855#define CAN_F9R2_FB27 CAN_F9R2_FB27_Msk /*!<Filter bit 27 */
4856#define CAN_F9R2_FB28_Pos (28U)
4857#define CAN_F9R2_FB28_Msk (0x1U << CAN_F9R2_FB28_Pos) /*!< 0x10000000 */
4858#define CAN_F9R2_FB28 CAN_F9R2_FB28_Msk /*!<Filter bit 28 */
4859#define CAN_F9R2_FB29_Pos (29U)
4860#define CAN_F9R2_FB29_Msk (0x1U << CAN_F9R2_FB29_Pos) /*!< 0x20000000 */
4861#define CAN_F9R2_FB29 CAN_F9R2_FB29_Msk /*!<Filter bit 29 */
4862#define CAN_F9R2_FB30_Pos (30U)
4863#define CAN_F9R2_FB30_Msk (0x1U << CAN_F9R2_FB30_Pos) /*!< 0x40000000 */
4864#define CAN_F9R2_FB30 CAN_F9R2_FB30_Msk /*!<Filter bit 30 */
4865#define CAN_F9R2_FB31_Pos (31U)
4866#define CAN_F9R2_FB31_Msk (0x1U << CAN_F9R2_FB31_Pos) /*!< 0x80000000 */
4867#define CAN_F9R2_FB31 CAN_F9R2_FB31_Msk /*!<Filter bit 31 */
4868
4869/******************* Bit definition for CAN_F10R2 register ******************/
4870#define CAN_F10R2_FB0_Pos (0U)
4871#define CAN_F10R2_FB0_Msk (0x1U << CAN_F10R2_FB0_Pos) /*!< 0x00000001 */
4872#define CAN_F10R2_FB0 CAN_F10R2_FB0_Msk /*!<Filter bit 0 */
4873#define CAN_F10R2_FB1_Pos (1U)
4874#define CAN_F10R2_FB1_Msk (0x1U << CAN_F10R2_FB1_Pos) /*!< 0x00000002 */
4875#define CAN_F10R2_FB1 CAN_F10R2_FB1_Msk /*!<Filter bit 1 */
4876#define CAN_F10R2_FB2_Pos (2U)
4877#define CAN_F10R2_FB2_Msk (0x1U << CAN_F10R2_FB2_Pos) /*!< 0x00000004 */
4878#define CAN_F10R2_FB2 CAN_F10R2_FB2_Msk /*!<Filter bit 2 */
4879#define CAN_F10R2_FB3_Pos (3U)
4880#define CAN_F10R2_FB3_Msk (0x1U << CAN_F10R2_FB3_Pos) /*!< 0x00000008 */
4881#define CAN_F10R2_FB3 CAN_F10R2_FB3_Msk /*!<Filter bit 3 */
4882#define CAN_F10R2_FB4_Pos (4U)
4883#define CAN_F10R2_FB4_Msk (0x1U << CAN_F10R2_FB4_Pos) /*!< 0x00000010 */
4884#define CAN_F10R2_FB4 CAN_F10R2_FB4_Msk /*!<Filter bit 4 */
4885#define CAN_F10R2_FB5_Pos (5U)
4886#define CAN_F10R2_FB5_Msk (0x1U << CAN_F10R2_FB5_Pos) /*!< 0x00000020 */
4887#define CAN_F10R2_FB5 CAN_F10R2_FB5_Msk /*!<Filter bit 5 */
4888#define CAN_F10R2_FB6_Pos (6U)
4889#define CAN_F10R2_FB6_Msk (0x1U << CAN_F10R2_FB6_Pos) /*!< 0x00000040 */
4890#define CAN_F10R2_FB6 CAN_F10R2_FB6_Msk /*!<Filter bit 6 */
4891#define CAN_F10R2_FB7_Pos (7U)
4892#define CAN_F10R2_FB7_Msk (0x1U << CAN_F10R2_FB7_Pos) /*!< 0x00000080 */
4893#define CAN_F10R2_FB7 CAN_F10R2_FB7_Msk /*!<Filter bit 7 */
4894#define CAN_F10R2_FB8_Pos (8U)
4895#define CAN_F10R2_FB8_Msk (0x1U << CAN_F10R2_FB8_Pos) /*!< 0x00000100 */
4896#define CAN_F10R2_FB8 CAN_F10R2_FB8_Msk /*!<Filter bit 8 */
4897#define CAN_F10R2_FB9_Pos (9U)
4898#define CAN_F10R2_FB9_Msk (0x1U << CAN_F10R2_FB9_Pos) /*!< 0x00000200 */
4899#define CAN_F10R2_FB9 CAN_F10R2_FB9_Msk /*!<Filter bit 9 */
4900#define CAN_F10R2_FB10_Pos (10U)
4901#define CAN_F10R2_FB10_Msk (0x1U << CAN_F10R2_FB10_Pos) /*!< 0x00000400 */
4902#define CAN_F10R2_FB10 CAN_F10R2_FB10_Msk /*!<Filter bit 10 */
4903#define CAN_F10R2_FB11_Pos (11U)
4904#define CAN_F10R2_FB11_Msk (0x1U << CAN_F10R2_FB11_Pos) /*!< 0x00000800 */
4905#define CAN_F10R2_FB11 CAN_F10R2_FB11_Msk /*!<Filter bit 11 */
4906#define CAN_F10R2_FB12_Pos (12U)
4907#define CAN_F10R2_FB12_Msk (0x1U << CAN_F10R2_FB12_Pos) /*!< 0x00001000 */
4908#define CAN_F10R2_FB12 CAN_F10R2_FB12_Msk /*!<Filter bit 12 */
4909#define CAN_F10R2_FB13_Pos (13U)
4910#define CAN_F10R2_FB13_Msk (0x1U << CAN_F10R2_FB13_Pos) /*!< 0x00002000 */
4911#define CAN_F10R2_FB13 CAN_F10R2_FB13_Msk /*!<Filter bit 13 */
4912#define CAN_F10R2_FB14_Pos (14U)
4913#define CAN_F10R2_FB14_Msk (0x1U << CAN_F10R2_FB14_Pos) /*!< 0x00004000 */
4914#define CAN_F10R2_FB14 CAN_F10R2_FB14_Msk /*!<Filter bit 14 */
4915#define CAN_F10R2_FB15_Pos (15U)
4916#define CAN_F10R2_FB15_Msk (0x1U << CAN_F10R2_FB15_Pos) /*!< 0x00008000 */
4917#define CAN_F10R2_FB15 CAN_F10R2_FB15_Msk /*!<Filter bit 15 */
4918#define CAN_F10R2_FB16_Pos (16U)
4919#define CAN_F10R2_FB16_Msk (0x1U << CAN_F10R2_FB16_Pos) /*!< 0x00010000 */
4920#define CAN_F10R2_FB16 CAN_F10R2_FB16_Msk /*!<Filter bit 16 */
4921#define CAN_F10R2_FB17_Pos (17U)
4922#define CAN_F10R2_FB17_Msk (0x1U << CAN_F10R2_FB17_Pos) /*!< 0x00020000 */
4923#define CAN_F10R2_FB17 CAN_F10R2_FB17_Msk /*!<Filter bit 17 */
4924#define CAN_F10R2_FB18_Pos (18U)
4925#define CAN_F10R2_FB18_Msk (0x1U << CAN_F10R2_FB18_Pos) /*!< 0x00040000 */
4926#define CAN_F10R2_FB18 CAN_F10R2_FB18_Msk /*!<Filter bit 18 */
4927#define CAN_F10R2_FB19_Pos (19U)
4928#define CAN_F10R2_FB19_Msk (0x1U << CAN_F10R2_FB19_Pos) /*!< 0x00080000 */
4929#define CAN_F10R2_FB19 CAN_F10R2_FB19_Msk /*!<Filter bit 19 */
4930#define CAN_F10R2_FB20_Pos (20U)
4931#define CAN_F10R2_FB20_Msk (0x1U << CAN_F10R2_FB20_Pos) /*!< 0x00100000 */
4932#define CAN_F10R2_FB20 CAN_F10R2_FB20_Msk /*!<Filter bit 20 */
4933#define CAN_F10R2_FB21_Pos (21U)
4934#define CAN_F10R2_FB21_Msk (0x1U << CAN_F10R2_FB21_Pos) /*!< 0x00200000 */
4935#define CAN_F10R2_FB21 CAN_F10R2_FB21_Msk /*!<Filter bit 21 */
4936#define CAN_F10R2_FB22_Pos (22U)
4937#define CAN_F10R2_FB22_Msk (0x1U << CAN_F10R2_FB22_Pos) /*!< 0x00400000 */
4938#define CAN_F10R2_FB22 CAN_F10R2_FB22_Msk /*!<Filter bit 22 */
4939#define CAN_F10R2_FB23_Pos (23U)
4940#define CAN_F10R2_FB23_Msk (0x1U << CAN_F10R2_FB23_Pos) /*!< 0x00800000 */
4941#define CAN_F10R2_FB23 CAN_F10R2_FB23_Msk /*!<Filter bit 23 */
4942#define CAN_F10R2_FB24_Pos (24U)
4943#define CAN_F10R2_FB24_Msk (0x1U << CAN_F10R2_FB24_Pos) /*!< 0x01000000 */
4944#define CAN_F10R2_FB24 CAN_F10R2_FB24_Msk /*!<Filter bit 24 */
4945#define CAN_F10R2_FB25_Pos (25U)
4946#define CAN_F10R2_FB25_Msk (0x1U << CAN_F10R2_FB25_Pos) /*!< 0x02000000 */
4947#define CAN_F10R2_FB25 CAN_F10R2_FB25_Msk /*!<Filter bit 25 */
4948#define CAN_F10R2_FB26_Pos (26U)
4949#define CAN_F10R2_FB26_Msk (0x1U << CAN_F10R2_FB26_Pos) /*!< 0x04000000 */
4950#define CAN_F10R2_FB26 CAN_F10R2_FB26_Msk /*!<Filter bit 26 */
4951#define CAN_F10R2_FB27_Pos (27U)
4952#define CAN_F10R2_FB27_Msk (0x1U << CAN_F10R2_FB27_Pos) /*!< 0x08000000 */
4953#define CAN_F10R2_FB27 CAN_F10R2_FB27_Msk /*!<Filter bit 27 */
4954#define CAN_F10R2_FB28_Pos (28U)
4955#define CAN_F10R2_FB28_Msk (0x1U << CAN_F10R2_FB28_Pos) /*!< 0x10000000 */
4956#define CAN_F10R2_FB28 CAN_F10R2_FB28_Msk /*!<Filter bit 28 */
4957#define CAN_F10R2_FB29_Pos (29U)
4958#define CAN_F10R2_FB29_Msk (0x1U << CAN_F10R2_FB29_Pos) /*!< 0x20000000 */
4959#define CAN_F10R2_FB29 CAN_F10R2_FB29_Msk /*!<Filter bit 29 */
4960#define CAN_F10R2_FB30_Pos (30U)
4961#define CAN_F10R2_FB30_Msk (0x1U << CAN_F10R2_FB30_Pos) /*!< 0x40000000 */
4962#define CAN_F10R2_FB30 CAN_F10R2_FB30_Msk /*!<Filter bit 30 */
4963#define CAN_F10R2_FB31_Pos (31U)
4964#define CAN_F10R2_FB31_Msk (0x1U << CAN_F10R2_FB31_Pos) /*!< 0x80000000 */
4965#define CAN_F10R2_FB31 CAN_F10R2_FB31_Msk /*!<Filter bit 31 */
4966
4967/******************* Bit definition for CAN_F11R2 register ******************/
4968#define CAN_F11R2_FB0_Pos (0U)
4969#define CAN_F11R2_FB0_Msk (0x1U << CAN_F11R2_FB0_Pos) /*!< 0x00000001 */
4970#define CAN_F11R2_FB0 CAN_F11R2_FB0_Msk /*!<Filter bit 0 */
4971#define CAN_F11R2_FB1_Pos (1U)
4972#define CAN_F11R2_FB1_Msk (0x1U << CAN_F11R2_FB1_Pos) /*!< 0x00000002 */
4973#define CAN_F11R2_FB1 CAN_F11R2_FB1_Msk /*!<Filter bit 1 */
4974#define CAN_F11R2_FB2_Pos (2U)
4975#define CAN_F11R2_FB2_Msk (0x1U << CAN_F11R2_FB2_Pos) /*!< 0x00000004 */
4976#define CAN_F11R2_FB2 CAN_F11R2_FB2_Msk /*!<Filter bit 2 */
4977#define CAN_F11R2_FB3_Pos (3U)
4978#define CAN_F11R2_FB3_Msk (0x1U << CAN_F11R2_FB3_Pos) /*!< 0x00000008 */
4979#define CAN_F11R2_FB3 CAN_F11R2_FB3_Msk /*!<Filter bit 3 */
4980#define CAN_F11R2_FB4_Pos (4U)
4981#define CAN_F11R2_FB4_Msk (0x1U << CAN_F11R2_FB4_Pos) /*!< 0x00000010 */
4982#define CAN_F11R2_FB4 CAN_F11R2_FB4_Msk /*!<Filter bit 4 */
4983#define CAN_F11R2_FB5_Pos (5U)
4984#define CAN_F11R2_FB5_Msk (0x1U << CAN_F11R2_FB5_Pos) /*!< 0x00000020 */
4985#define CAN_F11R2_FB5 CAN_F11R2_FB5_Msk /*!<Filter bit 5 */
4986#define CAN_F11R2_FB6_Pos (6U)
4987#define CAN_F11R2_FB6_Msk (0x1U << CAN_F11R2_FB6_Pos) /*!< 0x00000040 */
4988#define CAN_F11R2_FB6 CAN_F11R2_FB6_Msk /*!<Filter bit 6 */
4989#define CAN_F11R2_FB7_Pos (7U)
4990#define CAN_F11R2_FB7_Msk (0x1U << CAN_F11R2_FB7_Pos) /*!< 0x00000080 */
4991#define CAN_F11R2_FB7 CAN_F11R2_FB7_Msk /*!<Filter bit 7 */
4992#define CAN_F11R2_FB8_Pos (8U)
4993#define CAN_F11R2_FB8_Msk (0x1U << CAN_F11R2_FB8_Pos) /*!< 0x00000100 */
4994#define CAN_F11R2_FB8 CAN_F11R2_FB8_Msk /*!<Filter bit 8 */
4995#define CAN_F11R2_FB9_Pos (9U)
4996#define CAN_F11R2_FB9_Msk (0x1U << CAN_F11R2_FB9_Pos) /*!< 0x00000200 */
4997#define CAN_F11R2_FB9 CAN_F11R2_FB9_Msk /*!<Filter bit 9 */
4998#define CAN_F11R2_FB10_Pos (10U)
4999#define CAN_F11R2_FB10_Msk (0x1U << CAN_F11R2_FB10_Pos) /*!< 0x00000400 */
5000#define CAN_F11R2_FB10 CAN_F11R2_FB10_Msk /*!<Filter bit 10 */
5001#define CAN_F11R2_FB11_Pos (11U)
5002#define CAN_F11R2_FB11_Msk (0x1U << CAN_F11R2_FB11_Pos) /*!< 0x00000800 */
5003#define CAN_F11R2_FB11 CAN_F11R2_FB11_Msk /*!<Filter bit 11 */
5004#define CAN_F11R2_FB12_Pos (12U)
5005#define CAN_F11R2_FB12_Msk (0x1U << CAN_F11R2_FB12_Pos) /*!< 0x00001000 */
5006#define CAN_F11R2_FB12 CAN_F11R2_FB12_Msk /*!<Filter bit 12 */
5007#define CAN_F11R2_FB13_Pos (13U)
5008#define CAN_F11R2_FB13_Msk (0x1U << CAN_F11R2_FB13_Pos) /*!< 0x00002000 */
5009#define CAN_F11R2_FB13 CAN_F11R2_FB13_Msk /*!<Filter bit 13 */
5010#define CAN_F11R2_FB14_Pos (14U)
5011#define CAN_F11R2_FB14_Msk (0x1U << CAN_F11R2_FB14_Pos) /*!< 0x00004000 */
5012#define CAN_F11R2_FB14 CAN_F11R2_FB14_Msk /*!<Filter bit 14 */
5013#define CAN_F11R2_FB15_Pos (15U)
5014#define CAN_F11R2_FB15_Msk (0x1U << CAN_F11R2_FB15_Pos) /*!< 0x00008000 */
5015#define CAN_F11R2_FB15 CAN_F11R2_FB15_Msk /*!<Filter bit 15 */
5016#define CAN_F11R2_FB16_Pos (16U)
5017#define CAN_F11R2_FB16_Msk (0x1U << CAN_F11R2_FB16_Pos) /*!< 0x00010000 */
5018#define CAN_F11R2_FB16 CAN_F11R2_FB16_Msk /*!<Filter bit 16 */
5019#define CAN_F11R2_FB17_Pos (17U)
5020#define CAN_F11R2_FB17_Msk (0x1U << CAN_F11R2_FB17_Pos) /*!< 0x00020000 */
5021#define CAN_F11R2_FB17 CAN_F11R2_FB17_Msk /*!<Filter bit 17 */
5022#define CAN_F11R2_FB18_Pos (18U)
5023#define CAN_F11R2_FB18_Msk (0x1U << CAN_F11R2_FB18_Pos) /*!< 0x00040000 */
5024#define CAN_F11R2_FB18 CAN_F11R2_FB18_Msk /*!<Filter bit 18 */
5025#define CAN_F11R2_FB19_Pos (19U)
5026#define CAN_F11R2_FB19_Msk (0x1U << CAN_F11R2_FB19_Pos) /*!< 0x00080000 */
5027#define CAN_F11R2_FB19 CAN_F11R2_FB19_Msk /*!<Filter bit 19 */
5028#define CAN_F11R2_FB20_Pos (20U)
5029#define CAN_F11R2_FB20_Msk (0x1U << CAN_F11R2_FB20_Pos) /*!< 0x00100000 */
5030#define CAN_F11R2_FB20 CAN_F11R2_FB20_Msk /*!<Filter bit 20 */
5031#define CAN_F11R2_FB21_Pos (21U)
5032#define CAN_F11R2_FB21_Msk (0x1U << CAN_F11R2_FB21_Pos) /*!< 0x00200000 */
5033#define CAN_F11R2_FB21 CAN_F11R2_FB21_Msk /*!<Filter bit 21 */
5034#define CAN_F11R2_FB22_Pos (22U)
5035#define CAN_F11R2_FB22_Msk (0x1U << CAN_F11R2_FB22_Pos) /*!< 0x00400000 */
5036#define CAN_F11R2_FB22 CAN_F11R2_FB22_Msk /*!<Filter bit 22 */
5037#define CAN_F11R2_FB23_Pos (23U)
5038#define CAN_F11R2_FB23_Msk (0x1U << CAN_F11R2_FB23_Pos) /*!< 0x00800000 */
5039#define CAN_F11R2_FB23 CAN_F11R2_FB23_Msk /*!<Filter bit 23 */
5040#define CAN_F11R2_FB24_Pos (24U)
5041#define CAN_F11R2_FB24_Msk (0x1U << CAN_F11R2_FB24_Pos) /*!< 0x01000000 */
5042#define CAN_F11R2_FB24 CAN_F11R2_FB24_Msk /*!<Filter bit 24 */
5043#define CAN_F11R2_FB25_Pos (25U)
5044#define CAN_F11R2_FB25_Msk (0x1U << CAN_F11R2_FB25_Pos) /*!< 0x02000000 */
5045#define CAN_F11R2_FB25 CAN_F11R2_FB25_Msk /*!<Filter bit 25 */
5046#define CAN_F11R2_FB26_Pos (26U)
5047#define CAN_F11R2_FB26_Msk (0x1U << CAN_F11R2_FB26_Pos) /*!< 0x04000000 */
5048#define CAN_F11R2_FB26 CAN_F11R2_FB26_Msk /*!<Filter bit 26 */
5049#define CAN_F11R2_FB27_Pos (27U)
5050#define CAN_F11R2_FB27_Msk (0x1U << CAN_F11R2_FB27_Pos) /*!< 0x08000000 */
5051#define CAN_F11R2_FB27 CAN_F11R2_FB27_Msk /*!<Filter bit 27 */
5052#define CAN_F11R2_FB28_Pos (28U)
5053#define CAN_F11R2_FB28_Msk (0x1U << CAN_F11R2_FB28_Pos) /*!< 0x10000000 */
5054#define CAN_F11R2_FB28 CAN_F11R2_FB28_Msk /*!<Filter bit 28 */
5055#define CAN_F11R2_FB29_Pos (29U)
5056#define CAN_F11R2_FB29_Msk (0x1U << CAN_F11R2_FB29_Pos) /*!< 0x20000000 */
5057#define CAN_F11R2_FB29 CAN_F11R2_FB29_Msk /*!<Filter bit 29 */
5058#define CAN_F11R2_FB30_Pos (30U)
5059#define CAN_F11R2_FB30_Msk (0x1U << CAN_F11R2_FB30_Pos) /*!< 0x40000000 */
5060#define CAN_F11R2_FB30 CAN_F11R2_FB30_Msk /*!<Filter bit 30 */
5061#define CAN_F11R2_FB31_Pos (31U)
5062#define CAN_F11R2_FB31_Msk (0x1U << CAN_F11R2_FB31_Pos) /*!< 0x80000000 */
5063#define CAN_F11R2_FB31 CAN_F11R2_FB31_Msk /*!<Filter bit 31 */
5064
5065/******************* Bit definition for CAN_F12R2 register ******************/
5066#define CAN_F12R2_FB0_Pos (0U)
5067#define CAN_F12R2_FB0_Msk (0x1U << CAN_F12R2_FB0_Pos) /*!< 0x00000001 */
5068#define CAN_F12R2_FB0 CAN_F12R2_FB0_Msk /*!<Filter bit 0 */
5069#define CAN_F12R2_FB1_Pos (1U)
5070#define CAN_F12R2_FB1_Msk (0x1U << CAN_F12R2_FB1_Pos) /*!< 0x00000002 */
5071#define CAN_F12R2_FB1 CAN_F12R2_FB1_Msk /*!<Filter bit 1 */
5072#define CAN_F12R2_FB2_Pos (2U)
5073#define CAN_F12R2_FB2_Msk (0x1U << CAN_F12R2_FB2_Pos) /*!< 0x00000004 */
5074#define CAN_F12R2_FB2 CAN_F12R2_FB2_Msk /*!<Filter bit 2 */
5075#define CAN_F12R2_FB3_Pos (3U)
5076#define CAN_F12R2_FB3_Msk (0x1U << CAN_F12R2_FB3_Pos) /*!< 0x00000008 */
5077#define CAN_F12R2_FB3 CAN_F12R2_FB3_Msk /*!<Filter bit 3 */
5078#define CAN_F12R2_FB4_Pos (4U)
5079#define CAN_F12R2_FB4_Msk (0x1U << CAN_F12R2_FB4_Pos) /*!< 0x00000010 */
5080#define CAN_F12R2_FB4 CAN_F12R2_FB4_Msk /*!<Filter bit 4 */
5081#define CAN_F12R2_FB5_Pos (5U)
5082#define CAN_F12R2_FB5_Msk (0x1U << CAN_F12R2_FB5_Pos) /*!< 0x00000020 */
5083#define CAN_F12R2_FB5 CAN_F12R2_FB5_Msk /*!<Filter bit 5 */
5084#define CAN_F12R2_FB6_Pos (6U)
5085#define CAN_F12R2_FB6_Msk (0x1U << CAN_F12R2_FB6_Pos) /*!< 0x00000040 */
5086#define CAN_F12R2_FB6 CAN_F12R2_FB6_Msk /*!<Filter bit 6 */
5087#define CAN_F12R2_FB7_Pos (7U)
5088#define CAN_F12R2_FB7_Msk (0x1U << CAN_F12R2_FB7_Pos) /*!< 0x00000080 */
5089#define CAN_F12R2_FB7 CAN_F12R2_FB7_Msk /*!<Filter bit 7 */
5090#define CAN_F12R2_FB8_Pos (8U)
5091#define CAN_F12R2_FB8_Msk (0x1U << CAN_F12R2_FB8_Pos) /*!< 0x00000100 */
5092#define CAN_F12R2_FB8 CAN_F12R2_FB8_Msk /*!<Filter bit 8 */
5093#define CAN_F12R2_FB9_Pos (9U)
5094#define CAN_F12R2_FB9_Msk (0x1U << CAN_F12R2_FB9_Pos) /*!< 0x00000200 */
5095#define CAN_F12R2_FB9 CAN_F12R2_FB9_Msk /*!<Filter bit 9 */
5096#define CAN_F12R2_FB10_Pos (10U)
5097#define CAN_F12R2_FB10_Msk (0x1U << CAN_F12R2_FB10_Pos) /*!< 0x00000400 */
5098#define CAN_F12R2_FB10 CAN_F12R2_FB10_Msk /*!<Filter bit 10 */
5099#define CAN_F12R2_FB11_Pos (11U)
5100#define CAN_F12R2_FB11_Msk (0x1U << CAN_F12R2_FB11_Pos) /*!< 0x00000800 */
5101#define CAN_F12R2_FB11 CAN_F12R2_FB11_Msk /*!<Filter bit 11 */
5102#define CAN_F12R2_FB12_Pos (12U)
5103#define CAN_F12R2_FB12_Msk (0x1U << CAN_F12R2_FB12_Pos) /*!< 0x00001000 */
5104#define CAN_F12R2_FB12 CAN_F12R2_FB12_Msk /*!<Filter bit 12 */
5105#define CAN_F12R2_FB13_Pos (13U)
5106#define CAN_F12R2_FB13_Msk (0x1U << CAN_F12R2_FB13_Pos) /*!< 0x00002000 */
5107#define CAN_F12R2_FB13 CAN_F12R2_FB13_Msk /*!<Filter bit 13 */
5108#define CAN_F12R2_FB14_Pos (14U)
5109#define CAN_F12R2_FB14_Msk (0x1U << CAN_F12R2_FB14_Pos) /*!< 0x00004000 */
5110#define CAN_F12R2_FB14 CAN_F12R2_FB14_Msk /*!<Filter bit 14 */
5111#define CAN_F12R2_FB15_Pos (15U)
5112#define CAN_F12R2_FB15_Msk (0x1U << CAN_F12R2_FB15_Pos) /*!< 0x00008000 */
5113#define CAN_F12R2_FB15 CAN_F12R2_FB15_Msk /*!<Filter bit 15 */
5114#define CAN_F12R2_FB16_Pos (16U)
5115#define CAN_F12R2_FB16_Msk (0x1U << CAN_F12R2_FB16_Pos) /*!< 0x00010000 */
5116#define CAN_F12R2_FB16 CAN_F12R2_FB16_Msk /*!<Filter bit 16 */
5117#define CAN_F12R2_FB17_Pos (17U)
5118#define CAN_F12R2_FB17_Msk (0x1U << CAN_F12R2_FB17_Pos) /*!< 0x00020000 */
5119#define CAN_F12R2_FB17 CAN_F12R2_FB17_Msk /*!<Filter bit 17 */
5120#define CAN_F12R2_FB18_Pos (18U)
5121#define CAN_F12R2_FB18_Msk (0x1U << CAN_F12R2_FB18_Pos) /*!< 0x00040000 */
5122#define CAN_F12R2_FB18 CAN_F12R2_FB18_Msk /*!<Filter bit 18 */
5123#define CAN_F12R2_FB19_Pos (19U)
5124#define CAN_F12R2_FB19_Msk (0x1U << CAN_F12R2_FB19_Pos) /*!< 0x00080000 */
5125#define CAN_F12R2_FB19 CAN_F12R2_FB19_Msk /*!<Filter bit 19 */
5126#define CAN_F12R2_FB20_Pos (20U)
5127#define CAN_F12R2_FB20_Msk (0x1U << CAN_F12R2_FB20_Pos) /*!< 0x00100000 */
5128#define CAN_F12R2_FB20 CAN_F12R2_FB20_Msk /*!<Filter bit 20 */
5129#define CAN_F12R2_FB21_Pos (21U)
5130#define CAN_F12R2_FB21_Msk (0x1U << CAN_F12R2_FB21_Pos) /*!< 0x00200000 */
5131#define CAN_F12R2_FB21 CAN_F12R2_FB21_Msk /*!<Filter bit 21 */
5132#define CAN_F12R2_FB22_Pos (22U)
5133#define CAN_F12R2_FB22_Msk (0x1U << CAN_F12R2_FB22_Pos) /*!< 0x00400000 */
5134#define CAN_F12R2_FB22 CAN_F12R2_FB22_Msk /*!<Filter bit 22 */
5135#define CAN_F12R2_FB23_Pos (23U)
5136#define CAN_F12R2_FB23_Msk (0x1U << CAN_F12R2_FB23_Pos) /*!< 0x00800000 */
5137#define CAN_F12R2_FB23 CAN_F12R2_FB23_Msk /*!<Filter bit 23 */
5138#define CAN_F12R2_FB24_Pos (24U)
5139#define CAN_F12R2_FB24_Msk (0x1U << CAN_F12R2_FB24_Pos) /*!< 0x01000000 */
5140#define CAN_F12R2_FB24 CAN_F12R2_FB24_Msk /*!<Filter bit 24 */
5141#define CAN_F12R2_FB25_Pos (25U)
5142#define CAN_F12R2_FB25_Msk (0x1U << CAN_F12R2_FB25_Pos) /*!< 0x02000000 */
5143#define CAN_F12R2_FB25 CAN_F12R2_FB25_Msk /*!<Filter bit 25 */
5144#define CAN_F12R2_FB26_Pos (26U)
5145#define CAN_F12R2_FB26_Msk (0x1U << CAN_F12R2_FB26_Pos) /*!< 0x04000000 */
5146#define CAN_F12R2_FB26 CAN_F12R2_FB26_Msk /*!<Filter bit 26 */
5147#define CAN_F12R2_FB27_Pos (27U)
5148#define CAN_F12R2_FB27_Msk (0x1U << CAN_F12R2_FB27_Pos) /*!< 0x08000000 */
5149#define CAN_F12R2_FB27 CAN_F12R2_FB27_Msk /*!<Filter bit 27 */
5150#define CAN_F12R2_FB28_Pos (28U)
5151#define CAN_F12R2_FB28_Msk (0x1U << CAN_F12R2_FB28_Pos) /*!< 0x10000000 */
5152#define CAN_F12R2_FB28 CAN_F12R2_FB28_Msk /*!<Filter bit 28 */
5153#define CAN_F12R2_FB29_Pos (29U)
5154#define CAN_F12R2_FB29_Msk (0x1U << CAN_F12R2_FB29_Pos) /*!< 0x20000000 */
5155#define CAN_F12R2_FB29 CAN_F12R2_FB29_Msk /*!<Filter bit 29 */
5156#define CAN_F12R2_FB30_Pos (30U)
5157#define CAN_F12R2_FB30_Msk (0x1U << CAN_F12R2_FB30_Pos) /*!< 0x40000000 */
5158#define CAN_F12R2_FB30 CAN_F12R2_FB30_Msk /*!<Filter bit 30 */
5159#define CAN_F12R2_FB31_Pos (31U)
5160#define CAN_F12R2_FB31_Msk (0x1U << CAN_F12R2_FB31_Pos) /*!< 0x80000000 */
5161#define CAN_F12R2_FB31 CAN_F12R2_FB31_Msk /*!<Filter bit 31 */
5162
5163/******************* Bit definition for CAN_F13R2 register ******************/
5164#define CAN_F13R2_FB0_Pos (0U)
5165#define CAN_F13R2_FB0_Msk (0x1U << CAN_F13R2_FB0_Pos) /*!< 0x00000001 */
5166#define CAN_F13R2_FB0 CAN_F13R2_FB0_Msk /*!<Filter bit 0 */
5167#define CAN_F13R2_FB1_Pos (1U)
5168#define CAN_F13R2_FB1_Msk (0x1U << CAN_F13R2_FB1_Pos) /*!< 0x00000002 */
5169#define CAN_F13R2_FB1 CAN_F13R2_FB1_Msk /*!<Filter bit 1 */
5170#define CAN_F13R2_FB2_Pos (2U)
5171#define CAN_F13R2_FB2_Msk (0x1U << CAN_F13R2_FB2_Pos) /*!< 0x00000004 */
5172#define CAN_F13R2_FB2 CAN_F13R2_FB2_Msk /*!<Filter bit 2 */
5173#define CAN_F13R2_FB3_Pos (3U)
5174#define CAN_F13R2_FB3_Msk (0x1U << CAN_F13R2_FB3_Pos) /*!< 0x00000008 */
5175#define CAN_F13R2_FB3 CAN_F13R2_FB3_Msk /*!<Filter bit 3 */
5176#define CAN_F13R2_FB4_Pos (4U)
5177#define CAN_F13R2_FB4_Msk (0x1U << CAN_F13R2_FB4_Pos) /*!< 0x00000010 */
5178#define CAN_F13R2_FB4 CAN_F13R2_FB4_Msk /*!<Filter bit 4 */
5179#define CAN_F13R2_FB5_Pos (5U)
5180#define CAN_F13R2_FB5_Msk (0x1U << CAN_F13R2_FB5_Pos) /*!< 0x00000020 */
5181#define CAN_F13R2_FB5 CAN_F13R2_FB5_Msk /*!<Filter bit 5 */
5182#define CAN_F13R2_FB6_Pos (6U)
5183#define CAN_F13R2_FB6_Msk (0x1U << CAN_F13R2_FB6_Pos) /*!< 0x00000040 */
5184#define CAN_F13R2_FB6 CAN_F13R2_FB6_Msk /*!<Filter bit 6 */
5185#define CAN_F13R2_FB7_Pos (7U)
5186#define CAN_F13R2_FB7_Msk (0x1U << CAN_F13R2_FB7_Pos) /*!< 0x00000080 */
5187#define CAN_F13R2_FB7 CAN_F13R2_FB7_Msk /*!<Filter bit 7 */
5188#define CAN_F13R2_FB8_Pos (8U)
5189#define CAN_F13R2_FB8_Msk (0x1U << CAN_F13R2_FB8_Pos) /*!< 0x00000100 */
5190#define CAN_F13R2_FB8 CAN_F13R2_FB8_Msk /*!<Filter bit 8 */
5191#define CAN_F13R2_FB9_Pos (9U)
5192#define CAN_F13R2_FB9_Msk (0x1U << CAN_F13R2_FB9_Pos) /*!< 0x00000200 */
5193#define CAN_F13R2_FB9 CAN_F13R2_FB9_Msk /*!<Filter bit 9 */
5194#define CAN_F13R2_FB10_Pos (10U)
5195#define CAN_F13R2_FB10_Msk (0x1U << CAN_F13R2_FB10_Pos) /*!< 0x00000400 */
5196#define CAN_F13R2_FB10 CAN_F13R2_FB10_Msk /*!<Filter bit 10 */
5197#define CAN_F13R2_FB11_Pos (11U)