2020-12-07 10:24:29 +00:00
#![ doc = " Peripheral access API for S32K118 microcontrollers (generated using svd2rust v0.17.0) \n \n You can find an overview of the API [here]. \n \n [here]: https://docs.rs/svd2rust/0.17.0/svd2rust/#peripheral-api " ]
#![ deny(const_err) ]
#![ deny(dead_code) ]
#![ deny(improper_ctypes) ]
#![ deny(missing_docs) ]
#![ deny(no_mangle_generic_items) ]
#![ deny(non_shorthand_field_patterns) ]
#![ deny(overflowing_literals) ]
#![ deny(path_statements) ]
#![ deny(patterns_in_fns_without_body) ]
#![ deny(private_in_public) ]
#![ deny(unconditional_recursion) ]
#![ deny(unused_allocation) ]
#![ deny(unused_comparisons) ]
#![ deny(unused_parens) ]
#![ deny(while_true) ]
#![ allow(non_camel_case_types) ]
#![ allow(non_snake_case) ]
#![ 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 = 2 ;
#[ cfg(feature = " rt " ) ]
extern " C " {
fn DMA0 ( ) ;
fn DMA1 ( ) ;
fn DMA2 ( ) ;
fn DMA3 ( ) ;
fn DMA_ERROR ( ) ;
fn ERM_FAULT ( ) ;
fn RTC ( ) ;
fn RTC_SECONDS ( ) ;
fn LPTMR0 ( ) ;
fn PORT ( ) ;
fn CAN0_ORED_ERR_WAKEUP ( ) ;
fn CAN0_ORED_0_31_MB ( ) ;
fn FTM0_CH0_7 ( ) ;
fn FTM0_FAULT ( ) ;
fn FTM0_OVF_RELOAD ( ) ;
fn FTM1_CH0_7 ( ) ;
fn FTM1_FAULT ( ) ;
fn FTM1_OVF_RELOAD ( ) ;
fn FTFC ( ) ;
fn PDB0 ( ) ;
fn LPIT0 ( ) ;
fn SCG_CMU_LVD_LVWSCG ( ) ;
fn WDOG ( ) ;
fn RCM ( ) ;
fn LPI2C0_MASTER_SLAVE ( ) ;
fn FLEXIO ( ) ;
fn LPSPI0 ( ) ;
fn LPSPI1 ( ) ;
fn ADC0 ( ) ;
fn CMP0 ( ) ;
fn LPUART1_RXTX ( ) ;
fn LPUART0_RXTX ( ) ;
}
#[ 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 ; 32 ] = [
Vector { _handler : DMA0 } ,
Vector { _handler : DMA1 } ,
Vector { _handler : DMA2 } ,
Vector { _handler : DMA3 } ,
Vector { _handler : DMA_ERROR } ,
Vector { _handler : ERM_FAULT } ,
Vector { _handler : RTC } ,
Vector { _handler : RTC_SECONDS } ,
Vector { _handler : LPTMR0 } ,
Vector { _handler : PORT } ,
Vector { _handler : CAN0_ORED_ERR_WAKEUP } ,
Vector { _handler : CAN0_ORED_0_31_MB } ,
Vector { _handler : FTM0_CH0_7 } ,
Vector { _handler : FTM0_FAULT } ,
Vector { _handler : FTM0_OVF_RELOAD } ,
Vector { _handler : FTM1_CH0_7 } ,
Vector { _handler : FTM1_FAULT } ,
Vector { _handler : FTM1_OVF_RELOAD } ,
Vector { _handler : FTFC } ,
Vector { _handler : PDB0 } ,
Vector { _handler : LPIT0 } ,
Vector { _handler : SCG_CMU_LVD_LVWSCG } ,
Vector { _handler : WDOG } ,
Vector { _handler : RCM } ,
Vector { _handler : LPI2C0_MASTER_SLAVE } ,
Vector { _handler : FLEXIO } ,
Vector { _handler : LPSPI0 } ,
Vector { _handler : LPSPI1 } ,
Vector { _handler : ADC0 } ,
Vector { _handler : CMP0 } ,
Vector { _handler : LPUART1_RXTX } ,
Vector { _handler : LPUART0_RXTX } ,
] ;
#[ doc = r " Enumeration of all the interrupts " ]
#[ derive(Copy, Clone, Debug) ]
#[ repr(u8) ]
pub enum Interrupt {
#[ doc = " 0 - DMA0 " ]
DMA0 = 0 ,
#[ doc = " 1 - DMA1 " ]
DMA1 = 1 ,
#[ doc = " 2 - DMA2 " ]
DMA2 = 2 ,
#[ doc = " 3 - DMA3 " ]
DMA3 = 3 ,
#[ doc = " 4 - DMA_Error " ]
DMA_ERROR = 4 ,
#[ doc = " 5 - ERM_fault " ]
ERM_FAULT = 5 ,
#[ doc = " 6 - RTC " ]
RTC = 6 ,
#[ doc = " 7 - RTC_Seconds " ]
RTC_SECONDS = 7 ,
#[ doc = " 8 - LPTMR0 " ]
LPTMR0 = 8 ,
#[ doc = " 9 - PORT " ]
PORT = 9 ,
#[ doc = " 10 - CAN0_ORed_Err_Wakeup " ]
CAN0_ORED_ERR_WAKEUP = 10 ,
#[ doc = " 11 - CAN0_ORed_0_31_MB " ]
CAN0_ORED_0_31_MB = 11 ,
#[ doc = " 12 - FTM0_Ch0_7 " ]
FTM0_CH0_7 = 12 ,
#[ doc = " 13 - FTM0_Fault " ]
FTM0_FAULT = 13 ,
#[ doc = " 14 - FTM0_Ovf_Reload " ]
FTM0_OVF_RELOAD = 14 ,
#[ doc = " 15 - FTM1_Ch0_7 " ]
FTM1_CH0_7 = 15 ,
#[ doc = " 16 - FTM1_Fault " ]
FTM1_FAULT = 16 ,
#[ doc = " 17 - FTM1_Ovf_Reload " ]
FTM1_OVF_RELOAD = 17 ,
#[ doc = " 18 - FTFC " ]
FTFC = 18 ,
#[ doc = " 19 - PDB0 " ]
PDB0 = 19 ,
#[ doc = " 20 - LPIT0 " ]
LPIT0 = 20 ,
#[ doc = " 21 - SCG_CMU_LVD_LVWSCG " ]
SCG_CMU_LVD_LVWSCG = 21 ,
#[ doc = " 22 - WDOG " ]
WDOG = 22 ,
#[ doc = " 23 - RCM " ]
RCM = 23 ,
#[ doc = " 24 - LPI2C0_Master_Slave " ]
LPI2C0_MASTER_SLAVE = 24 ,
#[ doc = " 25 - FLEXIO " ]
FLEXIO = 25 ,
#[ doc = " 26 - LPSPI0 " ]
LPSPI0 = 26 ,
#[ doc = " 27 - LPSPI1 " ]
LPSPI1 = 27 ,
#[ doc = " 28 - ADC0 " ]
ADC0 = 28 ,
#[ doc = " 29 - CMP0 " ]
CMP0 = 29 ,
#[ doc = " 30 - LPUART1_RxTx " ]
LPUART1_RXTX = 30 ,
#[ doc = " 31 - LPUART0_RxTx " ]
LPUART0_RXTX = 31 ,
}
unsafe impl bare_metal ::Nr for Interrupt {
#[ inline(always) ]
fn nr ( & self ) -> u8 {
* self as u8
}
}
#[ 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 = " CSE_PRAM " ]
pub struct CSE_PRAM {
_marker : PhantomData < * const ( ) > ,
}
unsafe impl Send for CSE_PRAM { }
impl CSE_PRAM {
#[ doc = r " Returns a pointer to the register block " ]
#[ inline(always) ]
pub const fn ptr ( ) -> * const cse_pram ::RegisterBlock {
0x1400_0800 as * const _
}
}
impl Deref for CSE_PRAM {
type Target = cse_pram ::RegisterBlock ;
#[ inline(always) ]
fn deref ( & self ) -> & Self ::Target {
unsafe { & * CSE_PRAM ::ptr ( ) }
}
}
#[ doc = " CSE_PRAM " ]
pub mod cse_pram ;
#[ doc = " AIPS-Lite Bridge " ]
pub struct AIPS {
_marker : PhantomData < * const ( ) > ,
}
unsafe impl Send for AIPS { }
impl AIPS {
#[ doc = r " Returns a pointer to the register block " ]
#[ inline(always) ]
pub const fn ptr ( ) -> * const aips ::RegisterBlock {
0x4000_0000 as * const _
}
}
impl Deref for AIPS {
type Target = aips ::RegisterBlock ;
#[ inline(always) ]
fn deref ( & self ) -> & Self ::Target {
unsafe { & * AIPS ::ptr ( ) }
}
}
#[ doc = " AIPS-Lite Bridge " ]
pub mod aips ;
#[ doc = " MSCM " ]
pub struct MSCM {
_marker : PhantomData < * const ( ) > ,
}
unsafe impl Send for MSCM { }
impl MSCM {
#[ doc = r " Returns a pointer to the register block " ]
#[ inline(always) ]
pub const fn ptr ( ) -> * const mscm ::RegisterBlock {
0x4000_1000 as * const _
}
}
impl Deref for MSCM {
type Target = mscm ::RegisterBlock ;
#[ inline(always) ]
fn deref ( & self ) -> & Self ::Target {
unsafe { & * MSCM ::ptr ( ) }
}
}
#[ doc = " MSCM " ]
pub mod mscm ;
#[ doc = " Enhanced Direct Memory Access " ]
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 ;
#[ inline(always) ]
fn deref ( & self ) -> & Self ::Target {
unsafe { & * DMA ::ptr ( ) }
}
}
#[ doc = " Enhanced Direct Memory Access " ]
pub mod dma ;
#[ doc = " ERM " ]
pub struct ERM {
_marker : PhantomData < * const ( ) > ,
}
unsafe impl Send for ERM { }
impl ERM {
#[ doc = r " Returns a pointer to the register block " ]
#[ inline(always) ]
pub const fn ptr ( ) -> * const erm ::RegisterBlock {
0x4001_8000 as * const _
}
}
impl Deref for ERM {
type Target = erm ::RegisterBlock ;
#[ inline(always) ]
fn deref ( & self ) -> & Self ::Target {
unsafe { & * ERM ::ptr ( ) }
}
}
#[ doc = " ERM " ]
pub mod erm ;
#[ doc = " Error Injection Module " ]
pub struct EIM {
_marker : PhantomData < * const ( ) > ,
}
unsafe impl Send for EIM { }
impl EIM {
#[ doc = r " Returns a pointer to the register block " ]
#[ inline(always) ]
pub const fn ptr ( ) -> * const eim ::RegisterBlock {
0x4001_9000 as * const _
}
}
impl Deref for EIM {
type Target = eim ::RegisterBlock ;
#[ inline(always) ]
fn deref ( & self ) -> & Self ::Target {
unsafe { & * EIM ::ptr ( ) }
}
}
#[ doc = " Error Injection Module " ]
pub mod eim ;
#[ doc = " FTFC " ]
pub struct FTFC {
_marker : PhantomData < * const ( ) > ,
}
unsafe impl Send for FTFC { }
impl FTFC {
#[ doc = r " Returns a pointer to the register block " ]
#[ inline(always) ]
pub const fn ptr ( ) -> * const ftfc ::RegisterBlock {
0x4002_0000 as * const _
}
}
impl Deref for FTFC {
type Target = ftfc ::RegisterBlock ;
#[ inline(always) ]
fn deref ( & self ) -> & Self ::Target {
unsafe { & * FTFC ::ptr ( ) }
}
}
#[ doc = " FTFC " ]
pub mod ftfc ;
#[ 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 ;
#[ inline(always) ]
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 ;
#[ inline(always) ]
fn deref ( & self ) -> & Self ::Target {
unsafe { & * CAN0 ::ptr ( ) }
}
}
#[ doc = " Flex Controller Area Network module " ]
pub mod can0 ;
#[ doc = " The LPSPI Memory Map/Register Definition can be found here. " ]
pub struct LPSPI0 {
_marker : PhantomData < * const ( ) > ,
}
unsafe impl Send for LPSPI0 { }
impl LPSPI0 {
#[ doc = r " Returns a pointer to the register block " ]
#[ inline(always) ]
pub const fn ptr ( ) -> * const lpspi0 ::RegisterBlock {
0x4002_c000 as * const _
}
}
impl Deref for LPSPI0 {
type Target = lpspi0 ::RegisterBlock ;
#[ inline(always) ]
fn deref ( & self ) -> & Self ::Target {
unsafe { & * LPSPI0 ::ptr ( ) }
}
}
#[ doc = " The LPSPI Memory Map/Register Definition can be found here. " ]
pub mod lpspi0 ;
#[ doc = " The LPSPI Memory Map/Register Definition can be found here. " ]
pub struct LPSPI1 {
_marker : PhantomData < * const ( ) > ,
}
unsafe impl Send for LPSPI1 { }
impl LPSPI1 {
#[ doc = r " Returns a pointer to the register block " ]
#[ inline(always) ]
pub const fn ptr ( ) -> * const lpspi1 ::RegisterBlock {
0x4002_d000 as * const _
}
}
impl Deref for LPSPI1 {
type Target = lpspi1 ::RegisterBlock ;
#[ inline(always) ]
fn deref ( & self ) -> & Self ::Target {
unsafe { & * LPSPI1 ::ptr ( ) }
}
}
#[ doc = " The LPSPI Memory Map/Register Definition can be found here. " ]
pub mod lpspi1 ;
#[ 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 ;
#[ inline(always) ]
fn deref ( & self ) -> & Self ::Target {
unsafe { & * CRC ::ptr ( ) }
}
}
#[ doc = " Cyclic Redundancy Check " ]
pub mod crc ;
#[ 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 ;
#[ inline(always) ]
fn deref ( & self ) -> & Self ::Target {
unsafe { & * PDB0 ::ptr ( ) }
}
}
#[ doc = " Programmable Delay Block " ]
pub mod pdb0 ;
#[ doc = " Low Power Periodic Interrupt Timer (LPIT) " ]
pub struct LPIT0 {
_marker : PhantomData < * const ( ) > ,
}
unsafe impl Send for LPIT0 { }
impl LPIT0 {
#[ doc = r " Returns a pointer to the register block " ]
#[ inline(always) ]
pub const fn ptr ( ) -> * const lpit0 ::RegisterBlock {
0x4003_7000 as * const _
}
}
impl Deref for LPIT0 {
type Target = lpit0 ::RegisterBlock ;
#[ inline(always) ]
fn deref ( & self ) -> & Self ::Target {
unsafe { & * LPIT0 ::ptr ( ) }
}
}
#[ doc = " Low Power Periodic Interrupt Timer (LPIT) " ]
pub mod lpit0 ;
#[ 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 ;
#[ inline(always) ]
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 ;
#[ inline(always) ]
fn deref ( & self ) -> & Self ::Target {
unsafe { & * FTM1 ::ptr ( ) }
}
}
#[ doc = " FlexTimer Module " ]
pub mod ftm1 ;
#[ 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 ;
#[ inline(always) ]
fn deref ( & self ) -> & Self ::Target {
unsafe { & * ADC0 ::ptr ( ) }
}
}
#[ doc = " Analog-to-Digital Converter " ]
pub mod adc0 ;
#[ 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 ;
#[ inline(always) ]
fn deref ( & self ) -> & Self ::Target {
unsafe { & * RTC ::ptr ( ) }
}
}
#[ doc = " Secure Real Time Clock " ]
pub mod rtc ;
#[ doc = " CMU_FC " ]
pub struct CMU_FC_0 {
_marker : PhantomData < * const ( ) > ,
}
unsafe impl Send for CMU_FC_0 { }
impl CMU_FC_0 {
#[ doc = r " Returns a pointer to the register block " ]
#[ inline(always) ]
pub const fn ptr ( ) -> * const cmu_fc_0 ::RegisterBlock {
0x4003_e000 as * const _
}
}
impl Deref for CMU_FC_0 {
type Target = cmu_fc_0 ::RegisterBlock ;
#[ inline(always) ]
fn deref ( & self ) -> & Self ::Target {
unsafe { & * CMU_FC_0 ::ptr ( ) }
}
}
#[ doc = " CMU_FC " ]
pub mod cmu_fc_0 ;
#[ doc = " CMU_FC " ]
pub struct CMU_FC_1 {
_marker : PhantomData < * const ( ) > ,
}
unsafe impl Send for CMU_FC_1 { }
impl CMU_FC_1 {
#[ doc = r " Returns a pointer to the register block " ]
#[ inline(always) ]
pub const fn ptr ( ) -> * const cmu_fc_1 ::RegisterBlock {
0x4003_f000 as * const _
}
}
impl Deref for CMU_FC_1 {
type Target = cmu_fc_1 ::RegisterBlock ;
#[ inline(always) ]
fn deref ( & self ) -> & Self ::Target {
unsafe { & * CMU_FC_1 ::ptr ( ) }
}
}
#[ doc = " CMU_FC " ]
pub mod cmu_fc_1 ;
#[ 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 ;
#[ inline(always) ]
fn deref ( & self ) -> & Self ::Target {
unsafe { & * LPTMR0 ::ptr ( ) }
}
}
#[ doc = " Low Power Timer " ]
pub mod lptmr0 ;
#[ 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_8000 as * const _
}
}
impl Deref for SIM {
type Target = sim ::RegisterBlock ;
#[ inline(always) ]
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 ;
#[ inline(always) ]
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 ;
#[ inline(always) ]
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 ;
#[ inline(always) ]
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 ;
#[ inline(always) ]
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 ;
#[ inline(always) ]
fn deref ( & self ) -> & Self ::Target {
unsafe { & * PORTE ::ptr ( ) }
}
}
#[ doc = " Pin Control and Interrupts " ]
pub mod porte ;
#[ doc = " 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 ;
#[ inline(always) ]
fn deref ( & self ) -> & Self ::Target {
unsafe { & * WDOG ::ptr ( ) }
}
}
#[ doc = " Watchdog timer " ]
pub mod wdog ;
#[ doc = " The FLEXIO Memory Map/Register Definition can be found here. " ]
pub struct FLEXIO {
_marker : PhantomData < * const ( ) > ,
}
unsafe impl Send for FLEXIO { }
impl FLEXIO {
#[ doc = r " Returns a pointer to the register block " ]
#[ inline(always) ]
pub const fn ptr ( ) -> * const flexio ::RegisterBlock {
0x4005_a000 as * const _
}
}
impl Deref for FLEXIO {
type Target = flexio ::RegisterBlock ;
#[ inline(always) ]
fn deref ( & self ) -> & Self ::Target {
unsafe { & * FLEXIO ::ptr ( ) }
}
}
#[ doc = " The FLEXIO Memory Map/Register Definition can be found here. " ]
pub mod flexio ;
#[ doc = " TRGMUX " ]
pub struct TRGMUX {
_marker : PhantomData < * const ( ) > ,
}
unsafe impl Send for TRGMUX { }
impl TRGMUX {
#[ doc = r " Returns a pointer to the register block " ]
#[ inline(always) ]
pub const fn ptr ( ) -> * const trgmux ::RegisterBlock {
0x4006_3000 as * const _
}
}
impl Deref for TRGMUX {
type Target = trgmux ::RegisterBlock ;
#[ inline(always) ]
fn deref ( & self ) -> & Self ::Target {
unsafe { & * TRGMUX ::ptr ( ) }
}
}
#[ doc = " TRGMUX " ]
pub mod trgmux ;
#[ doc = " System Clock Generator " ]
pub struct SCG {
_marker : PhantomData < * const ( ) > ,
}
unsafe impl Send for SCG { }
impl SCG {
#[ doc = r " Returns a pointer to the register block " ]
#[ inline(always) ]
pub const fn ptr ( ) -> * const scg ::RegisterBlock {
0x4006_4000 as * const _
}
}
impl Deref for SCG {
type Target = scg ::RegisterBlock ;
#[ inline(always) ]
fn deref ( & self ) -> & Self ::Target {
unsafe { & * SCG ::ptr ( ) }
}
}
#[ doc = " System Clock Generator " ]
pub mod scg ;
#[ doc = " PCC " ]
pub struct PCC {
_marker : PhantomData < * const ( ) > ,
}
unsafe impl Send for PCC { }
impl PCC {
#[ doc = r " Returns a pointer to the register block " ]
#[ inline(always) ]
pub const fn ptr ( ) -> * const pcc ::RegisterBlock {
0x4006_5000 as * const _
}
}
impl Deref for PCC {
type Target = pcc ::RegisterBlock ;
#[ inline(always) ]
fn deref ( & self ) -> & Self ::Target {
unsafe { & * PCC ::ptr ( ) }
}
}
#[ doc = " PCC " ]
pub mod pcc ;
#[ doc = " The LPI2C Memory Map/Register Definition can be found here. " ]
pub struct LPI2C0 {
_marker : PhantomData < * const ( ) > ,
}
unsafe impl Send for LPI2C0 { }
impl LPI2C0 {
#[ doc = r " Returns a pointer to the register block " ]
#[ inline(always) ]
pub const fn ptr ( ) -> * const lpi2c0 ::RegisterBlock {
0x4006_6000 as * const _
}
}
impl Deref for LPI2C0 {
type Target = lpi2c0 ::RegisterBlock ;
#[ inline(always) ]
fn deref ( & self ) -> & Self ::Target {
unsafe { & * LPI2C0 ::ptr ( ) }
}
}
#[ doc = " The LPI2C Memory Map/Register Definition can be found here. " ]
pub mod lpi2c0 ;
#[ 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 {
0x4006_a000 as * const _
}
}
impl Deref for LPUART0 {
type Target = lpuart0 ::RegisterBlock ;
#[ inline(always) ]
fn deref ( & self ) -> & Self ::Target {
unsafe { & * LPUART0 ::ptr ( ) }
}
}
#[ doc = " Universal Asynchronous Receiver/Transmitter " ]
pub mod lpuart0 ;
#[ doc = " Universal Asynchronous Receiver/Transmitter " ]
pub struct LPUART1 {
_marker : PhantomData < * const ( ) > ,
}
unsafe impl Send for LPUART1 { }
impl LPUART1 {
#[ doc = r " Returns a pointer to the register block " ]
#[ inline(always) ]
pub const fn ptr ( ) -> * const lpuart1 ::RegisterBlock {
0x4006_b000 as * const _
}
}
impl Deref for LPUART1 {
type Target = lpuart1 ::RegisterBlock ;
#[ inline(always) ]
fn deref ( & self ) -> & Self ::Target {
unsafe { & * LPUART1 ::ptr ( ) }
}
}
#[ doc = " Universal Asynchronous Receiver/Transmitter " ]
pub mod lpuart1 ;
#[ 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 ;
#[ inline(always) ]
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 = " PMC " ]
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 ;
#[ inline(always) ]
fn deref ( & self ) -> & Self ::Target {
unsafe { & * PMC ::ptr ( ) }
}
}
#[ doc = " PMC " ]
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 ;
#[ inline(always) ]
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 ;
#[ inline(always) ]
fn deref ( & self ) -> & Self ::Target {
unsafe { & * RCM ::ptr ( ) }
}
}
#[ doc = " Reset Control Module " ]
pub mod rcm ;
#[ doc = " General Purpose Input/Output " ]
pub struct PTA {
_marker : PhantomData < * const ( ) > ,
}
unsafe impl Send for PTA { }
impl PTA {
#[ doc = r " Returns a pointer to the register block " ]
#[ inline(always) ]
pub const fn ptr ( ) -> * const pta ::RegisterBlock {
0x400f_f000 as * const _
}
}
impl Deref for PTA {
type Target = pta ::RegisterBlock ;
#[ inline(always) ]
fn deref ( & self ) -> & Self ::Target {
unsafe { & * PTA ::ptr ( ) }
}
}
#[ doc = " General Purpose Input/Output " ]
pub mod pta ;
#[ doc = " General Purpose Input/Output " ]
pub struct PTB {
_marker : PhantomData < * const ( ) > ,
}
unsafe impl Send for PTB { }
impl PTB {
#[ doc = r " Returns a pointer to the register block " ]
#[ inline(always) ]
pub const fn ptr ( ) -> * const ptb ::RegisterBlock {
0x400f_f040 as * const _
}
}
impl Deref for PTB {
type Target = ptb ::RegisterBlock ;
#[ inline(always) ]
fn deref ( & self ) -> & Self ::Target {
unsafe { & * PTB ::ptr ( ) }
}
}
#[ doc = " General Purpose Input/Output " ]
pub mod ptb ;
#[ doc = " General Purpose Input/Output " ]
pub struct PTC {
_marker : PhantomData < * const ( ) > ,
}
unsafe impl Send for PTC { }
impl PTC {
#[ doc = r " Returns a pointer to the register block " ]
#[ inline(always) ]
pub const fn ptr ( ) -> * const ptc ::RegisterBlock {
0x400f_f080 as * const _
}
}
impl Deref for PTC {
type Target = ptc ::RegisterBlock ;
#[ inline(always) ]
fn deref ( & self ) -> & Self ::Target {
unsafe { & * PTC ::ptr ( ) }
}
}
#[ doc = " General Purpose Input/Output " ]
pub mod ptc ;
#[ doc = " General Purpose Input/Output " ]
pub struct PTD {
_marker : PhantomData < * const ( ) > ,
}
unsafe impl Send for PTD { }
impl PTD {
#[ doc = r " Returns a pointer to the register block " ]
#[ inline(always) ]
pub const fn ptr ( ) -> * const ptd ::RegisterBlock {
0x400f_f0c0 as * const _
}
}
impl Deref for PTD {
type Target = ptd ::RegisterBlock ;
#[ inline(always) ]
fn deref ( & self ) -> & Self ::Target {
unsafe { & * PTD ::ptr ( ) }
}
}
#[ doc = " General Purpose Input/Output " ]
pub mod ptd ;
#[ doc = " General Purpose Input/Output " ]
pub struct PTE {
_marker : PhantomData < * const ( ) > ,
}
unsafe impl Send for PTE { }
impl PTE {
#[ doc = r " Returns a pointer to the register block " ]
#[ inline(always) ]
pub const fn ptr ( ) -> * const pte ::RegisterBlock {
0x400f_f100 as * const _
}
}
impl Deref for PTE {
type Target = pte ::RegisterBlock ;
#[ inline(always) ]
fn deref ( & self ) -> & Self ::Target {
unsafe { & * PTE ::ptr ( ) }
}
}
#[ doc = " General Purpose Input/Output " ]
pub mod pte ;
#[ doc = " System Control Registers " ]
pub struct S32_SCB {
_marker : PhantomData < * const ( ) > ,
}
unsafe impl Send for S32_SCB { }
impl S32_SCB {
#[ doc = r " Returns a pointer to the register block " ]
#[ inline(always) ]
pub const fn ptr ( ) -> * const s32_scb ::RegisterBlock {
0xe000_e000 as * const _
}
}
impl Deref for S32_SCB {
type Target = s32_scb ::RegisterBlock ;
#[ inline(always) ]
fn deref ( & self ) -> & Self ::Target {
unsafe { & * S32_SCB ::ptr ( ) }
}
}
#[ doc = " System Control Registers " ]
pub mod s32_scb ;
#[ doc = " System timer " ]
pub struct S32_SYSTICK {
_marker : PhantomData < * const ( ) > ,
}
unsafe impl Send for S32_SYSTICK { }
impl S32_SYSTICK {
#[ doc = r " Returns a pointer to the register block " ]
#[ inline(always) ]
pub const fn ptr ( ) -> * const s32_sys_tick ::RegisterBlock {
0xe000_e010 as * const _
}
}
impl Deref for S32_SYSTICK {
type Target = s32_sys_tick ::RegisterBlock ;
#[ inline(always) ]
fn deref ( & self ) -> & Self ::Target {
unsafe { & * S32_SYSTICK ::ptr ( ) }
}
}
#[ doc = " System timer " ]
pub mod s32_sys_tick ;
#[ doc = " Nested Vectored Interrupt Controller " ]
pub struct S32_NVIC {
_marker : PhantomData < * const ( ) > ,
}
unsafe impl Send for S32_NVIC { }
impl S32_NVIC {
#[ doc = r " Returns a pointer to the register block " ]
#[ inline(always) ]
pub const fn ptr ( ) -> * const s32_nvic ::RegisterBlock {
0xe000_e100 as * const _
}
}
impl Deref for S32_NVIC {
type Target = s32_nvic ::RegisterBlock ;
#[ inline(always) ]
fn deref ( & self ) -> & Self ::Target {
unsafe { & * S32_NVIC ::ptr ( ) }
}
}
#[ doc = " Nested Vectored Interrupt Controller " ]
pub mod s32_nvic ;
#[ 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 ;
#[ inline(always) ]
fn deref ( & self ) -> & Self ::Target {
unsafe { & * LMEM ::ptr ( ) }
}
}
#[ doc = " Local Memory Controller " ]
pub mod lmem ;
#[ 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 {
0xf000_3000 as * const _
}
}
impl Deref for MCM {
type Target = mcm ::RegisterBlock ;
#[ inline(always) ]
fn deref ( & self ) -> & Self ::Target {
unsafe { & * MCM ::ptr ( ) }
}
}
#[ doc = " Core Platform Miscellaneous Control Module " ]
pub mod mcm ;
#[ no_mangle ]
static mut DEVICE_PERIPHERALS : bool = false ;
#[ doc = r " All the peripherals " ]
#[ allow(non_snake_case) ]
pub struct Peripherals {
#[ doc = " CSE_PRAM " ]
pub CSE_PRAM : CSE_PRAM ,
#[ doc = " AIPS " ]
pub AIPS : AIPS ,
#[ doc = " MSCM " ]
pub MSCM : MSCM ,
#[ doc = " DMA " ]
pub DMA : DMA ,
#[ doc = " ERM " ]
pub ERM : ERM ,
#[ doc = " EIM " ]
pub EIM : EIM ,
#[ doc = " FTFC " ]
pub FTFC : FTFC ,
#[ doc = " DMAMUX " ]
pub DMAMUX : DMAMUX ,
#[ doc = " CAN0 " ]
pub CAN0 : CAN0 ,
#[ doc = " LPSPI0 " ]
pub LPSPI0 : LPSPI0 ,
#[ doc = " LPSPI1 " ]
pub LPSPI1 : LPSPI1 ,
#[ doc = " CRC " ]
pub CRC : CRC ,
#[ doc = " PDB0 " ]
pub PDB0 : PDB0 ,
#[ doc = " LPIT0 " ]
pub LPIT0 : LPIT0 ,
#[ doc = " FTM0 " ]
pub FTM0 : FTM0 ,
#[ doc = " FTM1 " ]
pub FTM1 : FTM1 ,
#[ doc = " ADC0 " ]
pub ADC0 : ADC0 ,
#[ doc = " RTC " ]
pub RTC : RTC ,
#[ doc = " CMU_FC_0 " ]
pub CMU_FC_0 : CMU_FC_0 ,
#[ doc = " CMU_FC_1 " ]
pub CMU_FC_1 : CMU_FC_1 ,
#[ doc = " LPTMR0 " ]
pub LPTMR0 : LPTMR0 ,
#[ 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 = " FLEXIO " ]
pub FLEXIO : FLEXIO ,
#[ doc = " TRGMUX " ]
pub TRGMUX : TRGMUX ,
#[ doc = " SCG " ]
pub SCG : SCG ,
#[ doc = " PCC " ]
pub PCC : PCC ,
#[ doc = " LPI2C0 " ]
pub LPI2C0 : LPI2C0 ,
#[ doc = " LPUART0 " ]
pub LPUART0 : LPUART0 ,
#[ doc = " LPUART1 " ]
pub LPUART1 : LPUART1 ,
#[ doc = " CMP0 " ]
pub CMP0 : CMP0 ,
#[ doc = " PMC " ]
pub PMC : PMC ,
#[ doc = " SMC " ]
pub SMC : SMC ,
#[ doc = " RCM " ]
pub RCM : RCM ,
#[ doc = " PTA " ]
pub PTA : PTA ,
#[ doc = " PTB " ]
pub PTB : PTB ,
#[ doc = " PTC " ]
pub PTC : PTC ,
#[ doc = " PTD " ]
pub PTD : PTD ,
#[ doc = " PTE " ]
pub PTE : PTE ,
#[ doc = " S32_SCB " ]
pub S32_SCB : S32_SCB ,
#[ doc = " S32_SYSTICK " ]
pub S32_SYSTICK : S32_SYSTICK ,
#[ doc = " S32_NVIC " ]
pub S32_NVIC : S32_NVIC ,
#[ doc = " LMEM " ]
pub LMEM : LMEM ,
#[ doc = " MCM " ]
pub MCM : MCM ,
}
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` " ]
#[ inline ]
pub unsafe fn steal ( ) -> Self {
DEVICE_PERIPHERALS = true ;
Peripherals {
CSE_PRAM : CSE_PRAM { _marker : PhantomData } ,
AIPS : AIPS { _marker : PhantomData } ,
MSCM : MSCM { _marker : PhantomData } ,
DMA : DMA { _marker : PhantomData } ,
ERM : ERM { _marker : PhantomData } ,
EIM : EIM { _marker : PhantomData } ,
FTFC : FTFC { _marker : PhantomData } ,
DMAMUX : DMAMUX { _marker : PhantomData } ,
CAN0 : CAN0 { _marker : PhantomData } ,
LPSPI0 : LPSPI0 { _marker : PhantomData } ,
LPSPI1 : LPSPI1 { _marker : PhantomData } ,
CRC : CRC { _marker : PhantomData } ,
PDB0 : PDB0 { _marker : PhantomData } ,
LPIT0 : LPIT0 { _marker : PhantomData } ,
FTM0 : FTM0 { _marker : PhantomData } ,
FTM1 : FTM1 { _marker : PhantomData } ,
ADC0 : ADC0 { _marker : PhantomData } ,
RTC : RTC { _marker : PhantomData } ,
CMU_FC_0 : CMU_FC_0 { _marker : PhantomData } ,
CMU_FC_1 : CMU_FC_1 { _marker : PhantomData } ,
LPTMR0 : LPTMR0 { _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 } ,
FLEXIO : FLEXIO { _marker : PhantomData } ,
TRGMUX : TRGMUX { _marker : PhantomData } ,
SCG : SCG { _marker : PhantomData } ,
PCC : PCC { _marker : PhantomData } ,
LPI2C0 : LPI2C0 { _marker : PhantomData } ,
LPUART0 : LPUART0 { _marker : PhantomData } ,
LPUART1 : LPUART1 { _marker : PhantomData } ,
CMP0 : CMP0 { _marker : PhantomData } ,
PMC : PMC { _marker : PhantomData } ,
SMC : SMC { _marker : PhantomData } ,
RCM : RCM { _marker : PhantomData } ,
PTA : PTA { _marker : PhantomData } ,
PTB : PTB { _marker : PhantomData } ,
PTC : PTC { _marker : PhantomData } ,
PTD : PTD { _marker : PhantomData } ,
PTE : PTE { _marker : PhantomData } ,
S32_SCB : S32_SCB { _marker : PhantomData } ,
S32_SYSTICK : S32_SYSTICK { _marker : PhantomData } ,
S32_NVIC : S32_NVIC { _marker : PhantomData } ,
LMEM : LMEM { _marker : PhantomData } ,
MCM : MCM { _marker : PhantomData } ,
}
}
}