#![doc = "Peripheral access API for MK66F18 microcontrollers (generated using svd2rust v0.16.1)\n\nYou can find an overview of the API [here].\n\n[here]: https://docs.rs/svd2rust/0.16.1/svd2rust/#peripheral-api"]
#![deny(missing_docs)]
#![deny(warnings)]
#![allow(non_camel_case_types)]
#![no_std]
extern crate bare_metal;
extern crate cortex_m;
#[cfg(feature = "rt")]
extern crate cortex_m_rt;
extern crate vcell;
use core::marker::PhantomData;
use core::ops::Deref;
#[doc = r"Number available in the NVIC for configuring priority"]
pub const NVIC_PRIO_BITS: u8 = 4;
#[cfg(feature = "rt")]
extern "C" {
fn DMA0_DMA16();
fn DMA1_DMA17();
fn DMA2_DMA18();
fn DMA3_DMA19();
fn DMA4_DMA20();
fn DMA5_DMA21();
fn DMA6_DMA22();
fn DMA7_DMA23();
fn DMA8_DMA24();
fn DMA9_DMA25();
fn DMA10_DMA26();
fn DMA11_DMA27();
fn DMA12_DMA28();
fn DMA13_DMA29();
fn DMA14_DMA30();
fn DMA15_DMA31();
fn DMA_ERROR();
fn MCM();
fn FTFE();
fn READ_COLLISION();
fn LVD_LVW();
fn LLWU();
fn WDOG_EWM();
fn RNG();
fn I2C0();
fn I2C1();
fn SPI0();
fn SPI1();
fn I2S0_TX();
fn I2S0_RX();
fn UART0_RX_TX();
fn UART0_ERR();
fn UART1_RX_TX();
fn UART1_ERR();
fn UART2_RX_TX();
fn UART2_ERR();
fn UART3_RX_TX();
fn UART3_ERR();
fn ADC0();
fn CMP0();
fn CMP1();
fn FTM0();
fn FTM1();
fn FTM2();
fn CMT();
fn RTC();
fn RTC_SECONDS();
fn PIT0();
fn PIT1();
fn PIT2();
fn PIT3();
fn PDB0();
fn USB0();
fn USBDCD();
fn DAC0();
fn LPTMR0();
fn PORTA();
fn PORTB();
fn PORTC();
fn PORTD();
fn PORTE();
fn SPI2();
fn UART4_RX_TX();
fn UART4_ERR();
fn CMP2();
fn FTM3();
fn DAC1();
fn ADC1();
fn I2C2();
fn CAN0_ORED_MESSAGE_BUFFER();
fn CAN0_BUS_OFF();
fn CAN0_ERROR();
fn CAN0_TX_WARNING();
fn CAN0_RX_WARNING();
fn CAN0_WAKE_UP();
fn SDHC();
fn ENET_1588_TIMER();
fn ENET_TRANSMIT();
fn ENET_RECEIVE();
fn ENET_ERROR();
fn LPUART0();
fn TSI0();
fn TPM1();
fn TPM2();
fn USBHSDCD();
fn I2C3();
fn CMP3();
fn USBHS();
fn CAN1_ORED_MESSAGE_BUFFER();
fn CAN1_BUS_OFF();
fn CAN1_ERROR();
fn CAN1_TX_WARNING();
fn CAN1_RX_WARNING();
fn CAN1_WAKE_UP();
}
#[doc(hidden)]
pub union Vector {
_handler: unsafe extern "C" fn(),
_reserved: u32,
}
#[cfg(feature = "rt")]
#[doc(hidden)]
#[link_section = ".vector_table.interrupts"]
#[no_mangle]
pub static __INTERRUPTS: [Vector; 100] = [
Vector {
_handler: DMA0_DMA16,
},
Vector {
_handler: DMA1_DMA17,
},
Vector {
_handler: DMA2_DMA18,
},
Vector {
_handler: DMA3_DMA19,
},
Vector {
_handler: DMA4_DMA20,
},
Vector {
_handler: DMA5_DMA21,
},
Vector {
_handler: DMA6_DMA22,
},
Vector {
_handler: DMA7_DMA23,
},
Vector {
_handler: DMA8_DMA24,
},
Vector {
_handler: DMA9_DMA25,
},
Vector {
_handler: DMA10_DMA26,
},
Vector {
_handler: DMA11_DMA27,
},
Vector {
_handler: DMA12_DMA28,
},
Vector {
_handler: DMA13_DMA29,
},
Vector {
_handler: DMA14_DMA30,
},
Vector {
_handler: DMA15_DMA31,
},
Vector {
_handler: DMA_ERROR,
},
Vector { _handler: MCM },
Vector { _handler: FTFE },
Vector {
_handler: READ_COLLISION,
},
Vector { _handler: LVD_LVW },
Vector { _handler: LLWU },
Vector { _handler: WDOG_EWM },
Vector { _handler: RNG },
Vector { _handler: I2C0 },
Vector { _handler: I2C1 },
Vector { _handler: SPI0 },
Vector { _handler: SPI1 },
Vector { _handler: I2S0_TX },
Vector { _handler: I2S0_RX },
Vector { _reserved: 0 },
Vector {
_handler: UART0_RX_TX,
},
Vector {
_handler: UART0_ERR,
},
Vector {
_handler: UART1_RX_TX,
},
Vector {
_handler: UART1_ERR,
},
Vector {
_handler: UART2_RX_TX,
},
Vector {
_handler: UART2_ERR,
},
Vector {
_handler: UART3_RX_TX,
},
Vector {
_handler: UART3_ERR,
},
Vector { _handler: ADC0 },
Vector { _handler: CMP0 },
Vector { _handler: CMP1 },
Vector { _handler: FTM0 },
Vector { _handler: FTM1 },
Vector { _handler: FTM2 },
Vector { _handler: CMT },
Vector { _handler: RTC },
Vector {
_handler: RTC_SECONDS,
},
Vector { _handler: PIT0 },
Vector { _handler: PIT1 },
Vector { _handler: PIT2 },
Vector { _handler: PIT3 },
Vector { _handler: PDB0 },
Vector { _handler: USB0 },
Vector { _handler: USBDCD },
Vector { _reserved: 0 },
Vector { _handler: DAC0 },
Vector { _reserved: 0 },
Vector { _handler: LPTMR0 },
Vector { _handler: PORTA },
Vector { _handler: PORTB },
Vector { _handler: PORTC },
Vector { _handler: PORTD },
Vector { _handler: PORTE },
Vector { _reserved: 0 },
Vector { _handler: SPI2 },
Vector {
_handler: UART4_RX_TX,
},
Vector {
_handler: UART4_ERR,
},
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _handler: CMP2 },
Vector { _handler: FTM3 },
Vector { _handler: DAC1 },
Vector { _handler: ADC1 },
Vector { _handler: I2C2 },
Vector {
_handler: CAN0_ORED_MESSAGE_BUFFER,
},
Vector {
_handler: CAN0_BUS_OFF,
},
Vector {
_handler: CAN0_ERROR,
},
Vector {
_handler: CAN0_TX_WARNING,
},
Vector {
_handler: CAN0_RX_WARNING,
},
Vector {
_handler: CAN0_WAKE_UP,
},
Vector { _handler: SDHC },
Vector {
_handler: ENET_1588_TIMER,
},
Vector {
_handler: ENET_TRANSMIT,
},
Vector {
_handler: ENET_RECEIVE,
},
Vector {
_handler: ENET_ERROR,
},
Vector { _handler: LPUART0 },
Vector { _handler: TSI0 },
Vector { _handler: TPM1 },
Vector { _handler: TPM2 },
Vector { _handler: USBHSDCD },
Vector { _handler: I2C3 },
Vector { _handler: CMP3 },
Vector { _handler: USBHS },
Vector {
_handler: CAN1_ORED_MESSAGE_BUFFER,
},
Vector {
_handler: CAN1_BUS_OFF,
},
Vector {
_handler: CAN1_ERROR,
},
Vector {
_handler: CAN1_TX_WARNING,
},
Vector {
_handler: CAN1_RX_WARNING,
},
Vector {
_handler: CAN1_WAKE_UP,
},
];
#[doc = r"Enumeration of all the interrupts"]
#[derive(Copy, Clone, Debug)]
pub enum Interrupt {
#[doc = "0 - DMA0_DMA16"]
DMA0_DMA16,
#[doc = "1 - DMA1_DMA17"]
DMA1_DMA17,
#[doc = "2 - DMA2_DMA18"]
DMA2_DMA18,
#[doc = "3 - DMA3_DMA19"]
DMA3_DMA19,
#[doc = "4 - DMA4_DMA20"]
DMA4_DMA20,
#[doc = "5 - DMA5_DMA21"]
DMA5_DMA21,
#[doc = "6 - DMA6_DMA22"]
DMA6_DMA22,
#[doc = "7 - DMA7_DMA23"]
DMA7_DMA23,
#[doc = "8 - DMA8_DMA24"]
DMA8_DMA24,
#[doc = "9 - DMA9_DMA25"]
DMA9_DMA25,
#[doc = "10 - DMA10_DMA26"]
DMA10_DMA26,
#[doc = "11 - DMA11_DMA27"]
DMA11_DMA27,
#[doc = "12 - DMA12_DMA28"]
DMA12_DMA28,
#[doc = "13 - DMA13_DMA29"]
DMA13_DMA29,
#[doc = "14 - DMA14_DMA30"]
DMA14_DMA30,
#[doc = "15 - DMA15_DMA31"]
DMA15_DMA31,
#[doc = "16 - DMA_Error"]
DMA_ERROR,
#[doc = "17 - MCM"]
MCM,
#[doc = "18 - FTFE"]
FTFE,
#[doc = "19 - Read_Collision"]
READ_COLLISION,
#[doc = "20 - LVD_LVW"]
LVD_LVW,
#[doc = "21 - LLWU"]
LLWU,
#[doc = "22 - WDOG_EWM"]
WDOG_EWM,
#[doc = "23 - RNG"]
RNG,
#[doc = "24 - I2C0"]
I2C0,
#[doc = "25 - I2C1"]
I2C1,
#[doc = "26 - SPI0"]
SPI0,
#[doc = "27 - SPI1"]
SPI1,
#[doc = "28 - I2S0_Tx"]
I2S0_TX,
#[doc = "29 - I2S0_Rx"]
I2S0_RX,
#[doc = "31 - UART0_RX_TX"]
UART0_RX_TX,
#[doc = "32 - UART0_ERR"]
UART0_ERR,
#[doc = "33 - UART1_RX_TX"]
UART1_RX_TX,
#[doc = "34 - UART1_ERR"]
UART1_ERR,
#[doc = "35 - UART2_RX_TX"]
UART2_RX_TX,
#[doc = "36 - UART2_ERR"]
UART2_ERR,
#[doc = "37 - UART3_RX_TX"]
UART3_RX_TX,
#[doc = "38 - UART3_ERR"]
UART3_ERR,
#[doc = "39 - ADC0"]
ADC0,
#[doc = "40 - CMP0"]
CMP0,
#[doc = "41 - CMP1"]
CMP1,
#[doc = "42 - FTM0"]
FTM0,
#[doc = "43 - FTM1"]
FTM1,
#[doc = "44 - FTM2"]
FTM2,
#[doc = "45 - CMT"]
CMT,
#[doc = "46 - RTC"]
RTC,
#[doc = "47 - RTC_Seconds"]
RTC_SECONDS,
#[doc = "48 - PIT0"]
PIT0,
#[doc = "49 - PIT1"]
PIT1,
#[doc = "50 - PIT2"]
PIT2,
#[doc = "51 - PIT3"]
PIT3,
#[doc = "52 - PDB0"]
PDB0,
#[doc = "53 - USB0"]
USB0,
#[doc = "54 - USBDCD"]
USBDCD,
#[doc = "56 - DAC0"]
DAC0,
#[doc = "58 - LPTMR0"]
LPTMR0,
#[doc = "59 - PORTA"]
PORTA,
#[doc = "60 - PORTB"]
PORTB,
#[doc = "61 - PORTC"]
PORTC,
#[doc = "62 - PORTD"]
PORTD,
#[doc = "63 - PORTE"]
PORTE,
#[doc = "65 - SPI2"]
SPI2,
#[doc = "66 - UART4_RX_TX"]
UART4_RX_TX,
#[doc = "67 - UART4_ERR"]
UART4_ERR,
#[doc = "70 - CMP2"]
CMP2,
#[doc = "71 - FTM3"]
FTM3,
#[doc = "72 - DAC1"]
DAC1,
#[doc = "73 - ADC1"]
ADC1,
#[doc = "74 - I2C2"]
I2C2,
#[doc = "75 - CAN0_ORed_Message_buffer"]
CAN0_ORED_MESSAGE_BUFFER,
#[doc = "76 - CAN0_Bus_Off"]
CAN0_BUS_OFF,
#[doc = "77 - CAN0_Error"]
CAN0_ERROR,
#[doc = "78 - CAN0_Tx_Warning"]
CAN0_TX_WARNING,
#[doc = "79 - CAN0_Rx_Warning"]
CAN0_RX_WARNING,
#[doc = "80 - CAN0_Wake_Up"]
CAN0_WAKE_UP,
#[doc = "81 - SDHC"]
SDHC,
#[doc = "82 - ENET_1588_Timer"]
ENET_1588_TIMER,
#[doc = "83 - ENET_Transmit"]
ENET_TRANSMIT,
#[doc = "84 - ENET_Receive"]
ENET_RECEIVE,
#[doc = "85 - ENET_Error"]
ENET_ERROR,
#[doc = "86 - LPUART0"]
LPUART0,
#[doc = "87 - TSI0"]
TSI0,
#[doc = "88 - TPM1"]
TPM1,
#[doc = "89 - TPM2"]
TPM2,
#[doc = "90 - USBHSDCD"]
USBHSDCD,
#[doc = "91 - I2C3"]
I2C3,
#[doc = "92 - CMP3"]
CMP3,
#[doc = "93 - USBHS"]
USBHS,
#[doc = "94 - CAN1_ORed_Message_buffer"]
CAN1_ORED_MESSAGE_BUFFER,
#[doc = "95 - CAN1_Bus_Off"]
CAN1_BUS_OFF,
#[doc = "96 - CAN1_Error"]
CAN1_ERROR,
#[doc = "97 - CAN1_Tx_Warning"]
CAN1_TX_WARNING,
#[doc = "98 - CAN1_Rx_Warning"]
CAN1_RX_WARNING,
#[doc = "99 - CAN1_Wake_Up"]
CAN1_WAKE_UP,
}
unsafe impl bare_metal::Nr for Interrupt {
#[inline]
fn nr(&self) -> u8 {
match *self {
Interrupt::DMA0_DMA16 => 0,
Interrupt::DMA1_DMA17 => 1,
Interrupt::DMA2_DMA18 => 2,
Interrupt::DMA3_DMA19 => 3,
Interrupt::DMA4_DMA20 => 4,
Interrupt::DMA5_DMA21 => 5,
Interrupt::DMA6_DMA22 => 6,
Interrupt::DMA7_DMA23 => 7,
Interrupt::DMA8_DMA24 => 8,
Interrupt::DMA9_DMA25 => 9,
Interrupt::DMA10_DMA26 => 10,
Interrupt::DMA11_DMA27 => 11,
Interrupt::DMA12_DMA28 => 12,
Interrupt::DMA13_DMA29 => 13,
Interrupt::DMA14_DMA30 => 14,
Interrupt::DMA15_DMA31 => 15,
Interrupt::DMA_ERROR => 16,
Interrupt::MCM => 17,
Interrupt::FTFE => 18,
Interrupt::READ_COLLISION => 19,
Interrupt::LVD_LVW => 20,
Interrupt::LLWU => 21,
Interrupt::WDOG_EWM => 22,
Interrupt::RNG => 23,
Interrupt::I2C0 => 24,
Interrupt::I2C1 => 25,
Interrupt::SPI0 => 26,
Interrupt::SPI1 => 27,
Interrupt::I2S0_TX => 28,
Interrupt::I2S0_RX => 29,
Interrupt::UART0_RX_TX => 31,
Interrupt::UART0_ERR => 32,
Interrupt::UART1_RX_TX => 33,
Interrupt::UART1_ERR => 34,
Interrupt::UART2_RX_TX => 35,
Interrupt::UART2_ERR => 36,
Interrupt::UART3_RX_TX => 37,
Interrupt::UART3_ERR => 38,
Interrupt::ADC0 => 39,
Interrupt::CMP0 => 40,
Interrupt::CMP1 => 41,
Interrupt::FTM0 => 42,
Interrupt::FTM1 => 43,
Interrupt::FTM2 => 44,
Interrupt::CMT => 45,
Interrupt::RTC => 46,
Interrupt::RTC_SECONDS => 47,
Interrupt::PIT0 => 48,
Interrupt::PIT1 => 49,
Interrupt::PIT2 => 50,
Interrupt::PIT3 => 51,
Interrupt::PDB0 => 52,
Interrupt::USB0 => 53,
Interrupt::USBDCD => 54,
Interrupt::DAC0 => 56,
Interrupt::LPTMR0 => 58,
Interrupt::PORTA => 59,
Interrupt::PORTB => 60,
Interrupt::PORTC => 61,
Interrupt::PORTD => 62,
Interrupt::PORTE => 63,
Interrupt::SPI2 => 65,
Interrupt::UART4_RX_TX => 66,
Interrupt::UART4_ERR => 67,
Interrupt::CMP2 => 70,
Interrupt::FTM3 => 71,
Interrupt::DAC1 => 72,
Interrupt::ADC1 => 73,
Interrupt::I2C2 => 74,
Interrupt::CAN0_ORED_MESSAGE_BUFFER => 75,
Interrupt::CAN0_BUS_OFF => 76,
Interrupt::CAN0_ERROR => 77,
Interrupt::CAN0_TX_WARNING => 78,
Interrupt::CAN0_RX_WARNING => 79,
Interrupt::CAN0_WAKE_UP => 80,
Interrupt::SDHC => 81,
Interrupt::ENET_1588_TIMER => 82,
Interrupt::ENET_TRANSMIT => 83,
Interrupt::ENET_RECEIVE => 84,
Interrupt::ENET_ERROR => 85,
Interrupt::LPUART0 => 86,
Interrupt::TSI0 => 87,
Interrupt::TPM1 => 88,
Interrupt::TPM2 => 89,
Interrupt::USBHSDCD => 90,
Interrupt::I2C3 => 91,
Interrupt::CMP3 => 92,
Interrupt::USBHS => 93,
Interrupt::CAN1_ORED_MESSAGE_BUFFER => 94,
Interrupt::CAN1_BUS_OFF => 95,
Interrupt::CAN1_ERROR => 96,
Interrupt::CAN1_TX_WARNING => 97,
Interrupt::CAN1_RX_WARNING => 98,
Interrupt::CAN1_WAKE_UP => 99,
}
}
}
#[cfg(feature = "rt")]
pub use self::Interrupt as interrupt;
pub use cortex_m::peripheral::Peripherals as CorePeripherals;
pub use cortex_m::peripheral::{CBP, CPUID, DCB, DWT, FPB, FPU, ITM, MPU, NVIC, SCB, SYST, TPIU};
#[cfg(feature = "rt")]
pub use cortex_m_rt::interrupt;
#[allow(unused_imports)]
use generic::*;
#[doc = r"Common register and bit access and modify traits"]
pub mod generic;
#[doc = "Flash configuration field"]
pub struct FTFE_FLASHCONFIG {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for FTFE_FLASHCONFIG {}
impl FTFE_FLASHCONFIG {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const ftfe_flash_config::RegisterBlock {
0x0400 as *const _
}
}
impl Deref for FTFE_FLASHCONFIG {
type Target = ftfe_flash_config::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*FTFE_FLASHCONFIG::ptr() }
}
}
#[doc = "Flash configuration field"]
pub mod ftfe_flash_config;
#[doc = "AIPS-Lite Bridge"]
pub struct AIPS0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for AIPS0 {}
impl AIPS0 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const aips0::RegisterBlock {
0x4000_0000 as *const _
}
}
impl Deref for AIPS0 {
type Target = aips0::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*AIPS0::ptr() }
}
}
#[doc = "AIPS-Lite Bridge"]
pub mod aips0;
#[doc = "AIPS-Lite Bridge"]
pub struct AIPS1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for AIPS1 {}
impl AIPS1 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const aips1::RegisterBlock {
0x4008_0000 as *const _
}
}
impl Deref for AIPS1 {
type Target = aips1::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*AIPS1::ptr() }
}
}
#[doc = "AIPS-Lite Bridge"]
pub mod aips1;
#[doc = "Crossbar switch"]
pub struct AXBS {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for AXBS {}
impl AXBS {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const axbs::RegisterBlock {
0x4000_4000 as *const _
}
}
impl Deref for AXBS {
type Target = axbs::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*AXBS::ptr() }
}
}
#[doc = "Crossbar switch"]
pub mod axbs;
#[doc = "Enhanced direct memory access controller"]
pub struct DMA {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for DMA {}
impl DMA {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const dma::RegisterBlock {
0x4000_8000 as *const _
}
}
impl Deref for DMA {
type Target = dma::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*DMA::ptr() }
}
}
#[doc = "Enhanced direct memory access controller"]
pub mod dma;
#[doc = "FlexBus external bus interface"]
pub struct FB {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for FB {}
impl FB {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const fb::RegisterBlock {
0x4000_c000 as *const _
}
}
impl Deref for FB {
type Target = fb::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*FB::ptr() }
}
}
#[doc = "FlexBus external bus interface"]
pub mod fb;
#[doc = "Memory protection unit"]
pub struct SYSMPU {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SYSMPU {}
impl SYSMPU {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const sysmpu::RegisterBlock {
0x4000_d000 as *const _
}
}
impl Deref for SYSMPU {
type Target = sysmpu::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*SYSMPU::ptr() }
}
}
#[doc = "Memory protection unit"]
pub mod sysmpu;
#[doc = "Synchronous DRAM Controller"]
pub struct SDRAM {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SDRAM {}
impl SDRAM {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const sdram::RegisterBlock {
0x4000_f000 as *const _
}
}
impl Deref for SDRAM {
type Target = sdram::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*SDRAM::ptr() }
}
}
#[doc = "Synchronous DRAM Controller"]
pub mod sdram;
#[doc = "Flash Memory Controller-greg"]
pub struct FMC {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for FMC {}
impl FMC {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const fmc::RegisterBlock {
0x4001_f000 as *const _
}
}
impl Deref for FMC {
type Target = fmc::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*FMC::ptr() }
}
}
#[doc = "Flash Memory Controller-greg"]
pub mod fmc;
#[doc = "Flash Memory Interface"]
pub struct FTFE {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for FTFE {}
impl FTFE {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const ftfe::RegisterBlock {
0x4002_0000 as *const _
}
}
impl Deref for FTFE {
type Target = ftfe::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*FTFE::ptr() }
}
}
#[doc = "Flash Memory Interface"]
pub mod ftfe;
#[doc = "DMA channel multiplexor"]
pub struct DMAMUX {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for DMAMUX {}
impl DMAMUX {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const dmamux::RegisterBlock {
0x4002_1000 as *const _
}
}
impl Deref for DMAMUX {
type Target = dmamux::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*DMAMUX::ptr() }
}
}
#[doc = "DMA channel multiplexor"]
pub mod dmamux;
#[doc = "Flex Controller Area Network module"]
pub struct CAN0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for CAN0 {}
impl CAN0 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const can0::RegisterBlock {
0x4002_4000 as *const _
}
}
impl Deref for CAN0 {
type Target = can0::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*CAN0::ptr() }
}
}
#[doc = "Flex Controller Area Network module"]
pub mod can0;
#[doc = "Flex Controller Area Network module"]
pub struct CAN1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for CAN1 {}
impl CAN1 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const can1::RegisterBlock {
0x400a_4000 as *const _
}
}
impl Deref for CAN1 {
type Target = can1::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*CAN1::ptr() }
}
}
#[doc = "Flex Controller Area Network module"]
pub mod can1;
#[doc = "Serial Peripheral Interface"]
pub struct SPI0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SPI0 {}
impl SPI0 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const spi0::RegisterBlock {
0x4002_c000 as *const _
}
}
impl Deref for SPI0 {
type Target = spi0::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*SPI0::ptr() }
}
}
#[doc = "Serial Peripheral Interface"]
pub mod spi0;
#[doc = "Serial Peripheral Interface"]
pub struct SPI1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SPI1 {}
impl SPI1 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const spi1::RegisterBlock {
0x4002_d000 as *const _
}
}
impl Deref for SPI1 {
type Target = spi1::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*SPI1::ptr() }
}
}
#[doc = "Serial Peripheral Interface"]
pub mod spi1;
#[doc = "Serial Peripheral Interface"]
pub struct SPI2 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SPI2 {}
impl SPI2 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const spi2::RegisterBlock {
0x400a_c000 as *const _
}
}
impl Deref for SPI2 {
type Target = spi2::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*SPI2::ptr() }
}
}
#[doc = "Serial Peripheral Interface"]
pub mod spi2;
#[doc = "Inter-IC Sound / Synchronous Audio Interface"]
pub struct I2S0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for I2S0 {}
impl I2S0 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const i2s0::RegisterBlock {
0x4002_f000 as *const _
}
}
impl Deref for I2S0 {
type Target = i2s0::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*I2S0::ptr() }
}
}
#[doc = "Inter-IC Sound / Synchronous Audio Interface"]
pub mod i2s0;
#[doc = "Cyclic Redundancy Check"]
pub struct CRC {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for CRC {}
impl CRC {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const crc::RegisterBlock {
0x4003_2000 as *const _
}
}
impl Deref for CRC {
type Target = crc::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*CRC::ptr() }
}
}
#[doc = "Cyclic Redundancy Check"]
pub mod crc;
#[doc = "USB Device Charger Detection module"]
pub struct USBDCD {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for USBDCD {}
impl USBDCD {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const usbdcd::RegisterBlock {
0x4003_5000 as *const _
}
}
impl Deref for USBDCD {
type Target = usbdcd::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*USBDCD::ptr() }
}
}
#[doc = "USB Device Charger Detection module"]
pub mod usbdcd;
#[doc = "Programmable Delay Block"]
pub struct PDB0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PDB0 {}
impl PDB0 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const pdb0::RegisterBlock {
0x4003_6000 as *const _
}
}
impl Deref for PDB0 {
type Target = pdb0::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*PDB0::ptr() }
}
}
#[doc = "Programmable Delay Block"]
pub mod pdb0;
#[doc = "Periodic Interrupt Timer"]
pub struct PIT {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PIT {}
impl PIT {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const pit::RegisterBlock {
0x4003_7000 as *const _
}
}
impl Deref for PIT {
type Target = pit::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*PIT::ptr() }
}
}
#[doc = "Periodic Interrupt Timer"]
pub mod pit;
#[doc = "FlexTimer Module"]
pub struct FTM0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for FTM0 {}
impl FTM0 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const ftm0::RegisterBlock {
0x4003_8000 as *const _
}
}
impl Deref for FTM0 {
type Target = ftm0::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*FTM0::ptr() }
}
}
#[doc = "FlexTimer Module"]
pub mod ftm0;
#[doc = "FlexTimer Module"]
pub struct FTM1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for FTM1 {}
impl FTM1 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const ftm1::RegisterBlock {
0x4003_9000 as *const _
}
}
impl Deref for FTM1 {
type Target = ftm1::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*FTM1::ptr() }
}
}
#[doc = "FlexTimer Module"]
pub mod ftm1;
#[doc = "FlexTimer Module"]
pub struct FTM2 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for FTM2 {}
impl FTM2 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const ftm2::RegisterBlock {
0x4003_a000 as *const _
}
}
impl Deref for FTM2 {
type Target = ftm2::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*FTM2::ptr() }
}
}
#[doc = "FlexTimer Module"]
pub mod ftm2;
#[doc = "FlexTimer Module"]
pub struct FTM3 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for FTM3 {}
impl FTM3 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const ftm3::RegisterBlock {
0x400b_9000 as *const _
}
}
impl Deref for FTM3 {
type Target = ftm3::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*FTM3::ptr() }
}
}
#[doc = "FlexTimer Module"]
pub mod ftm3;
#[doc = "Analog-to-Digital Converter"]
pub struct ADC0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for ADC0 {}
impl ADC0 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const adc0::RegisterBlock {
0x4003_b000 as *const _
}
}
impl Deref for ADC0 {
type Target = adc0::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*ADC0::ptr() }
}
}
#[doc = "Analog-to-Digital Converter"]
pub mod adc0;
#[doc = "Analog-to-Digital Converter"]
pub struct ADC1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for ADC1 {}
impl ADC1 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const adc1::RegisterBlock {
0x400b_b000 as *const _
}
}
impl Deref for ADC1 {
type Target = adc1::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*ADC1::ptr() }
}
}
#[doc = "Analog-to-Digital Converter"]
pub mod adc1;
#[doc = "Secure Real Time Clock"]
pub struct RTC {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for RTC {}
impl RTC {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const rtc::RegisterBlock {
0x4003_d000 as *const _
}
}
impl Deref for RTC {
type Target = rtc::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*RTC::ptr() }
}
}
#[doc = "Secure Real Time Clock"]
pub mod rtc;
#[doc = "VBAT register file"]
pub struct RFVBAT {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for RFVBAT {}
impl RFVBAT {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const rfvbat::RegisterBlock {
0x4003_e000 as *const _
}
}
impl Deref for RFVBAT {
type Target = rfvbat::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*RFVBAT::ptr() }
}
}
#[doc = "VBAT register file"]
pub mod rfvbat;
#[doc = "Low Power Timer"]
pub struct LPTMR0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for LPTMR0 {}
impl LPTMR0 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const lptmr0::RegisterBlock {
0x4004_0000 as *const _
}
}
impl Deref for LPTMR0 {
type Target = lptmr0::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*LPTMR0::ptr() }
}
}
#[doc = "Low Power Timer"]
pub mod lptmr0;
#[doc = "System register file"]
pub struct RFSYS {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for RFSYS {}
impl RFSYS {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const rfsys::RegisterBlock {
0x4004_1000 as *const _
}
}
impl Deref for RFSYS {
type Target = rfsys::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*RFSYS::ptr() }
}
}
#[doc = "System register file"]
pub mod rfsys;
#[doc = "Touch sense input"]
pub struct TSI0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for TSI0 {}
impl TSI0 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const tsi0::RegisterBlock {
0x4004_5000 as *const _
}
}
impl Deref for TSI0 {
type Target = tsi0::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*TSI0::ptr() }
}
}
#[doc = "Touch sense input"]
pub mod tsi0;
#[doc = "System Integration Module"]
pub struct SIM {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SIM {}
impl SIM {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const sim::RegisterBlock {
0x4004_7000 as *const _
}
}
impl Deref for SIM {
type Target = sim::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*SIM::ptr() }
}
}
#[doc = "System Integration Module"]
pub mod sim;
#[doc = "Pin Control and Interrupts"]
pub struct PORTA {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PORTA {}
impl PORTA {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const porta::RegisterBlock {
0x4004_9000 as *const _
}
}
impl Deref for PORTA {
type Target = porta::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*PORTA::ptr() }
}
}
#[doc = "Pin Control and Interrupts"]
pub mod porta;
#[doc = "Pin Control and Interrupts"]
pub struct PORTB {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PORTB {}
impl PORTB {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const portb::RegisterBlock {
0x4004_a000 as *const _
}
}
impl Deref for PORTB {
type Target = portb::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*PORTB::ptr() }
}
}
#[doc = "Pin Control and Interrupts"]
pub mod portb;
#[doc = "Pin Control and Interrupts"]
pub struct PORTC {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PORTC {}
impl PORTC {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const portc::RegisterBlock {
0x4004_b000 as *const _
}
}
impl Deref for PORTC {
type Target = portc::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*PORTC::ptr() }
}
}
#[doc = "Pin Control and Interrupts"]
pub mod portc;
#[doc = "Pin Control and Interrupts"]
pub struct PORTD {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PORTD {}
impl PORTD {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const portd::RegisterBlock {
0x4004_c000 as *const _
}
}
impl Deref for PORTD {
type Target = portd::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*PORTD::ptr() }
}
}
#[doc = "Pin Control and Interrupts"]
pub mod portd;
#[doc = "Pin Control and Interrupts"]
pub struct PORTE {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PORTE {}
impl PORTE {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const porte::RegisterBlock {
0x4004_d000 as *const _
}
}
impl Deref for PORTE {
type Target = porte::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*PORTE::ptr() }
}
}
#[doc = "Pin Control and Interrupts"]
pub mod porte;
#[doc = "Generation 2008 Watchdog Timer"]
pub struct WDOG {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for WDOG {}
impl WDOG {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const wdog::RegisterBlock {
0x4005_2000 as *const _
}
}
impl Deref for WDOG {
type Target = wdog::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*WDOG::ptr() }
}
}
#[doc = "Generation 2008 Watchdog Timer"]
pub mod wdog;
#[doc = "External Watchdog Monitor"]
pub struct EWM {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for EWM {}
impl EWM {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const ewm::RegisterBlock {
0x4006_1000 as *const _
}
}
impl Deref for EWM {
type Target = ewm::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*EWM::ptr() }
}
}
#[doc = "External Watchdog Monitor"]
pub mod ewm;
#[doc = "Carrier Modulator Transmitter"]
pub struct CMT {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for CMT {}
impl CMT {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const cmt::RegisterBlock {
0x4006_2000 as *const _
}
}
impl Deref for CMT {
type Target = cmt::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*CMT::ptr() }
}
}
#[doc = "Carrier Modulator Transmitter"]
pub mod cmt;
#[doc = "Multipurpose Clock Generator module"]
pub struct MCG {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for MCG {}
impl MCG {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const mcg::RegisterBlock {
0x4006_4000 as *const _
}
}
impl Deref for MCG {
type Target = mcg::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*MCG::ptr() }
}
}
#[doc = "Multipurpose Clock Generator module"]
pub mod mcg;
#[doc = "Oscillator"]
pub struct OSC {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for OSC {}
impl OSC {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const osc::RegisterBlock {
0x4006_5000 as *const _
}
}
impl Deref for OSC {
type Target = osc::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*OSC::ptr() }
}
}
#[doc = "Oscillator"]
pub mod osc;
#[doc = "Inter-Integrated Circuit"]
pub struct I2C0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for I2C0 {}
impl I2C0 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const i2c0::RegisterBlock {
0x4006_6000 as *const _
}
}
impl Deref for I2C0 {
type Target = i2c0::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*I2C0::ptr() }
}
}
#[doc = "Inter-Integrated Circuit"]
pub mod i2c0;
#[doc = "Inter-Integrated Circuit"]
pub struct I2C1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for I2C1 {}
impl I2C1 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const i2c1::RegisterBlock {
0x4006_7000 as *const _
}
}
impl Deref for I2C1 {
type Target = i2c1::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*I2C1::ptr() }
}
}
#[doc = "Inter-Integrated Circuit"]
pub mod i2c1;
#[doc = "Inter-Integrated Circuit"]
pub struct I2C2 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for I2C2 {}
impl I2C2 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const i2c2::RegisterBlock {
0x400e_6000 as *const _
}
}
impl Deref for I2C2 {
type Target = i2c2::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*I2C2::ptr() }
}
}
#[doc = "Inter-Integrated Circuit"]
pub mod i2c2;
#[doc = "Inter-Integrated Circuit"]
pub struct I2C3 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for I2C3 {}
impl I2C3 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const i2c3::RegisterBlock {
0x400e_7000 as *const _
}
}
impl Deref for I2C3 {
type Target = i2c3::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*I2C3::ptr() }
}
}
#[doc = "Inter-Integrated Circuit"]
pub mod i2c3;
#[doc = "Serial Communication Interface"]
pub struct UART0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for UART0 {}
impl UART0 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const uart0::RegisterBlock {
0x4006_a000 as *const _
}
}
impl Deref for UART0 {
type Target = uart0::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*UART0::ptr() }
}
}
#[doc = "Serial Communication Interface"]
pub mod uart0;
#[doc = "Serial Communication Interface"]
pub struct UART1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for UART1 {}
impl UART1 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const uart1::RegisterBlock {
0x4006_b000 as *const _
}
}
impl Deref for UART1 {
type Target = uart1::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*UART1::ptr() }
}
}
#[doc = "Serial Communication Interface"]
pub mod uart1;
#[doc = "Serial Communication Interface"]
pub struct UART2 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for UART2 {}
impl UART2 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const uart2::RegisterBlock {
0x4006_c000 as *const _
}
}
impl Deref for UART2 {
type Target = uart2::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*UART2::ptr() }
}
}
#[doc = "Serial Communication Interface"]
pub mod uart2;
#[doc = "Serial Communication Interface"]
pub struct UART3 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for UART3 {}
impl UART3 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const uart3::RegisterBlock {
0x4006_d000 as *const _
}
}
impl Deref for UART3 {
type Target = uart3::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*UART3::ptr() }
}
}
#[doc = "Serial Communication Interface"]
pub mod uart3;
#[doc = "Serial Communication Interface"]
pub struct UART4 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for UART4 {}
impl UART4 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const uart4::RegisterBlock {
0x400e_a000 as *const _
}
}
impl Deref for UART4 {
type Target = uart4::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*UART4::ptr() }
}
}
#[doc = "Serial Communication Interface"]
pub mod uart4;
#[doc = "Universal Serial Bus, OTG Capable Controller"]
pub struct USB0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for USB0 {}
impl USB0 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const usb0::RegisterBlock {
0x4007_2000 as *const _
}
}
impl Deref for USB0 {
type Target = usb0::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*USB0::ptr() }
}
}
#[doc = "Universal Serial Bus, OTG Capable Controller"]
pub mod usb0;
#[doc = "High-Speed Comparator (CMP), Voltage Reference (VREF) Digital-to-Analog Converter (DAC), and Analog Mux (ANMUX)"]
pub struct CMP0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for CMP0 {}
impl CMP0 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const cmp0::RegisterBlock {
0x4007_3000 as *const _
}
}
impl Deref for CMP0 {
type Target = cmp0::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*CMP0::ptr() }
}
}
#[doc = "High-Speed Comparator (CMP), Voltage Reference (VREF) Digital-to-Analog Converter (DAC), and Analog Mux (ANMUX)"]
pub mod cmp0;
#[doc = "High-Speed Comparator (CMP), Voltage Reference (VREF) Digital-to-Analog Converter (DAC), and Analog Mux (ANMUX)"]
pub struct CMP1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for CMP1 {}
impl CMP1 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const cmp1::RegisterBlock {
0x4007_3008 as *const _
}
}
impl Deref for CMP1 {
type Target = cmp1::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*CMP1::ptr() }
}
}
#[doc = "High-Speed Comparator (CMP), Voltage Reference (VREF) Digital-to-Analog Converter (DAC), and Analog Mux (ANMUX)"]
pub mod cmp1;
#[doc = "High-Speed Comparator (CMP), Voltage Reference (VREF) Digital-to-Analog Converter (DAC), and Analog Mux (ANMUX)"]
pub struct CMP2 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for CMP2 {}
impl CMP2 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const cmp2::RegisterBlock {
0x4007_3010 as *const _
}
}
impl Deref for CMP2 {
type Target = cmp2::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*CMP2::ptr() }
}
}
#[doc = "High-Speed Comparator (CMP), Voltage Reference (VREF) Digital-to-Analog Converter (DAC), and Analog Mux (ANMUX)"]
pub mod cmp2;
#[doc = "High-Speed Comparator (CMP), Voltage Reference (VREF) Digital-to-Analog Converter (DAC), and Analog Mux (ANMUX)"]
pub struct CMP3 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for CMP3 {}
impl CMP3 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const cmp3::RegisterBlock {
0x4007_3018 as *const _
}
}
impl Deref for CMP3 {
type Target = cmp3::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*CMP3::ptr() }
}
}
#[doc = "High-Speed Comparator (CMP), Voltage Reference (VREF) Digital-to-Analog Converter (DAC), and Analog Mux (ANMUX)"]
pub mod cmp3;
#[doc = "Voltage Reference"]
pub struct VREF {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for VREF {}
impl VREF {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const vref::RegisterBlock {
0x4007_4000 as *const _
}
}
impl Deref for VREF {
type Target = vref::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*VREF::ptr() }
}
}
#[doc = "Voltage Reference"]
pub mod vref;
#[doc = "Low leakage wakeup unit"]
pub struct LLWU {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for LLWU {}
impl LLWU {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const llwu::RegisterBlock {
0x4007_c000 as *const _
}
}
impl Deref for LLWU {
type Target = llwu::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*LLWU::ptr() }
}
}
#[doc = "Low leakage wakeup unit"]
pub mod llwu;
#[doc = "Power Management Controller"]
pub struct PMC {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PMC {}
impl PMC {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const pmc::RegisterBlock {
0x4007_d000 as *const _
}
}
impl Deref for PMC {
type Target = pmc::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*PMC::ptr() }
}
}
#[doc = "Power Management Controller"]
pub mod pmc;
#[doc = "System Mode Controller"]
pub struct SMC {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SMC {}
impl SMC {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const smc::RegisterBlock {
0x4007_e000 as *const _
}
}
impl Deref for SMC {
type Target = smc::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*SMC::ptr() }
}
}
#[doc = "System Mode Controller"]
pub mod smc;
#[doc = "Reset Control Module"]
pub struct RCM {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for RCM {}
impl RCM {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const rcm::RegisterBlock {
0x4007_f000 as *const _
}
}
impl Deref for RCM {
type Target = rcm::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*RCM::ptr() }
}
}
#[doc = "Reset Control Module"]
pub mod rcm;
#[doc = "Random Number Generator Accelerator"]
pub struct RNG {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for RNG {}
impl RNG {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const rng::RegisterBlock {
0x400a_0000 as *const _
}
}
impl Deref for RNG {
type Target = rng::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*RNG::ptr() }
}
}
#[doc = "Random Number Generator Accelerator"]
pub mod rng;
#[doc = "USB HS/FS/LS OTG Controller"]
pub struct USBHS {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for USBHS {}
impl USBHS {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const usbhs::RegisterBlock {
0x400a_1000 as *const _
}
}
impl Deref for USBHS {
type Target = usbhs::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*USBHS::ptr() }
}
}
#[doc = "USB HS/FS/LS OTG Controller"]
pub mod usbhs;
#[doc = "USBPHY Register Reference Index"]
pub struct USBPHY {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for USBPHY {}
impl USBPHY {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const usbphy::RegisterBlock {
0x400a_2000 as *const _
}
}
impl Deref for USBPHY {
type Target = usbphy::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*USBPHY::ptr() }
}
}
#[doc = "USBPHY Register Reference Index"]
pub mod usbphy;
#[doc = "USB Device Charger Detection module"]
pub struct USBHSDCD {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for USBHSDCD {}
impl USBHSDCD {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const usbhsdcd::RegisterBlock {
0x400a_3000 as *const _
}
}
impl Deref for USBHSDCD {
type Target = usbhsdcd::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*USBHSDCD::ptr() }
}
}
#[doc = "USB Device Charger Detection module"]
pub mod usbhsdcd;
#[doc = "Secured Digital Host Controller"]
pub struct SDHC {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SDHC {}
impl SDHC {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const sdhc::RegisterBlock {
0x400b_1000 as *const _
}
}
impl Deref for SDHC {
type Target = sdhc::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*SDHC::ptr() }
}
}
#[doc = "Secured Digital Host Controller"]
pub mod sdhc;
#[doc = "Ethernet MAC-NET Core"]
pub struct ENET {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for ENET {}
impl ENET {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const enet::RegisterBlock {
0x400c_0000 as *const _
}
}
impl Deref for ENET {
type Target = enet::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*ENET::ptr() }
}
}
#[doc = "Ethernet MAC-NET Core"]
pub mod enet;
#[doc = "Universal Asynchronous Receiver/Transmitter"]
pub struct LPUART0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for LPUART0 {}
impl LPUART0 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const lpuart0::RegisterBlock {
0x400c_4000 as *const _
}
}
impl Deref for LPUART0 {
type Target = lpuart0::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*LPUART0::ptr() }
}
}
#[doc = "Universal Asynchronous Receiver/Transmitter"]
pub mod lpuart0;
#[doc = "Timer/PWM Module"]
pub struct TPM1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for TPM1 {}
impl TPM1 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const tpm1::RegisterBlock {
0x400c_9000 as *const _
}
}
impl Deref for TPM1 {
type Target = tpm1::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*TPM1::ptr() }
}
}
#[doc = "Timer/PWM Module"]
pub mod tpm1;
#[doc = "Timer/PWM Module"]
pub struct TPM2 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for TPM2 {}
impl TPM2 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const tpm2::RegisterBlock {
0x400c_a000 as *const _
}
}
impl Deref for TPM2 {
type Target = tpm2::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*TPM2::ptr() }
}
}
#[doc = "Timer/PWM Module"]
pub mod tpm2;
#[doc = "12-Bit Digital-to-Analog Converter"]
pub struct DAC0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for DAC0 {}
impl DAC0 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const dac0::RegisterBlock {
0x400c_c000 as *const _
}
}
impl Deref for DAC0 {
type Target = dac0::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*DAC0::ptr() }
}
}
#[doc = "12-Bit Digital-to-Analog Converter"]
pub mod dac0;
#[doc = "12-Bit Digital-to-Analog Converter"]
pub struct DAC1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for DAC1 {}
impl DAC1 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const dac1::RegisterBlock {
0x400c_d000 as *const _
}
}
impl Deref for DAC1 {
type Target = dac1::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*DAC1::ptr() }
}
}
#[doc = "12-Bit Digital-to-Analog Converter"]
pub mod dac1;
#[doc = "General Purpose Input/Output"]
pub struct GPIOA {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for GPIOA {}
impl GPIOA {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const gpioa::RegisterBlock {
0x400f_f000 as *const _
}
}
impl Deref for GPIOA {
type Target = gpioa::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*GPIOA::ptr() }
}
}
#[doc = "General Purpose Input/Output"]
pub mod gpioa;
#[doc = "General Purpose Input/Output"]
pub struct GPIOB {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for GPIOB {}
impl GPIOB {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const gpiob::RegisterBlock {
0x400f_f040 as *const _
}
}
impl Deref for GPIOB {
type Target = gpiob::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*GPIOB::ptr() }
}
}
#[doc = "General Purpose Input/Output"]
pub mod gpiob;
#[doc = "General Purpose Input/Output"]
pub struct GPIOC {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for GPIOC {}
impl GPIOC {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const gpioc::RegisterBlock {
0x400f_f080 as *const _
}
}
impl Deref for GPIOC {
type Target = gpioc::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*GPIOC::ptr() }
}
}
#[doc = "General Purpose Input/Output"]
pub mod gpioc;
#[doc = "General Purpose Input/Output"]
pub struct GPIOD {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for GPIOD {}
impl GPIOD {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const gpiod::RegisterBlock {
0x400f_f0c0 as *const _
}
}
impl Deref for GPIOD {
type Target = gpiod::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*GPIOD::ptr() }
}
}
#[doc = "General Purpose Input/Output"]
pub mod gpiod;
#[doc = "General Purpose Input/Output"]
pub struct GPIOE {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for GPIOE {}
impl GPIOE {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const gpioe::RegisterBlock {
0x400f_f100 as *const _
}
}
impl Deref for GPIOE {
type Target = gpioe::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*GPIOE::ptr() }
}
}
#[doc = "General Purpose Input/Output"]
pub mod gpioe;
#[doc = "System Control Block"]
pub struct SYSTEMCONTROL {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SYSTEMCONTROL {}
impl SYSTEMCONTROL {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const system_control::RegisterBlock {
0xe000_e000 as *const _
}
}
impl Deref for SYSTEMCONTROL {
type Target = system_control::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*SYSTEMCONTROL::ptr() }
}
}
#[doc = "System Control Block"]
pub mod system_control;
#[doc = "System timer"]
pub struct SYSTICK {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SYSTICK {}
impl SYSTICK {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const sys_tick::RegisterBlock {
0xe000_e010 as *const _
}
}
impl Deref for SYSTICK {
type Target = sys_tick::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*SYSTICK::ptr() }
}
}
#[doc = "System timer"]
pub mod sys_tick;
#[doc = "Core Platform Miscellaneous Control Module"]
pub struct MCM {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for MCM {}
impl MCM {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const mcm::RegisterBlock {
0xe008_0000 as *const _
}
}
impl Deref for MCM {
type Target = mcm::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*MCM::ptr() }
}
}
#[doc = "Core Platform Miscellaneous Control Module"]
pub mod mcm;
#[doc = "Memory Mapped Cryptographic Acceleration Unit (MMCAU)"]
pub struct CAU {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for CAU {}
impl CAU {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const cau::RegisterBlock {
0xe008_1000 as *const _
}
}
impl Deref for CAU {
type Target = cau::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*CAU::ptr() }
}
}
#[doc = "Memory Mapped Cryptographic Acceleration Unit (MMCAU)"]
pub mod cau;
#[doc = "Local Memory Controller"]
pub struct LMEM {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for LMEM {}
impl LMEM {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const lmem::RegisterBlock {
0xe008_2000 as *const _
}
}
impl Deref for LMEM {
type Target = lmem::RegisterBlock;
fn deref(&self) -> &Self::Target {
unsafe { &*LMEM::ptr() }
}
}
#[doc = "Local Memory Controller"]
pub mod lmem;
#[no_mangle]
static mut DEVICE_PERIPHERALS: bool = false;
#[doc = r"All the peripherals"]
#[allow(non_snake_case)]
pub struct Peripherals {
#[doc = "FTFE_FLASHCONFIG"]
pub FTFE_FLASHCONFIG: FTFE_FLASHCONFIG,
#[doc = "AIPS0"]
pub AIPS0: AIPS0,
#[doc = "AIPS1"]
pub AIPS1: AIPS1,
#[doc = "AXBS"]
pub AXBS: AXBS,
#[doc = "DMA"]
pub DMA: DMA,
#[doc = "FB"]
pub FB: FB,
#[doc = "SYSMPU"]
pub SYSMPU: SYSMPU,
#[doc = "SDRAM"]
pub SDRAM: SDRAM,
#[doc = "FMC"]
pub FMC: FMC,
#[doc = "FTFE"]
pub FTFE: FTFE,
#[doc = "DMAMUX"]
pub DMAMUX: DMAMUX,
#[doc = "CAN0"]
pub CAN0: CAN0,
#[doc = "CAN1"]
pub CAN1: CAN1,
#[doc = "SPI0"]
pub SPI0: SPI0,
#[doc = "SPI1"]
pub SPI1: SPI1,
#[doc = "SPI2"]
pub SPI2: SPI2,
#[doc = "I2S0"]
pub I2S0: I2S0,
#[doc = "CRC"]
pub CRC: CRC,
#[doc = "USBDCD"]
pub USBDCD: USBDCD,
#[doc = "PDB0"]
pub PDB0: PDB0,
#[doc = "PIT"]
pub PIT: PIT,
#[doc = "FTM0"]
pub FTM0: FTM0,
#[doc = "FTM1"]
pub FTM1: FTM1,
#[doc = "FTM2"]
pub FTM2: FTM2,
#[doc = "FTM3"]
pub FTM3: FTM3,
#[doc = "ADC0"]
pub ADC0: ADC0,
#[doc = "ADC1"]
pub ADC1: ADC1,
#[doc = "RTC"]
pub RTC: RTC,
#[doc = "RFVBAT"]
pub RFVBAT: RFVBAT,
#[doc = "LPTMR0"]
pub LPTMR0: LPTMR0,
#[doc = "RFSYS"]
pub RFSYS: RFSYS,
#[doc = "TSI0"]
pub TSI0: TSI0,
#[doc = "SIM"]
pub SIM: SIM,
#[doc = "PORTA"]
pub PORTA: PORTA,
#[doc = "PORTB"]
pub PORTB: PORTB,
#[doc = "PORTC"]
pub PORTC: PORTC,
#[doc = "PORTD"]
pub PORTD: PORTD,
#[doc = "PORTE"]
pub PORTE: PORTE,
#[doc = "WDOG"]
pub WDOG: WDOG,
#[doc = "EWM"]
pub EWM: EWM,
#[doc = "CMT"]
pub CMT: CMT,
#[doc = "MCG"]
pub MCG: MCG,
#[doc = "OSC"]
pub OSC: OSC,
#[doc = "I2C0"]
pub I2C0: I2C0,
#[doc = "I2C1"]
pub I2C1: I2C1,
#[doc = "I2C2"]
pub I2C2: I2C2,
#[doc = "I2C3"]
pub I2C3: I2C3,
#[doc = "UART0"]
pub UART0: UART0,
#[doc = "UART1"]
pub UART1: UART1,
#[doc = "UART2"]
pub UART2: UART2,
#[doc = "UART3"]
pub UART3: UART3,
#[doc = "UART4"]
pub UART4: UART4,
#[doc = "USB0"]
pub USB0: USB0,
#[doc = "CMP0"]
pub CMP0: CMP0,
#[doc = "CMP1"]
pub CMP1: CMP1,
#[doc = "CMP2"]
pub CMP2: CMP2,
#[doc = "CMP3"]
pub CMP3: CMP3,
#[doc = "VREF"]
pub VREF: VREF,
#[doc = "LLWU"]
pub LLWU: LLWU,
#[doc = "PMC"]
pub PMC: PMC,
#[doc = "SMC"]
pub SMC: SMC,
#[doc = "RCM"]
pub RCM: RCM,
#[doc = "RNG"]
pub RNG: RNG,
#[doc = "USBHS"]
pub USBHS: USBHS,
#[doc = "USBPHY"]
pub USBPHY: USBPHY,
#[doc = "USBHSDCD"]
pub USBHSDCD: USBHSDCD,
#[doc = "SDHC"]
pub SDHC: SDHC,
#[doc = "ENET"]
pub ENET: ENET,
#[doc = "LPUART0"]
pub LPUART0: LPUART0,
#[doc = "TPM1"]
pub TPM1: TPM1,
#[doc = "TPM2"]
pub TPM2: TPM2,
#[doc = "DAC0"]
pub DAC0: DAC0,
#[doc = "DAC1"]
pub DAC1: DAC1,
#[doc = "GPIOA"]
pub GPIOA: GPIOA,
#[doc = "GPIOB"]
pub GPIOB: GPIOB,
#[doc = "GPIOC"]
pub GPIOC: GPIOC,
#[doc = "GPIOD"]
pub GPIOD: GPIOD,
#[doc = "GPIOE"]
pub GPIOE: GPIOE,
#[doc = "SYSTEMCONTROL"]
pub SYSTEMCONTROL: SYSTEMCONTROL,
#[doc = "SYSTICK"]
pub SYSTICK: SYSTICK,
#[doc = "MCM"]
pub MCM: MCM,
#[doc = "CAU"]
pub CAU: CAU,
#[doc = "LMEM"]
pub LMEM: LMEM,
}
impl Peripherals {
#[doc = r"Returns all the peripherals *once*"]
#[inline]
pub fn take() -> Option<Self> {
cortex_m::interrupt::free(|_| {
if unsafe { DEVICE_PERIPHERALS } {
None
} else {
Some(unsafe { Peripherals::steal() })
}
})
}
#[doc = r"Unchecked version of `Peripherals::take`"]
pub unsafe fn steal() -> Self {
DEVICE_PERIPHERALS = true;
Peripherals {
FTFE_FLASHCONFIG: FTFE_FLASHCONFIG {
_marker: PhantomData,
},
AIPS0: AIPS0 {
_marker: PhantomData,
},
AIPS1: AIPS1 {
_marker: PhantomData,
},
AXBS: AXBS {
_marker: PhantomData,
},
DMA: DMA {
_marker: PhantomData,
},
FB: FB {
_marker: PhantomData,
},
SYSMPU: SYSMPU {
_marker: PhantomData,
},
SDRAM: SDRAM {
_marker: PhantomData,
},
FMC: FMC {
_marker: PhantomData,
},
FTFE: FTFE {
_marker: PhantomData,
},
DMAMUX: DMAMUX {
_marker: PhantomData,
},
CAN0: CAN0 {
_marker: PhantomData,
},
CAN1: CAN1 {
_marker: PhantomData,
},
SPI0: SPI0 {
_marker: PhantomData,
},
SPI1: SPI1 {
_marker: PhantomData,
},
SPI2: SPI2 {
_marker: PhantomData,
},
I2S0: I2S0 {
_marker: PhantomData,
},
CRC: CRC {
_marker: PhantomData,
},
USBDCD: USBDCD {
_marker: PhantomData,
},
PDB0: PDB0 {
_marker: PhantomData,
},
PIT: PIT {
_marker: PhantomData,
},
FTM0: FTM0 {
_marker: PhantomData,
},
FTM1: FTM1 {
_marker: PhantomData,
},
FTM2: FTM2 {
_marker: PhantomData,
},
FTM3: FTM3 {
_marker: PhantomData,
},
ADC0: ADC0 {
_marker: PhantomData,
},
ADC1: ADC1 {
_marker: PhantomData,
},
RTC: RTC {
_marker: PhantomData,
},
RFVBAT: RFVBAT {
_marker: PhantomData,
},
LPTMR0: LPTMR0 {
_marker: PhantomData,
},
RFSYS: RFSYS {
_marker: PhantomData,
},
TSI0: TSI0 {
_marker: PhantomData,
},
SIM: SIM {
_marker: PhantomData,
},
PORTA: PORTA {
_marker: PhantomData,
},
PORTB: PORTB {
_marker: PhantomData,
},
PORTC: PORTC {
_marker: PhantomData,
},
PORTD: PORTD {
_marker: PhantomData,
},
PORTE: PORTE {
_marker: PhantomData,
},
WDOG: WDOG {
_marker: PhantomData,
},
EWM: EWM {
_marker: PhantomData,
},
CMT: CMT {
_marker: PhantomData,
},
MCG: MCG {
_marker: PhantomData,
},
OSC: OSC {
_marker: PhantomData,
},
I2C0: I2C0 {
_marker: PhantomData,
},
I2C1: I2C1 {
_marker: PhantomData,
},
I2C2: I2C2 {
_marker: PhantomData,
},
I2C3: I2C3 {
_marker: PhantomData,
},
UART0: UART0 {
_marker: PhantomData,
},
UART1: UART1 {
_marker: PhantomData,
},
UART2: UART2 {
_marker: PhantomData,
},
UART3: UART3 {
_marker: PhantomData,
},
UART4: UART4 {
_marker: PhantomData,
},
USB0: USB0 {
_marker: PhantomData,
},
CMP0: CMP0 {
_marker: PhantomData,
},
CMP1: CMP1 {
_marker: PhantomData,
},
CMP2: CMP2 {
_marker: PhantomData,
},
CMP3: CMP3 {
_marker: PhantomData,
},
VREF: VREF {
_marker: PhantomData,
},
LLWU: LLWU {
_marker: PhantomData,
},
PMC: PMC {
_marker: PhantomData,
},
SMC: SMC {
_marker: PhantomData,
},
RCM: RCM {
_marker: PhantomData,
},
RNG: RNG {
_marker: PhantomData,
},
USBHS: USBHS {
_marker: PhantomData,
},
USBPHY: USBPHY {
_marker: PhantomData,
},
USBHSDCD: USBHSDCD {
_marker: PhantomData,
},
SDHC: SDHC {
_marker: PhantomData,
},
ENET: ENET {
_marker: PhantomData,
},
LPUART0: LPUART0 {
_marker: PhantomData,
},
TPM1: TPM1 {
_marker: PhantomData,
},
TPM2: TPM2 {
_marker: PhantomData,
},
DAC0: DAC0 {
_marker: PhantomData,
},
DAC1: DAC1 {
_marker: PhantomData,
},
GPIOA: GPIOA {
_marker: PhantomData,
},
GPIOB: GPIOB {
_marker: PhantomData,
},
GPIOC: GPIOC {
_marker: PhantomData,
},
GPIOD: GPIOD {
_marker: PhantomData,
},
GPIOE: GPIOE {
_marker: PhantomData,
},
SYSTEMCONTROL: SYSTEMCONTROL {
_marker: PhantomData,
},
SYSTICK: SYSTICK {
_marker: PhantomData,
},
MCM: MCM {
_marker: PhantomData,
},
CAU: CAU {
_marker: PhantomData,
},
LMEM: LMEM {
_marker: PhantomData,
},
}
}
}