efm32pg23-pac 0.1.2

#![doc = "Peripheral access API for EFM32PG23B200F128IM40 microcontrollers (generated using svd2rust v0.28.0 ( ))\n\nYou can find an overview of the generated API [here].\n\nAPI features to be included in the [next]
svd2rust release can be generated by cloning the svd2rust [repository], checking out the above commit, and running `cargo doc --open`.\n\n[here]: https://docs.rs/svd2rust/0.28.0/svd2rust/#peripheral-api\n[next]: https://github.com/rust-embedded/svd2rust/blob/master/CHANGELOG.md#unreleased\n[repository]: https://github.com/rust-embedded/svd2rust"]
#[cfg(feature = "rt")]
pub use self::Interrupt as interrupt;
use core::marker::PhantomData;
use core::ops::Deref;
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;
#[cfg(feature = "rt")]
extern "C" {
    fn SMU_SECURE();
    fn SMU_S_PRIVILEGED();
    fn EMU();
    fn TIMER0();
    fn TIMER1();
    fn TIMER2();
    fn TIMER3();
    fn TIMER4();
    fn USART0_RX();
    fn USART0_TX();
    fn EUSART0_RX();
    fn EUSART0_TX();
    fn EUSART1_RX();
    fn EUSART1_TX();
    fn EUSART2_RX();
    fn EUSART2_TX();
    fn ICACHE0();
    fn BURTC();
    fn LETIMER0();
    fn SYSCFG();
    fn LDMA();
    fn LFXO();
    fn LFRCO();
    fn ULFRCO();
    fn GPIO_ODD();
    fn GPIO_EVEN();
    fn I2C0();
    fn I2C1();
    fn EMUDG();
    fn ACMP0();
    fn ACMP1();
    fn WDOG0();
    fn WDOG1();
    fn HFXO0();
    fn HFRCO0();
    fn HFRCOEM23();
    fn CMU();
    fn IADC();
    fn MSC();
    fn DPLL0();
    fn VDAC();
    fn PCNT0();
    fn SW0();
    fn SW1();
    fn SW2();
    fn SW3();
    fn SEMBRX();
    fn SEMBTX();
    fn LCD();
    fn KEYSCAN();
}
#[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; 74] = [
    Vector {
        _handler: SMU_SECURE,
    },
    Vector {
        _handler: SMU_S_PRIVILEGED,
    },
    Vector { _reserved: 0 },
    Vector { _handler: EMU },
    Vector { _handler: TIMER0 },
    Vector { _handler: TIMER1 },
    Vector { _handler: TIMER2 },
    Vector { _handler: TIMER3 },
    Vector { _handler: TIMER4 },
    Vector {
        _handler: USART0_RX,
    },
    Vector {
        _handler: USART0_TX,
    },
    Vector {
        _handler: EUSART0_RX,
    },
    Vector {
        _handler: EUSART0_TX,
    },
    Vector {
        _handler: EUSART1_RX,
    },
    Vector {
        _handler: EUSART1_TX,
    },
    Vector {
        _handler: EUSART2_RX,
    },
    Vector {
        _handler: EUSART2_TX,
    },
    Vector { _handler: ICACHE0 },
    Vector { _handler: BURTC },
    Vector { _handler: LETIMER0 },
    Vector { _handler: SYSCFG },
    Vector { _reserved: 0 },
    Vector { _handler: LDMA },
    Vector { _handler: LFXO },
    Vector { _handler: LFRCO },
    Vector { _handler: ULFRCO },
    Vector { _handler: GPIO_ODD },
    Vector {
        _handler: GPIO_EVEN,
    },
    Vector { _handler: I2C0 },
    Vector { _handler: I2C1 },
    Vector { _handler: EMUDG },
    Vector { _reserved: 0 },
    Vector { _reserved: 0 },
    Vector { _reserved: 0 },
    Vector { _reserved: 0 },
    Vector { _reserved: 0 },
    Vector { _reserved: 0 },
    Vector { _reserved: 0 },
    Vector { _reserved: 0 },
    Vector { _reserved: 0 },
    Vector { _reserved: 0 },
    Vector { _handler: ACMP0 },
    Vector { _handler: ACMP1 },
    Vector { _handler: WDOG0 },
    Vector { _handler: WDOG1 },
    Vector { _handler: HFXO0 },
    Vector { _handler: HFRCO0 },
    Vector {
        _handler: HFRCOEM23,
    },
    Vector { _handler: CMU },
    Vector { _reserved: 0 },
    Vector { _handler: IADC },
    Vector { _handler: MSC },
    Vector { _handler: DPLL0 },
    Vector { _reserved: 0 },
    Vector { _reserved: 0 },
    Vector { _handler: VDAC },
    Vector { _handler: PCNT0 },
    Vector { _handler: SW0 },
    Vector { _handler: SW1 },
    Vector { _handler: SW2 },
    Vector { _handler: SW3 },
    Vector { _reserved: 0 },
    Vector { _reserved: 0 },
    Vector { _reserved: 0 },
    Vector { _reserved: 0 },
    Vector { _reserved: 0 },
    Vector { _reserved: 0 },
    Vector { _handler: SEMBRX },
    Vector { _handler: SEMBTX },
    Vector { _reserved: 0 },
    Vector { _reserved: 0 },
    Vector { _reserved: 0 },
    Vector { _handler: LCD },
    Vector { _handler: KEYSCAN },
];
#[doc = r"Enumeration of all the interrupts."]
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
#[repr(u16)]
pub enum Interrupt {
    #[doc = "0 - SMU_SECURE"]
    SMU_SECURE = 0,
    #[doc = "1 - SMU_S_PRIVILEGED"]
    SMU_S_PRIVILEGED = 1,
    #[doc = "3 - EMU"]
    EMU = 3,
    #[doc = "4 - TIMER0"]
    TIMER0 = 4,
    #[doc = "5 - TIMER1"]
    TIMER1 = 5,
    #[doc = "6 - TIMER2"]
    TIMER2 = 6,
    #[doc = "7 - TIMER3"]
    TIMER3 = 7,
    #[doc = "8 - TIMER4"]
    TIMER4 = 8,
    #[doc = "9 - USART0_RX"]
    USART0_RX = 9,
    #[doc = "10 - USART0_TX"]
    USART0_TX = 10,
    #[doc = "11 - EUSART0_RX"]
    EUSART0_RX = 11,
    #[doc = "12 - EUSART0_TX"]
    EUSART0_TX = 12,
    #[doc = "13 - EUSART1_RX"]
    EUSART1_RX = 13,
    #[doc = "14 - EUSART1_TX"]
    EUSART1_TX = 14,
    #[doc = "15 - EUSART2_RX"]
    EUSART2_RX = 15,
    #[doc = "16 - EUSART2_TX"]
    EUSART2_TX = 16,
    #[doc = "17 - ICACHE0"]
    ICACHE0 = 17,
    #[doc = "18 - BURTC"]
    BURTC = 18,
    #[doc = "19 - LETIMER0"]
    LETIMER0 = 19,
    #[doc = "20 - SYSCFG"]
    SYSCFG = 20,
    #[doc = "22 - LDMA"]
    LDMA = 22,
    #[doc = "23 - LFXO"]
    LFXO = 23,
    #[doc = "24 - LFRCO"]
    LFRCO = 24,
    #[doc = "25 - ULFRCO"]
    ULFRCO = 25,
    #[doc = "26 - GPIO_ODD"]
    GPIO_ODD = 26,
    #[doc = "27 - GPIO_EVEN"]
    GPIO_EVEN = 27,
    #[doc = "28 - I2C0"]
    I2C0 = 28,
    #[doc = "29 - I2C1"]
    I2C1 = 29,
    #[doc = "30 - EMUDG"]
    EMUDG = 30,
    #[doc = "41 - ACMP0"]
    ACMP0 = 41,
    #[doc = "42 - ACMP1"]
    ACMP1 = 42,
    #[doc = "43 - WDOG0"]
    WDOG0 = 43,
    #[doc = "44 - WDOG1"]
    WDOG1 = 44,
    #[doc = "45 - HFXO0"]
    HFXO0 = 45,
    #[doc = "46 - HFRCO0"]
    HFRCO0 = 46,
    #[doc = "47 - HFRCOEM23"]
    HFRCOEM23 = 47,
    #[doc = "48 - CMU"]
    CMU = 48,
    #[doc = "50 - IADC"]
    IADC = 50,
    #[doc = "51 - MSC"]
    MSC = 51,
    #[doc = "52 - DPLL0"]
    DPLL0 = 52,
    #[doc = "55 - VDAC"]
    VDAC = 55,
    #[doc = "56 - PCNT0"]
    PCNT0 = 56,
    #[doc = "57 - SW0"]
    SW0 = 57,
    #[doc = "58 - SW1"]
    SW1 = 58,
    #[doc = "59 - SW2"]
    SW2 = 59,
    #[doc = "60 - SW3"]
    SW3 = 60,
    #[doc = "67 - SEMBRX"]
    SEMBRX = 67,
    #[doc = "68 - SEMBTX"]
    SEMBTX = 68,
    #[doc = "72 - LCD"]
    LCD = 72,
    #[doc = "73 - KEYSCAN"]
    KEYSCAN = 73,
}
unsafe impl cortex_m::interrupt::InterruptNumber for Interrupt {
    #[inline(always)]
    fn number(self) -> u16 {
        self as u16
    }
}
#[doc = "SCRATCHPAD_S Registers"]
pub struct SCRATCHPAD_S {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for SCRATCHPAD_S {}
impl SCRATCHPAD_S {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const scratchpad_s::RegisterBlock = 0x4000_0000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const scratchpad_s::RegisterBlock {
        Self::PTR
    }
}
impl Deref for SCRATCHPAD_S {
    type Target = scratchpad_s::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for SCRATCHPAD_S {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("SCRATCHPAD_S").finish()
    }
}
#[doc = "SCRATCHPAD_S Registers"]
pub mod scratchpad_s;
#[doc = "EMU_S Registers"]
pub struct EMU_S {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for EMU_S {}
impl EMU_S {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const emu_s::RegisterBlock = 0x4000_4000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const emu_s::RegisterBlock {
        Self::PTR
    }
}
impl Deref for EMU_S {
    type Target = emu_s::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for EMU_S {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("EMU_S").finish()
    }
}
#[doc = "EMU_S Registers"]
pub mod emu_s;
#[doc = "CMU_S Registers"]
pub struct CMU_S {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for CMU_S {}
impl CMU_S {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const cmu_s::RegisterBlock = 0x4000_8000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const cmu_s::RegisterBlock {
        Self::PTR
    }
}
impl Deref for CMU_S {
    type Target = cmu_s::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for CMU_S {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("CMU_S").finish()
    }
}
#[doc = "CMU_S Registers"]
pub mod cmu_s;
#[doc = "HFRCO0_S Registers"]
pub struct HFRCO0_S {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for HFRCO0_S {}
impl HFRCO0_S {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const hfrco0_s::RegisterBlock = 0x4001_0000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const hfrco0_s::RegisterBlock {
        Self::PTR
    }
}
impl Deref for HFRCO0_S {
    type Target = hfrco0_s::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for HFRCO0_S {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("HFRCO0_S").finish()
    }
}
#[doc = "HFRCO0_S Registers"]
pub mod hfrco0_s;
#[doc = "FSRCO_S Registers"]
pub struct FSRCO_S {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for FSRCO_S {}
impl FSRCO_S {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const fsrco_s::RegisterBlock = 0x4001_8000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const fsrco_s::RegisterBlock {
        Self::PTR
    }
}
impl Deref for FSRCO_S {
    type Target = fsrco_s::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for FSRCO_S {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("FSRCO_S").finish()
    }
}
#[doc = "FSRCO_S Registers"]
pub mod fsrco_s;
#[doc = "DPLL0_S Registers"]
pub struct DPLL0_S {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for DPLL0_S {}
impl DPLL0_S {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const dpll0_s::RegisterBlock = 0x4001_c000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const dpll0_s::RegisterBlock {
        Self::PTR
    }
}
impl Deref for DPLL0_S {
    type Target = dpll0_s::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for DPLL0_S {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("DPLL0_S").finish()
    }
}
#[doc = "DPLL0_S Registers"]
pub mod dpll0_s;
#[doc = "LFXO_S Registers"]
pub struct LFXO_S {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for LFXO_S {}
impl LFXO_S {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const lfxo_s::RegisterBlock = 0x4002_0000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const lfxo_s::RegisterBlock {
        Self::PTR
    }
}
impl Deref for LFXO_S {
    type Target = lfxo_s::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for LFXO_S {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("LFXO_S").finish()
    }
}
#[doc = "LFXO_S Registers"]
pub mod lfxo_s;
#[doc = "LFRCO_S Registers"]
pub struct LFRCO_S {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for LFRCO_S {}
impl LFRCO_S {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const lfrco_s::RegisterBlock = 0x4002_4000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const lfrco_s::RegisterBlock {
        Self::PTR
    }
}
impl Deref for LFRCO_S {
    type Target = lfrco_s::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for LFRCO_S {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("LFRCO_S").finish()
    }
}
#[doc = "LFRCO_S Registers"]
pub mod lfrco_s;
#[doc = "ULFRCO_S Registers"]
pub struct ULFRCO_S {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for ULFRCO_S {}
impl ULFRCO_S {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const ulfrco_s::RegisterBlock = 0x4002_8000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const ulfrco_s::RegisterBlock {
        Self::PTR
    }
}
impl Deref for ULFRCO_S {
    type Target = ulfrco_s::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for ULFRCO_S {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("ULFRCO_S").finish()
    }
}
#[doc = "ULFRCO_S Registers"]
pub mod ulfrco_s;
#[doc = "MSC_S Registers"]
pub struct MSC_S {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for MSC_S {}
impl MSC_S {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const msc_s::RegisterBlock = 0x4003_0000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const msc_s::RegisterBlock {
        Self::PTR
    }
}
impl Deref for MSC_S {
    type Target = msc_s::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for MSC_S {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("MSC_S").finish()
    }
}
#[doc = "MSC_S Registers"]
pub mod msc_s;
#[doc = "ICACHE0_S Registers"]
pub struct ICACHE0_S {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for ICACHE0_S {}
impl ICACHE0_S {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const icache0_s::RegisterBlock = 0x4003_4000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const icache0_s::RegisterBlock {
        Self::PTR
    }
}
impl Deref for ICACHE0_S {
    type Target = icache0_s::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for ICACHE0_S {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("ICACHE0_S").finish()
    }
}
#[doc = "ICACHE0_S Registers"]
pub mod icache0_s;
#[doc = "PRS_S Registers"]
pub struct PRS_S {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for PRS_S {}
impl PRS_S {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const prs_s::RegisterBlock = 0x4003_8000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const prs_s::RegisterBlock {
        Self::PTR
    }
}
impl Deref for PRS_S {
    type Target = prs_s::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for PRS_S {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("PRS_S").finish()
    }
}
#[doc = "PRS_S Registers"]
pub mod prs_s;
#[doc = "GPIO_S Registers"]
pub struct GPIO_S {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for GPIO_S {}
impl GPIO_S {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const gpio_s::RegisterBlock = 0x4003_c000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const gpio_s::RegisterBlock {
        Self::PTR
    }
}
impl Deref for GPIO_S {
    type Target = gpio_s::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for GPIO_S {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("GPIO_S").finish()
    }
}
#[doc = "GPIO_S Registers"]
pub mod gpio_s;
#[doc = "LDMA_S Registers"]
pub struct LDMA_S {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for LDMA_S {}
impl LDMA_S {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const ldma_s::RegisterBlock = 0x4004_0000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const ldma_s::RegisterBlock {
        Self::PTR
    }
}
impl Deref for LDMA_S {
    type Target = ldma_s::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for LDMA_S {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("LDMA_S").finish()
    }
}
#[doc = "LDMA_S Registers"]
pub mod ldma_s;
#[doc = "LDMAXBAR_S Registers"]
pub struct LDMAXBAR_S {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for LDMAXBAR_S {}
impl LDMAXBAR_S {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const ldmaxbar_s::RegisterBlock = 0x4004_4000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const ldmaxbar_s::RegisterBlock {
        Self::PTR
    }
}
impl Deref for LDMAXBAR_S {
    type Target = ldmaxbar_s::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for LDMAXBAR_S {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("LDMAXBAR_S").finish()
    }
}
#[doc = "LDMAXBAR_S Registers"]
pub mod ldmaxbar_s;
#[doc = "TIMER0_S Registers"]
pub struct TIMER0_S {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for TIMER0_S {}
impl TIMER0_S {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const timer0_s::RegisterBlock = 0x4004_8000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const timer0_s::RegisterBlock {
        Self::PTR
    }
}
impl Deref for TIMER0_S {
    type Target = timer0_s::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for TIMER0_S {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("TIMER0_S").finish()
    }
}
#[doc = "TIMER0_S Registers"]
pub mod timer0_s;
#[doc = "TIMER1_S Registers"]
pub struct TIMER1_S {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for TIMER1_S {}
impl TIMER1_S {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const timer1_s::RegisterBlock = 0x4004_c000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const timer1_s::RegisterBlock {
        Self::PTR
    }
}
impl Deref for TIMER1_S {
    type Target = timer1_s::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for TIMER1_S {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("TIMER1_S").finish()
    }
}
#[doc = "TIMER1_S Registers"]
pub mod timer1_s;
#[doc = "TIMER2_S Registers"]
pub struct TIMER2_S {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for TIMER2_S {}
impl TIMER2_S {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const timer2_s::RegisterBlock = 0x4005_0000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const timer2_s::RegisterBlock {
        Self::PTR
    }
}
impl Deref for TIMER2_S {
    type Target = timer2_s::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for TIMER2_S {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("TIMER2_S").finish()
    }
}
#[doc = "TIMER2_S Registers"]
pub mod timer2_s;
#[doc = "TIMER3_S Registers"]
pub struct TIMER3_S {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for TIMER3_S {}
impl TIMER3_S {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const timer3_s::RegisterBlock = 0x4005_4000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const timer3_s::RegisterBlock {
        Self::PTR
    }
}
impl Deref for TIMER3_S {
    type Target = timer3_s::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for TIMER3_S {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("TIMER3_S").finish()
    }
}
#[doc = "TIMER3_S Registers"]
pub mod timer3_s;
#[doc = "TIMER4_S Registers"]
pub struct TIMER4_S {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for TIMER4_S {}
impl TIMER4_S {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const timer4_s::RegisterBlock = 0x4005_8000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const timer4_s::RegisterBlock {
        Self::PTR
    }
}
impl Deref for TIMER4_S {
    type Target = timer4_s::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for TIMER4_S {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("TIMER4_S").finish()
    }
}
#[doc = "TIMER4_S Registers"]
pub mod timer4_s;
#[doc = "USART0_S Registers"]
pub struct USART0_S {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for USART0_S {}
impl USART0_S {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const usart0_s::RegisterBlock = 0x4005_c000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const usart0_s::RegisterBlock {
        Self::PTR
    }
}
impl Deref for USART0_S {
    type Target = usart0_s::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for USART0_S {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("USART0_S").finish()
    }
}
#[doc = "USART0_S Registers"]
pub mod usart0_s;
#[doc = "BURTC_S Registers"]
pub struct BURTC_S {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for BURTC_S {}
impl BURTC_S {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const burtc_s::RegisterBlock = 0x4006_4000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const burtc_s::RegisterBlock {
        Self::PTR
    }
}
impl Deref for BURTC_S {
    type Target = burtc_s::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for BURTC_S {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("BURTC_S").finish()
    }
}
#[doc = "BURTC_S Registers"]
pub mod burtc_s;
#[doc = "I2C1_S Registers"]
pub struct I2C1_S {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for I2C1_S {}
impl I2C1_S {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const i2c1_s::RegisterBlock = 0x4006_8000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const i2c1_s::RegisterBlock {
        Self::PTR
    }
}
impl Deref for I2C1_S {
    type Target = i2c1_s::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for I2C1_S {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("I2C1_S").finish()
    }
}
#[doc = "I2C1_S Registers"]
pub mod i2c1_s;
#[doc = "SYSCFG_S_CFGNS Registers"]
pub struct SYSCFG_S_CFGNS {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for SYSCFG_S_CFGNS {}
impl SYSCFG_S_CFGNS {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const syscfg_s_cfgns::RegisterBlock = 0x4007_8000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const syscfg_s_cfgns::RegisterBlock {
        Self::PTR
    }
}
impl Deref for SYSCFG_S_CFGNS {
    type Target = syscfg_s_cfgns::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for SYSCFG_S_CFGNS {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("SYSCFG_S_CFGNS").finish()
    }
}
#[doc = "SYSCFG_S_CFGNS Registers"]
pub mod syscfg_s_cfgns;
#[doc = "SYSCFG_S Registers"]
pub struct SYSCFG_S {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for SYSCFG_S {}
impl SYSCFG_S {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const syscfg_s::RegisterBlock = 0x4007_c000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const syscfg_s::RegisterBlock {
        Self::PTR
    }
}
impl Deref for SYSCFG_S {
    type Target = syscfg_s::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for SYSCFG_S {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("SYSCFG_S").finish()
    }
}
#[doc = "SYSCFG_S Registers"]
pub mod syscfg_s;
#[doc = "BURAM_S Registers"]
pub struct BURAM_S {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for BURAM_S {}
impl BURAM_S {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const buram_s::RegisterBlock = 0x4008_0000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const buram_s::RegisterBlock {
        Self::PTR
    }
}
impl Deref for BURAM_S {
    type Target = buram_s::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for BURAM_S {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("BURAM_S").finish()
    }
}
#[doc = "BURAM_S Registers"]
pub mod buram_s;
#[doc = "GPCRC_S Registers"]
pub struct GPCRC_S {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for GPCRC_S {}
impl GPCRC_S {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const gpcrc_s::RegisterBlock = 0x4008_8000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const gpcrc_s::RegisterBlock {
        Self::PTR
    }
}
impl Deref for GPCRC_S {
    type Target = gpcrc_s::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for GPCRC_S {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("GPCRC_S").finish()
    }
}
#[doc = "GPCRC_S Registers"]
pub mod gpcrc_s;
#[doc = "DCDC_S Registers"]
pub struct DCDC_S {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for DCDC_S {}
impl DCDC_S {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const dcdc_s::RegisterBlock = 0x4009_4000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const dcdc_s::RegisterBlock {
        Self::PTR
    }
}
impl Deref for DCDC_S {
    type Target = dcdc_s::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for DCDC_S {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("DCDC_S").finish()
    }
}
#[doc = "DCDC_S Registers"]
pub mod dcdc_s;
#[doc = "HOSTMAILBOX_S Registers"]
pub struct HOSTMAILBOX_S {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for HOSTMAILBOX_S {}
impl HOSTMAILBOX_S {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const hostmailbox_s::RegisterBlock = 0x4009_8000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const hostmailbox_s::RegisterBlock {
        Self::PTR
    }
}
impl Deref for HOSTMAILBOX_S {
    type Target = hostmailbox_s::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for HOSTMAILBOX_S {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("HOSTMAILBOX_S").finish()
    }
}
#[doc = "HOSTMAILBOX_S Registers"]
pub mod hostmailbox_s;
#[doc = "EUSART1_S Registers"]
pub struct EUSART1_S {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for EUSART1_S {}
impl EUSART1_S {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const eusart1_s::RegisterBlock = 0x400a_0000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const eusart1_s::RegisterBlock {
        Self::PTR
    }
}
impl Deref for EUSART1_S {
    type Target = eusart1_s::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for EUSART1_S {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("EUSART1_S").finish()
    }
}
#[doc = "EUSART1_S Registers"]
pub mod eusart1_s;
#[doc = "EUSART2_S Registers"]
pub struct EUSART2_S {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for EUSART2_S {}
impl EUSART2_S {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const eusart2_s::RegisterBlock = 0x400a_4000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const eusart2_s::RegisterBlock {
        Self::PTR
    }
}
impl Deref for EUSART2_S {
    type Target = eusart2_s::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for EUSART2_S {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("EUSART2_S").finish()
    }
}
#[doc = "EUSART2_S Registers"]
pub mod eusart2_s;
#[doc = "SYSRTC0_S Registers"]
pub struct SYSRTC0_S {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for SYSRTC0_S {}
impl SYSRTC0_S {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const sysrtc0_s::RegisterBlock = 0x400a_8000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const sysrtc0_s::RegisterBlock {
        Self::PTR
    }
}
impl Deref for SYSRTC0_S {
    type Target = sysrtc0_s::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for SYSRTC0_S {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("SYSRTC0_S").finish()
    }
}
#[doc = "SYSRTC0_S Registers"]
pub mod sysrtc0_s;
#[doc = "LCD_S Registers"]
pub struct LCD_S {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for LCD_S {}
impl LCD_S {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const lcd_s::RegisterBlock = 0x400a_c000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const lcd_s::RegisterBlock {
        Self::PTR
    }
}
impl Deref for LCD_S {
    type Target = lcd_s::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for LCD_S {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("LCD_S").finish()
    }
}
#[doc = "LCD_S Registers"]
pub mod lcd_s;
#[doc = "KEYSCAN_S Registers"]
pub struct KEYSCAN_S {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for KEYSCAN_S {}
impl KEYSCAN_S {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const keyscan_s::RegisterBlock = 0x400b_0000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const keyscan_s::RegisterBlock {
        Self::PTR
    }
}
impl Deref for KEYSCAN_S {
    type Target = keyscan_s::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for KEYSCAN_S {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("KEYSCAN_S").finish()
    }
}
#[doc = "KEYSCAN_S Registers"]
pub mod keyscan_s;
#[doc = "DMEM_S Registers"]
pub struct DMEM_S {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for DMEM_S {}
impl DMEM_S {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const dmem_s::RegisterBlock = 0x400b_4000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const dmem_s::RegisterBlock {
        Self::PTR
    }
}
impl Deref for DMEM_S {
    type Target = dmem_s::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for DMEM_S {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("DMEM_S").finish()
    }
}
#[doc = "DMEM_S Registers"]
pub mod dmem_s;
#[doc = "LCDRF_S Registers"]
pub struct LCDRF_S {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for LCDRF_S {}
impl LCDRF_S {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const lcdrf_s::RegisterBlock = 0x400c_0000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const lcdrf_s::RegisterBlock {
        Self::PTR
    }
}
impl Deref for LCDRF_S {
    type Target = lcdrf_s::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for LCDRF_S {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("LCDRF_S").finish()
    }
}
#[doc = "LCDRF_S Registers"]
pub mod lcdrf_s;
#[doc = "SMU_S Registers"]
pub struct SMU_S {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for SMU_S {}
impl SMU_S {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const smu_s::RegisterBlock = 0x4400_8000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const smu_s::RegisterBlock {
        Self::PTR
    }
}
impl Deref for SMU_S {
    type Target = smu_s::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for SMU_S {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("SMU_S").finish()
    }
}
#[doc = "SMU_S Registers"]
pub mod smu_s;
#[doc = "SMU_S_CFGNS Registers"]
pub struct SMU_S_CFGNS {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for SMU_S_CFGNS {}
impl SMU_S_CFGNS {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const smu_s_cfgns::RegisterBlock = 0x4400_c000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const smu_s_cfgns::RegisterBlock {
        Self::PTR
    }
}
impl Deref for SMU_S_CFGNS {
    type Target = smu_s_cfgns::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for SMU_S_CFGNS {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("SMU_S_CFGNS").finish()
    }
}
#[doc = "SMU_S_CFGNS Registers"]
pub mod smu_s_cfgns;
#[doc = "LETIMER0_S Registers"]
pub struct LETIMER0_S {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for LETIMER0_S {}
impl LETIMER0_S {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const letimer0_s::RegisterBlock = 0x4900_0000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const letimer0_s::RegisterBlock {
        Self::PTR
    }
}
impl Deref for LETIMER0_S {
    type Target = letimer0_s::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for LETIMER0_S {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("LETIMER0_S").finish()
    }
}
#[doc = "LETIMER0_S Registers"]
pub mod letimer0_s;
#[doc = "IADC0_S Registers"]
pub struct IADC0_S {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for IADC0_S {}
impl IADC0_S {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const iadc0_s::RegisterBlock = 0x4900_4000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const iadc0_s::RegisterBlock {
        Self::PTR
    }
}
impl Deref for IADC0_S {
    type Target = iadc0_s::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for IADC0_S {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("IADC0_S").finish()
    }
}
#[doc = "IADC0_S Registers"]
pub mod iadc0_s;
#[doc = "ACMP0_S Registers"]
pub struct ACMP0_S {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for ACMP0_S {}
impl ACMP0_S {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const acmp0_s::RegisterBlock = 0x4900_8000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const acmp0_s::RegisterBlock {
        Self::PTR
    }
}
impl Deref for ACMP0_S {
    type Target = acmp0_s::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for ACMP0_S {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("ACMP0_S").finish()
    }
}
#[doc = "ACMP0_S Registers"]
pub mod acmp0_s;
#[doc = "ACMP1_S Registers"]
pub struct ACMP1_S {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for ACMP1_S {}
impl ACMP1_S {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const acmp1_s::RegisterBlock = 0x4900_c000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const acmp1_s::RegisterBlock {
        Self::PTR
    }
}
impl Deref for ACMP1_S {
    type Target = acmp1_s::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for ACMP1_S {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("ACMP1_S").finish()
    }
}
#[doc = "ACMP1_S Registers"]
pub mod acmp1_s;
#[doc = "AMUXCP0_S Registers"]
pub struct AMUXCP0_S {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for AMUXCP0_S {}
impl AMUXCP0_S {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const amuxcp0_s::RegisterBlock = 0x4902_0000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const amuxcp0_s::RegisterBlock {
        Self::PTR
    }
}
impl Deref for AMUXCP0_S {
    type Target = amuxcp0_s::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for AMUXCP0_S {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("AMUXCP0_S").finish()
    }
}
#[doc = "AMUXCP0_S Registers"]
pub mod amuxcp0_s;
#[doc = "VDAC0_S Registers"]
pub struct VDAC0_S {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for VDAC0_S {}
impl VDAC0_S {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const vdac0_s::RegisterBlock = 0x4902_4000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const vdac0_s::RegisterBlock {
        Self::PTR
    }
}
impl Deref for VDAC0_S {
    type Target = vdac0_s::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for VDAC0_S {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("VDAC0_S").finish()
    }
}
#[doc = "VDAC0_S Registers"]
pub mod vdac0_s;
#[doc = "PCNT0_S Registers"]
pub struct PCNT0_S {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for PCNT0_S {}
impl PCNT0_S {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const pcnt0_s::RegisterBlock = 0x4903_0000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const pcnt0_s::RegisterBlock {
        Self::PTR
    }
}
impl Deref for PCNT0_S {
    type Target = pcnt0_s::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for PCNT0_S {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("PCNT0_S").finish()
    }
}
#[doc = "PCNT0_S Registers"]
pub mod pcnt0_s;
#[doc = "LESENSE_S Registers"]
pub struct LESENSE_S {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for LESENSE_S {}
impl LESENSE_S {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const lesense_s::RegisterBlock = 0x4903_8000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const lesense_s::RegisterBlock {
        Self::PTR
    }
}
impl Deref for LESENSE_S {
    type Target = lesense_s::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for LESENSE_S {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("LESENSE_S").finish()
    }
}
#[doc = "LESENSE_S Registers"]
pub mod lesense_s;
#[doc = "HFRCOEM23_S Registers"]
pub struct HFRCOEM23_S {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for HFRCOEM23_S {}
impl HFRCOEM23_S {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const hfrcoem23_s::RegisterBlock = 0x4a00_0000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const hfrcoem23_s::RegisterBlock {
        Self::PTR
    }
}
impl Deref for HFRCOEM23_S {
    type Target = hfrcoem23_s::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for HFRCOEM23_S {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("HFRCOEM23_S").finish()
    }
}
#[doc = "HFRCOEM23_S Registers"]
pub mod hfrcoem23_s;
#[doc = "HFXO0_S Registers"]
pub struct HFXO0_S {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for HFXO0_S {}
impl HFXO0_S {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const hfxo0_s::RegisterBlock = 0x4a00_4000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const hfxo0_s::RegisterBlock {
        Self::PTR
    }
}
impl Deref for HFXO0_S {
    type Target = hfxo0_s::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for HFXO0_S {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("HFXO0_S").finish()
    }
}
#[doc = "HFXO0_S Registers"]
pub mod hfxo0_s;
#[doc = "I2C0_S Registers"]
pub struct I2C0_S {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for I2C0_S {}
impl I2C0_S {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const i2c0_s::RegisterBlock = 0x4b00_0000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const i2c0_s::RegisterBlock {
        Self::PTR
    }
}
impl Deref for I2C0_S {
    type Target = i2c0_s::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for I2C0_S {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("I2C0_S").finish()
    }
}
#[doc = "I2C0_S Registers"]
pub mod i2c0_s;
#[doc = "WDOG0_S Registers"]
pub struct WDOG0_S {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for WDOG0_S {}
impl WDOG0_S {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const wdog0_s::RegisterBlock = 0x4b00_4000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const wdog0_s::RegisterBlock {
        Self::PTR
    }
}
impl Deref for WDOG0_S {
    type Target = wdog0_s::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for WDOG0_S {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("WDOG0_S").finish()
    }
}
#[doc = "WDOG0_S Registers"]
pub mod wdog0_s;
#[doc = "WDOG1_S Registers"]
pub struct WDOG1_S {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for WDOG1_S {}
impl WDOG1_S {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const wdog1_s::RegisterBlock = 0x4b00_8000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const wdog1_s::RegisterBlock {
        Self::PTR
    }
}
impl Deref for WDOG1_S {
    type Target = wdog1_s::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for WDOG1_S {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("WDOG1_S").finish()
    }
}
#[doc = "WDOG1_S Registers"]
pub mod wdog1_s;
#[doc = "EUSART0_S Registers"]
pub struct EUSART0_S {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for EUSART0_S {}
impl EUSART0_S {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const eusart0_s::RegisterBlock = 0x4b01_0000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const eusart0_s::RegisterBlock {
        Self::PTR
    }
}
impl Deref for EUSART0_S {
    type Target = eusart0_s::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for EUSART0_S {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("EUSART0_S").finish()
    }
}
#[doc = "EUSART0_S Registers"]
pub mod eusart0_s;
#[doc = "SEMAILBOX_S_HOST Registers"]
pub struct SEMAILBOX_S_HOST {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for SEMAILBOX_S_HOST {}
impl SEMAILBOX_S_HOST {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const semailbox_s_host::RegisterBlock = 0x4c00_0000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const semailbox_s_host::RegisterBlock {
        Self::PTR
    }
}
impl Deref for SEMAILBOX_S_HOST {
    type Target = semailbox_s_host::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for SEMAILBOX_S_HOST {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("SEMAILBOX_S_HOST").finish()
    }
}
#[doc = "SEMAILBOX_S_HOST Registers"]
pub mod semailbox_s_host;
#[doc = "SCRATCHPAD_NS Registers"]
pub struct SCRATCHPAD_NS {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for SCRATCHPAD_NS {}
impl SCRATCHPAD_NS {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const scratchpad_ns::RegisterBlock = 0x5000_0000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const scratchpad_ns::RegisterBlock {
        Self::PTR
    }
}
impl Deref for SCRATCHPAD_NS {
    type Target = scratchpad_ns::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for SCRATCHPAD_NS {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("SCRATCHPAD_NS").finish()
    }
}
#[doc = "SCRATCHPAD_NS Registers"]
pub mod scratchpad_ns;
#[doc = "EMU_NS Registers"]
pub struct EMU_NS {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for EMU_NS {}
impl EMU_NS {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const emu_ns::RegisterBlock = 0x5000_4000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const emu_ns::RegisterBlock {
        Self::PTR
    }
}
impl Deref for EMU_NS {
    type Target = emu_ns::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for EMU_NS {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("EMU_NS").finish()
    }
}
#[doc = "EMU_NS Registers"]
pub mod emu_ns;
#[doc = "CMU_NS Registers"]
pub struct CMU_NS {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for CMU_NS {}
impl CMU_NS {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const cmu_ns::RegisterBlock = 0x5000_8000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const cmu_ns::RegisterBlock {
        Self::PTR
    }
}
impl Deref for CMU_NS {
    type Target = cmu_ns::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for CMU_NS {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("CMU_NS").finish()
    }
}
#[doc = "CMU_NS Registers"]
pub mod cmu_ns;
#[doc = "HFRCO0_NS Registers"]
pub struct HFRCO0_NS {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for HFRCO0_NS {}
impl HFRCO0_NS {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const hfrco0_ns::RegisterBlock = 0x5001_0000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const hfrco0_ns::RegisterBlock {
        Self::PTR
    }
}
impl Deref for HFRCO0_NS {
    type Target = hfrco0_ns::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for HFRCO0_NS {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("HFRCO0_NS").finish()
    }
}
#[doc = "HFRCO0_NS Registers"]
pub mod hfrco0_ns;
#[doc = "FSRCO_NS Registers"]
pub struct FSRCO_NS {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for FSRCO_NS {}
impl FSRCO_NS {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const fsrco_ns::RegisterBlock = 0x5001_8000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const fsrco_ns::RegisterBlock {
        Self::PTR
    }
}
impl Deref for FSRCO_NS {
    type Target = fsrco_ns::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for FSRCO_NS {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("FSRCO_NS").finish()
    }
}
#[doc = "FSRCO_NS Registers"]
pub mod fsrco_ns;
#[doc = "DPLL0_NS Registers"]
pub struct DPLL0_NS {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for DPLL0_NS {}
impl DPLL0_NS {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const dpll0_ns::RegisterBlock = 0x5001_c000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const dpll0_ns::RegisterBlock {
        Self::PTR
    }
}
impl Deref for DPLL0_NS {
    type Target = dpll0_ns::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for DPLL0_NS {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("DPLL0_NS").finish()
    }
}
#[doc = "DPLL0_NS Registers"]
pub mod dpll0_ns;
#[doc = "LFXO_NS Registers"]
pub struct LFXO_NS {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for LFXO_NS {}
impl LFXO_NS {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const lfxo_ns::RegisterBlock = 0x5002_0000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const lfxo_ns::RegisterBlock {
        Self::PTR
    }
}
impl Deref for LFXO_NS {
    type Target = lfxo_ns::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for LFXO_NS {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("LFXO_NS").finish()
    }
}
#[doc = "LFXO_NS Registers"]
pub mod lfxo_ns;
#[doc = "LFRCO_NS Registers"]
pub struct LFRCO_NS {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for LFRCO_NS {}
impl LFRCO_NS {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const lfrco_ns::RegisterBlock = 0x5002_4000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const lfrco_ns::RegisterBlock {
        Self::PTR
    }
}
impl Deref for LFRCO_NS {
    type Target = lfrco_ns::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for LFRCO_NS {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("LFRCO_NS").finish()
    }
}
#[doc = "LFRCO_NS Registers"]
pub mod lfrco_ns;
#[doc = "ULFRCO_NS Registers"]
pub struct ULFRCO_NS {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for ULFRCO_NS {}
impl ULFRCO_NS {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const ulfrco_ns::RegisterBlock = 0x5002_8000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const ulfrco_ns::RegisterBlock {
        Self::PTR
    }
}
impl Deref for ULFRCO_NS {
    type Target = ulfrco_ns::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for ULFRCO_NS {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("ULFRCO_NS").finish()
    }
}
#[doc = "ULFRCO_NS Registers"]
pub mod ulfrco_ns;
#[doc = "MSC_NS Registers"]
pub struct MSC_NS {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for MSC_NS {}
impl MSC_NS {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const msc_ns::RegisterBlock = 0x5003_0000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const msc_ns::RegisterBlock {
        Self::PTR
    }
}
impl Deref for MSC_NS {
    type Target = msc_ns::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for MSC_NS {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("MSC_NS").finish()
    }
}
#[doc = "MSC_NS Registers"]
pub mod msc_ns;
#[doc = "ICACHE0_NS Registers"]
pub struct ICACHE0_NS {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for ICACHE0_NS {}
impl ICACHE0_NS {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const icache0_ns::RegisterBlock = 0x5003_4000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const icache0_ns::RegisterBlock {
        Self::PTR
    }
}
impl Deref for ICACHE0_NS {
    type Target = icache0_ns::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for ICACHE0_NS {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("ICACHE0_NS").finish()
    }
}
#[doc = "ICACHE0_NS Registers"]
pub mod icache0_ns;
#[doc = "PRS_NS Registers"]
pub struct PRS_NS {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for PRS_NS {}
impl PRS_NS {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const prs_ns::RegisterBlock = 0x5003_8000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const prs_ns::RegisterBlock {
        Self::PTR
    }
}
impl Deref for PRS_NS {
    type Target = prs_ns::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for PRS_NS {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("PRS_NS").finish()
    }
}
#[doc = "PRS_NS Registers"]
pub mod prs_ns;
#[doc = "GPIO_NS Registers"]
pub struct GPIO_NS {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for GPIO_NS {}
impl GPIO_NS {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const gpio_ns::RegisterBlock = 0x5003_c000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const gpio_ns::RegisterBlock {
        Self::PTR
    }
}
impl Deref for GPIO_NS {
    type Target = gpio_ns::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for GPIO_NS {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("GPIO_NS").finish()
    }
}
#[doc = "GPIO_NS Registers"]
pub mod gpio_ns;
#[doc = "LDMA_NS Registers"]
pub struct LDMA_NS {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for LDMA_NS {}
impl LDMA_NS {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const ldma_ns::RegisterBlock = 0x5004_0000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const ldma_ns::RegisterBlock {
        Self::PTR
    }
}
impl Deref for LDMA_NS {
    type Target = ldma_ns::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for LDMA_NS {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("LDMA_NS").finish()
    }
}
#[doc = "LDMA_NS Registers"]
pub mod ldma_ns;
#[doc = "LDMAXBAR_NS Registers"]
pub struct LDMAXBAR_NS {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for LDMAXBAR_NS {}
impl LDMAXBAR_NS {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const ldmaxbar_ns::RegisterBlock = 0x5004_4000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const ldmaxbar_ns::RegisterBlock {
        Self::PTR
    }
}
impl Deref for LDMAXBAR_NS {
    type Target = ldmaxbar_ns::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for LDMAXBAR_NS {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("LDMAXBAR_NS").finish()
    }
}
#[doc = "LDMAXBAR_NS Registers"]
pub mod ldmaxbar_ns;
#[doc = "TIMER0_NS Registers"]
pub struct TIMER0_NS {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for TIMER0_NS {}
impl TIMER0_NS {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const timer0_ns::RegisterBlock = 0x5004_8000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const timer0_ns::RegisterBlock {
        Self::PTR
    }
}
impl Deref for TIMER0_NS {
    type Target = timer0_ns::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for TIMER0_NS {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("TIMER0_NS").finish()
    }
}
#[doc = "TIMER0_NS Registers"]
pub mod timer0_ns;
#[doc = "TIMER1_NS Registers"]
pub struct TIMER1_NS {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for TIMER1_NS {}
impl TIMER1_NS {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const timer1_ns::RegisterBlock = 0x5004_c000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const timer1_ns::RegisterBlock {
        Self::PTR
    }
}
impl Deref for TIMER1_NS {
    type Target = timer1_ns::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for TIMER1_NS {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("TIMER1_NS").finish()
    }
}
#[doc = "TIMER1_NS Registers"]
pub mod timer1_ns;
#[doc = "TIMER2_NS Registers"]
pub struct TIMER2_NS {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for TIMER2_NS {}
impl TIMER2_NS {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const timer2_ns::RegisterBlock = 0x5005_0000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const timer2_ns::RegisterBlock {
        Self::PTR
    }
}
impl Deref for TIMER2_NS {
    type Target = timer2_ns::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for TIMER2_NS {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("TIMER2_NS").finish()
    }
}
#[doc = "TIMER2_NS Registers"]
pub mod timer2_ns;
#[doc = "TIMER3_NS Registers"]
pub struct TIMER3_NS {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for TIMER3_NS {}
impl TIMER3_NS {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const timer3_ns::RegisterBlock = 0x5005_4000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const timer3_ns::RegisterBlock {
        Self::PTR
    }
}
impl Deref for TIMER3_NS {
    type Target = timer3_ns::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for TIMER3_NS {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("TIMER3_NS").finish()
    }
}
#[doc = "TIMER3_NS Registers"]
pub mod timer3_ns;
#[doc = "TIMER4_NS Registers"]
pub struct TIMER4_NS {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for TIMER4_NS {}
impl TIMER4_NS {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const timer4_ns::RegisterBlock = 0x5005_8000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const timer4_ns::RegisterBlock {
        Self::PTR
    }
}
impl Deref for TIMER4_NS {
    type Target = timer4_ns::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for TIMER4_NS {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("TIMER4_NS").finish()
    }
}
#[doc = "TIMER4_NS Registers"]
pub mod timer4_ns;
#[doc = "USART0_NS Registers"]
pub struct USART0_NS {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for USART0_NS {}
impl USART0_NS {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const usart0_ns::RegisterBlock = 0x5005_c000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const usart0_ns::RegisterBlock {
        Self::PTR
    }
}
impl Deref for USART0_NS {
    type Target = usart0_ns::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for USART0_NS {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("USART0_NS").finish()
    }
}
#[doc = "USART0_NS Registers"]
pub mod usart0_ns;
#[doc = "BURTC_NS Registers"]
pub struct BURTC_NS {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for BURTC_NS {}
impl BURTC_NS {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const burtc_ns::RegisterBlock = 0x5006_4000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const burtc_ns::RegisterBlock {
        Self::PTR
    }
}
impl Deref for BURTC_NS {
    type Target = burtc_ns::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for BURTC_NS {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("BURTC_NS").finish()
    }
}
#[doc = "BURTC_NS Registers"]
pub mod burtc_ns;
#[doc = "I2C1_NS Registers"]
pub struct I2C1_NS {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for I2C1_NS {}
impl I2C1_NS {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const i2c1_ns::RegisterBlock = 0x5006_8000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const i2c1_ns::RegisterBlock {
        Self::PTR
    }
}
impl Deref for I2C1_NS {
    type Target = i2c1_ns::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for I2C1_NS {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("I2C1_NS").finish()
    }
}
#[doc = "I2C1_NS Registers"]
pub mod i2c1_ns;
#[doc = "SYSCFG_NS_CFGNS Registers"]
pub struct SYSCFG_NS_CFGNS {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for SYSCFG_NS_CFGNS {}
impl SYSCFG_NS_CFGNS {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const syscfg_ns_cfgns::RegisterBlock = 0x5007_8000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const syscfg_ns_cfgns::RegisterBlock {
        Self::PTR
    }
}
impl Deref for SYSCFG_NS_CFGNS {
    type Target = syscfg_ns_cfgns::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for SYSCFG_NS_CFGNS {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("SYSCFG_NS_CFGNS").finish()
    }
}
#[doc = "SYSCFG_NS_CFGNS Registers"]
pub mod syscfg_ns_cfgns;
#[doc = "SYSCFG_NS Registers"]
pub struct SYSCFG_NS {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for SYSCFG_NS {}
impl SYSCFG_NS {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const syscfg_ns::RegisterBlock = 0x5007_c000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const syscfg_ns::RegisterBlock {
        Self::PTR
    }
}
impl Deref for SYSCFG_NS {
    type Target = syscfg_ns::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for SYSCFG_NS {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("SYSCFG_NS").finish()
    }
}
#[doc = "SYSCFG_NS Registers"]
pub mod syscfg_ns;
#[doc = "BURAM_NS Registers"]
pub struct BURAM_NS {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for BURAM_NS {}
impl BURAM_NS {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const buram_ns::RegisterBlock = 0x5008_0000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const buram_ns::RegisterBlock {
        Self::PTR
    }
}
impl Deref for BURAM_NS {
    type Target = buram_ns::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for BURAM_NS {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("BURAM_NS").finish()
    }
}
#[doc = "BURAM_NS Registers"]
pub mod buram_ns;
#[doc = "GPCRC_NS Registers"]
pub struct GPCRC_NS {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for GPCRC_NS {}
impl GPCRC_NS {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const gpcrc_ns::RegisterBlock = 0x5008_8000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const gpcrc_ns::RegisterBlock {
        Self::PTR
    }
}
impl Deref for GPCRC_NS {
    type Target = gpcrc_ns::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for GPCRC_NS {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("GPCRC_NS").finish()
    }
}
#[doc = "GPCRC_NS Registers"]
pub mod gpcrc_ns;
#[doc = "DCDC_NS Registers"]
pub struct DCDC_NS {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for DCDC_NS {}
impl DCDC_NS {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const dcdc_ns::RegisterBlock = 0x5009_4000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const dcdc_ns::RegisterBlock {
        Self::PTR
    }
}
impl Deref for DCDC_NS {
    type Target = dcdc_ns::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for DCDC_NS {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("DCDC_NS").finish()
    }
}
#[doc = "DCDC_NS Registers"]
pub mod dcdc_ns;
#[doc = "HOSTMAILBOX_NS Registers"]
pub struct HOSTMAILBOX_NS {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for HOSTMAILBOX_NS {}
impl HOSTMAILBOX_NS {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const hostmailbox_ns::RegisterBlock = 0x5009_8000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const hostmailbox_ns::RegisterBlock {
        Self::PTR
    }
}
impl Deref for HOSTMAILBOX_NS {
    type Target = hostmailbox_ns::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for HOSTMAILBOX_NS {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("HOSTMAILBOX_NS").finish()
    }
}
#[doc = "HOSTMAILBOX_NS Registers"]
pub mod hostmailbox_ns;
#[doc = "EUSART1_NS Registers"]
pub struct EUSART1_NS {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for EUSART1_NS {}
impl EUSART1_NS {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const eusart1_ns::RegisterBlock = 0x500a_0000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const eusart1_ns::RegisterBlock {
        Self::PTR
    }
}
impl Deref for EUSART1_NS {
    type Target = eusart1_ns::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for EUSART1_NS {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("EUSART1_NS").finish()
    }
}
#[doc = "EUSART1_NS Registers"]
pub mod eusart1_ns;
#[doc = "EUSART2_NS Registers"]
pub struct EUSART2_NS {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for EUSART2_NS {}
impl EUSART2_NS {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const eusart2_ns::RegisterBlock = 0x500a_4000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const eusart2_ns::RegisterBlock {
        Self::PTR
    }
}
impl Deref for EUSART2_NS {
    type Target = eusart2_ns::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for EUSART2_NS {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("EUSART2_NS").finish()
    }
}
#[doc = "EUSART2_NS Registers"]
pub mod eusart2_ns;
#[doc = "SYSRTC0_NS Registers"]
pub struct SYSRTC0_NS {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for SYSRTC0_NS {}
impl SYSRTC0_NS {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const sysrtc0_ns::RegisterBlock = 0x500a_8000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const sysrtc0_ns::RegisterBlock {
        Self::PTR
    }
}
impl Deref for SYSRTC0_NS {
    type Target = sysrtc0_ns::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for SYSRTC0_NS {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("SYSRTC0_NS").finish()
    }
}
#[doc = "SYSRTC0_NS Registers"]
pub mod sysrtc0_ns;
#[doc = "LCD_NS Registers"]
pub struct LCD_NS {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for LCD_NS {}
impl LCD_NS {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const lcd_ns::RegisterBlock = 0x500a_c000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const lcd_ns::RegisterBlock {
        Self::PTR
    }
}
impl Deref for LCD_NS {
    type Target = lcd_ns::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for LCD_NS {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("LCD_NS").finish()
    }
}
#[doc = "LCD_NS Registers"]
pub mod lcd_ns;
#[doc = "KEYSCAN_NS Registers"]
pub struct KEYSCAN_NS {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for KEYSCAN_NS {}
impl KEYSCAN_NS {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const keyscan_ns::RegisterBlock = 0x500b_0000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const keyscan_ns::RegisterBlock {
        Self::PTR
    }
}
impl Deref for KEYSCAN_NS {
    type Target = keyscan_ns::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for KEYSCAN_NS {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("KEYSCAN_NS").finish()
    }
}
#[doc = "KEYSCAN_NS Registers"]
pub mod keyscan_ns;
#[doc = "DMEM_NS Registers"]
pub struct DMEM_NS {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for DMEM_NS {}
impl DMEM_NS {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const dmem_ns::RegisterBlock = 0x500b_4000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const dmem_ns::RegisterBlock {
        Self::PTR
    }
}
impl Deref for DMEM_NS {
    type Target = dmem_ns::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for DMEM_NS {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("DMEM_NS").finish()
    }
}
#[doc = "DMEM_NS Registers"]
pub mod dmem_ns;
#[doc = "LCDRF_NS Registers"]
pub struct LCDRF_NS {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for LCDRF_NS {}
impl LCDRF_NS {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const lcdrf_ns::RegisterBlock = 0x500c_0000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const lcdrf_ns::RegisterBlock {
        Self::PTR
    }
}
impl Deref for LCDRF_NS {
    type Target = lcdrf_ns::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for LCDRF_NS {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("LCDRF_NS").finish()
    }
}
#[doc = "LCDRF_NS Registers"]
pub mod lcdrf_ns;
#[doc = "SMU_NS Registers"]
pub struct SMU_NS {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for SMU_NS {}
impl SMU_NS {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const smu_ns::RegisterBlock = 0x5400_8000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const smu_ns::RegisterBlock {
        Self::PTR
    }
}
impl Deref for SMU_NS {
    type Target = smu_ns::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for SMU_NS {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("SMU_NS").finish()
    }
}
#[doc = "SMU_NS Registers"]
pub mod smu_ns;
#[doc = "SMU_NS_CFGNS Registers"]
pub struct SMU_NS_CFGNS {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for SMU_NS_CFGNS {}
impl SMU_NS_CFGNS {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const smu_ns_cfgns::RegisterBlock = 0x5400_c000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const smu_ns_cfgns::RegisterBlock {
        Self::PTR
    }
}
impl Deref for SMU_NS_CFGNS {
    type Target = smu_ns_cfgns::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for SMU_NS_CFGNS {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("SMU_NS_CFGNS").finish()
    }
}
#[doc = "SMU_NS_CFGNS Registers"]
pub mod smu_ns_cfgns;
#[doc = "LETIMER0_NS Registers"]
pub struct LETIMER0_NS {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for LETIMER0_NS {}
impl LETIMER0_NS {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const letimer0_ns::RegisterBlock = 0x5900_0000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const letimer0_ns::RegisterBlock {
        Self::PTR
    }
}
impl Deref for LETIMER0_NS {
    type Target = letimer0_ns::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for LETIMER0_NS {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("LETIMER0_NS").finish()
    }
}
#[doc = "LETIMER0_NS Registers"]
pub mod letimer0_ns;
#[doc = "IADC0_NS Registers"]
pub struct IADC0_NS {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for IADC0_NS {}
impl IADC0_NS {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const iadc0_ns::RegisterBlock = 0x5900_4000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const iadc0_ns::RegisterBlock {
        Self::PTR
    }
}
impl Deref for IADC0_NS {
    type Target = iadc0_ns::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for IADC0_NS {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("IADC0_NS").finish()
    }
}
#[doc = "IADC0_NS Registers"]
pub mod iadc0_ns;
#[doc = "ACMP0_NS Registers"]
pub struct ACMP0_NS {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for ACMP0_NS {}
impl ACMP0_NS {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const acmp0_ns::RegisterBlock = 0x5900_8000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const acmp0_ns::RegisterBlock {
        Self::PTR
    }
}
impl Deref for ACMP0_NS {
    type Target = acmp0_ns::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for ACMP0_NS {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("ACMP0_NS").finish()
    }
}
#[doc = "ACMP0_NS Registers"]
pub mod acmp0_ns;
#[doc = "ACMP1_NS Registers"]
pub struct ACMP1_NS {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for ACMP1_NS {}
impl ACMP1_NS {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const acmp1_ns::RegisterBlock = 0x5900_c000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const acmp1_ns::RegisterBlock {
        Self::PTR
    }
}
impl Deref for ACMP1_NS {
    type Target = acmp1_ns::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for ACMP1_NS {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("ACMP1_NS").finish()
    }
}
#[doc = "ACMP1_NS Registers"]
pub mod acmp1_ns;
#[doc = "AMUXCP0_NS Registers"]
pub struct AMUXCP0_NS {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for AMUXCP0_NS {}
impl AMUXCP0_NS {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const amuxcp0_ns::RegisterBlock = 0x5902_0000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const amuxcp0_ns::RegisterBlock {
        Self::PTR
    }
}
impl Deref for AMUXCP0_NS {
    type Target = amuxcp0_ns::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for AMUXCP0_NS {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("AMUXCP0_NS").finish()
    }
}
#[doc = "AMUXCP0_NS Registers"]
pub mod amuxcp0_ns;
#[doc = "VDAC0_NS Registers"]
pub struct VDAC0_NS {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for VDAC0_NS {}
impl VDAC0_NS {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const vdac0_ns::RegisterBlock = 0x5902_4000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const vdac0_ns::RegisterBlock {
        Self::PTR
    }
}
impl Deref for VDAC0_NS {
    type Target = vdac0_ns::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for VDAC0_NS {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("VDAC0_NS").finish()
    }
}
#[doc = "VDAC0_NS Registers"]
pub mod vdac0_ns;
#[doc = "PCNT0_NS Registers"]
pub struct PCNT0_NS {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for PCNT0_NS {}
impl PCNT0_NS {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const pcnt0_ns::RegisterBlock = 0x5903_0000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const pcnt0_ns::RegisterBlock {
        Self::PTR
    }
}
impl Deref for PCNT0_NS {
    type Target = pcnt0_ns::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for PCNT0_NS {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("PCNT0_NS").finish()
    }
}
#[doc = "PCNT0_NS Registers"]
pub mod pcnt0_ns;
#[doc = "LESENSE_NS Registers"]
pub struct LESENSE_NS {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for LESENSE_NS {}
impl LESENSE_NS {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const lesense_ns::RegisterBlock = 0x5903_8000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const lesense_ns::RegisterBlock {
        Self::PTR
    }
}
impl Deref for LESENSE_NS {
    type Target = lesense_ns::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for LESENSE_NS {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("LESENSE_NS").finish()
    }
}
#[doc = "LESENSE_NS Registers"]
pub mod lesense_ns;
#[doc = "HFRCOEM23_NS Registers"]
pub struct HFRCOEM23_NS {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for HFRCOEM23_NS {}
impl HFRCOEM23_NS {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const hfrcoem23_ns::RegisterBlock = 0x5a00_0000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const hfrcoem23_ns::RegisterBlock {
        Self::PTR
    }
}
impl Deref for HFRCOEM23_NS {
    type Target = hfrcoem23_ns::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for HFRCOEM23_NS {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("HFRCOEM23_NS").finish()
    }
}
#[doc = "HFRCOEM23_NS Registers"]
pub mod hfrcoem23_ns;
#[doc = "HFXO0_NS Registers"]
pub struct HFXO0_NS {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for HFXO0_NS {}
impl HFXO0_NS {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const hfxo0_ns::RegisterBlock = 0x5a00_4000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const hfxo0_ns::RegisterBlock {
        Self::PTR
    }
}
impl Deref for HFXO0_NS {
    type Target = hfxo0_ns::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for HFXO0_NS {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("HFXO0_NS").finish()
    }
}
#[doc = "HFXO0_NS Registers"]
pub mod hfxo0_ns;
#[doc = "I2C0_NS Registers"]
pub struct I2C0_NS {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for I2C0_NS {}
impl I2C0_NS {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const i2c0_ns::RegisterBlock = 0x5b00_0000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const i2c0_ns::RegisterBlock {
        Self::PTR
    }
}
impl Deref for I2C0_NS {
    type Target = i2c0_ns::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for I2C0_NS {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("I2C0_NS").finish()
    }
}
#[doc = "I2C0_NS Registers"]
pub mod i2c0_ns;
#[doc = "WDOG0_NS Registers"]
pub struct WDOG0_NS {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for WDOG0_NS {}
impl WDOG0_NS {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const wdog0_ns::RegisterBlock = 0x5b00_4000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const wdog0_ns::RegisterBlock {
        Self::PTR
    }
}
impl Deref for WDOG0_NS {
    type Target = wdog0_ns::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for WDOG0_NS {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("WDOG0_NS").finish()
    }
}
#[doc = "WDOG0_NS Registers"]
pub mod wdog0_ns;
#[doc = "WDOG1_NS Registers"]
pub struct WDOG1_NS {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for WDOG1_NS {}
impl WDOG1_NS {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const wdog1_ns::RegisterBlock = 0x5b00_8000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const wdog1_ns::RegisterBlock {
        Self::PTR
    }
}
impl Deref for WDOG1_NS {
    type Target = wdog1_ns::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for WDOG1_NS {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("WDOG1_NS").finish()
    }
}
#[doc = "WDOG1_NS Registers"]
pub mod wdog1_ns;
#[doc = "EUSART0_NS Registers"]
pub struct EUSART0_NS {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for EUSART0_NS {}
impl EUSART0_NS {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const eusart0_ns::RegisterBlock = 0x5b01_0000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const eusart0_ns::RegisterBlock {
        Self::PTR
    }
}
impl Deref for EUSART0_NS {
    type Target = eusart0_ns::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for EUSART0_NS {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("EUSART0_NS").finish()
    }
}
#[doc = "EUSART0_NS Registers"]
pub mod eusart0_ns;
#[doc = "SEMAILBOX_NS_HOST Registers"]
pub struct SEMAILBOX_NS_HOST {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for SEMAILBOX_NS_HOST {}
impl SEMAILBOX_NS_HOST {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const semailbox_ns_host::RegisterBlock = 0x5c00_0000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const semailbox_ns_host::RegisterBlock {
        Self::PTR
    }
}
impl Deref for SEMAILBOX_NS_HOST {
    type Target = semailbox_ns_host::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for SEMAILBOX_NS_HOST {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("SEMAILBOX_NS_HOST").finish()
    }
}
#[doc = "SEMAILBOX_NS_HOST Registers"]
pub mod semailbox_ns_host;
#[doc = "DEVINFO Registers"]
pub struct DEVINFO {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for DEVINFO {}
impl DEVINFO {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const devinfo::RegisterBlock = 0x0fe0_8000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const devinfo::RegisterBlock {
        Self::PTR
    }
}
impl Deref for DEVINFO {
    type Target = devinfo::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for DEVINFO {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("DEVINFO").finish()
    }
}
#[doc = "DEVINFO Registers"]
pub mod devinfo;
#[no_mangle]
static mut DEVICE_PERIPHERALS: bool = false;
#[doc = r" All the peripherals."]
#[allow(non_snake_case)]
pub struct Peripherals {
    #[doc = "SCRATCHPAD_S"]
    pub SCRATCHPAD_S: SCRATCHPAD_S,
    #[doc = "EMU_S"]
    pub EMU_S: EMU_S,
    #[doc = "CMU_S"]
    pub CMU_S: CMU_S,
    #[doc = "HFRCO0_S"]
    pub HFRCO0_S: HFRCO0_S,
    #[doc = "FSRCO_S"]
    pub FSRCO_S: FSRCO_S,
    #[doc = "DPLL0_S"]
    pub DPLL0_S: DPLL0_S,
    #[doc = "LFXO_S"]
    pub LFXO_S: LFXO_S,
    #[doc = "LFRCO_S"]
    pub LFRCO_S: LFRCO_S,
    #[doc = "ULFRCO_S"]
    pub ULFRCO_S: ULFRCO_S,
    #[doc = "MSC_S"]
    pub MSC_S: MSC_S,
    #[doc = "ICACHE0_S"]
    pub ICACHE0_S: ICACHE0_S,
    #[doc = "PRS_S"]
    pub PRS_S: PRS_S,
    #[doc = "GPIO_S"]
    pub GPIO_S: GPIO_S,
    #[doc = "LDMA_S"]
    pub LDMA_S: LDMA_S,
    #[doc = "LDMAXBAR_S"]
    pub LDMAXBAR_S: LDMAXBAR_S,
    #[doc = "TIMER0_S"]
    pub TIMER0_S: TIMER0_S,
    #[doc = "TIMER1_S"]
    pub TIMER1_S: TIMER1_S,
    #[doc = "TIMER2_S"]
    pub TIMER2_S: TIMER2_S,
    #[doc = "TIMER3_S"]
    pub TIMER3_S: TIMER3_S,
    #[doc = "TIMER4_S"]
    pub TIMER4_S: TIMER4_S,
    #[doc = "USART0_S"]
    pub USART0_S: USART0_S,
    #[doc = "BURTC_S"]
    pub BURTC_S: BURTC_S,
    #[doc = "I2C1_S"]
    pub I2C1_S: I2C1_S,
    #[doc = "SYSCFG_S_CFGNS"]
    pub SYSCFG_S_CFGNS: SYSCFG_S_CFGNS,
    #[doc = "SYSCFG_S"]
    pub SYSCFG_S: SYSCFG_S,
    #[doc = "BURAM_S"]
    pub BURAM_S: BURAM_S,
    #[doc = "GPCRC_S"]
    pub GPCRC_S: GPCRC_S,
    #[doc = "DCDC_S"]
    pub DCDC_S: DCDC_S,
    #[doc = "HOSTMAILBOX_S"]
    pub HOSTMAILBOX_S: HOSTMAILBOX_S,
    #[doc = "EUSART1_S"]
    pub EUSART1_S: EUSART1_S,
    #[doc = "EUSART2_S"]
    pub EUSART2_S: EUSART2_S,
    #[doc = "SYSRTC0_S"]
    pub SYSRTC0_S: SYSRTC0_S,
    #[doc = "LCD_S"]
    pub LCD_S: LCD_S,
    #[doc = "KEYSCAN_S"]
    pub KEYSCAN_S: KEYSCAN_S,
    #[doc = "DMEM_S"]
    pub DMEM_S: DMEM_S,
    #[doc = "LCDRF_S"]
    pub LCDRF_S: LCDRF_S,
    #[doc = "SMU_S"]
    pub SMU_S: SMU_S,
    #[doc = "SMU_S_CFGNS"]
    pub SMU_S_CFGNS: SMU_S_CFGNS,
    #[doc = "LETIMER0_S"]
    pub LETIMER0_S: LETIMER0_S,
    #[doc = "IADC0_S"]
    pub IADC0_S: IADC0_S,
    #[doc = "ACMP0_S"]
    pub ACMP0_S: ACMP0_S,
    #[doc = "ACMP1_S"]
    pub ACMP1_S: ACMP1_S,
    #[doc = "AMUXCP0_S"]
    pub AMUXCP0_S: AMUXCP0_S,
    #[doc = "VDAC0_S"]
    pub VDAC0_S: VDAC0_S,
    #[doc = "PCNT0_S"]
    pub PCNT0_S: PCNT0_S,
    #[doc = "LESENSE_S"]
    pub LESENSE_S: LESENSE_S,
    #[doc = "HFRCOEM23_S"]
    pub HFRCOEM23_S: HFRCOEM23_S,
    #[doc = "HFXO0_S"]
    pub HFXO0_S: HFXO0_S,
    #[doc = "I2C0_S"]
    pub I2C0_S: I2C0_S,
    #[doc = "WDOG0_S"]
    pub WDOG0_S: WDOG0_S,
    #[doc = "WDOG1_S"]
    pub WDOG1_S: WDOG1_S,
    #[doc = "EUSART0_S"]
    pub EUSART0_S: EUSART0_S,
    #[doc = "SEMAILBOX_S_HOST"]
    pub SEMAILBOX_S_HOST: SEMAILBOX_S_HOST,
    #[doc = "SCRATCHPAD_NS"]
    pub SCRATCHPAD_NS: SCRATCHPAD_NS,
    #[doc = "EMU_NS"]
    pub EMU_NS: EMU_NS,
    #[doc = "CMU_NS"]
    pub CMU_NS: CMU_NS,
    #[doc = "HFRCO0_NS"]
    pub HFRCO0_NS: HFRCO0_NS,
    #[doc = "FSRCO_NS"]
    pub FSRCO_NS: FSRCO_NS,
    #[doc = "DPLL0_NS"]
    pub DPLL0_NS: DPLL0_NS,
    #[doc = "LFXO_NS"]
    pub LFXO_NS: LFXO_NS,
    #[doc = "LFRCO_NS"]
    pub LFRCO_NS: LFRCO_NS,
    #[doc = "ULFRCO_NS"]
    pub ULFRCO_NS: ULFRCO_NS,
    #[doc = "MSC_NS"]
    pub MSC_NS: MSC_NS,
    #[doc = "ICACHE0_NS"]
    pub ICACHE0_NS: ICACHE0_NS,
    #[doc = "PRS_NS"]
    pub PRS_NS: PRS_NS,
    #[doc = "GPIO_NS"]
    pub GPIO_NS: GPIO_NS,
    #[doc = "LDMA_NS"]
    pub LDMA_NS: LDMA_NS,
    #[doc = "LDMAXBAR_NS"]
    pub LDMAXBAR_NS: LDMAXBAR_NS,
    #[doc = "TIMER0_NS"]
    pub TIMER0_NS: TIMER0_NS,
    #[doc = "TIMER1_NS"]
    pub TIMER1_NS: TIMER1_NS,
    #[doc = "TIMER2_NS"]
    pub TIMER2_NS: TIMER2_NS,
    #[doc = "TIMER3_NS"]
    pub TIMER3_NS: TIMER3_NS,
    #[doc = "TIMER4_NS"]
    pub TIMER4_NS: TIMER4_NS,
    #[doc = "USART0_NS"]
    pub USART0_NS: USART0_NS,
    #[doc = "BURTC_NS"]
    pub BURTC_NS: BURTC_NS,
    #[doc = "I2C1_NS"]
    pub I2C1_NS: I2C1_NS,
    #[doc = "SYSCFG_NS_CFGNS"]
    pub SYSCFG_NS_CFGNS: SYSCFG_NS_CFGNS,
    #[doc = "SYSCFG_NS"]
    pub SYSCFG_NS: SYSCFG_NS,
    #[doc = "BURAM_NS"]
    pub BURAM_NS: BURAM_NS,
    #[doc = "GPCRC_NS"]
    pub GPCRC_NS: GPCRC_NS,
    #[doc = "DCDC_NS"]
    pub DCDC_NS: DCDC_NS,
    #[doc = "HOSTMAILBOX_NS"]
    pub HOSTMAILBOX_NS: HOSTMAILBOX_NS,
    #[doc = "EUSART1_NS"]
    pub EUSART1_NS: EUSART1_NS,
    #[doc = "EUSART2_NS"]
    pub EUSART2_NS: EUSART2_NS,
    #[doc = "SYSRTC0_NS"]
    pub SYSRTC0_NS: SYSRTC0_NS,
    #[doc = "LCD_NS"]
    pub LCD_NS: LCD_NS,
    #[doc = "KEYSCAN_NS"]
    pub KEYSCAN_NS: KEYSCAN_NS,
    #[doc = "DMEM_NS"]
    pub DMEM_NS: DMEM_NS,
    #[doc = "LCDRF_NS"]
    pub LCDRF_NS: LCDRF_NS,
    #[doc = "SMU_NS"]
    pub SMU_NS: SMU_NS,
    #[doc = "SMU_NS_CFGNS"]
    pub SMU_NS_CFGNS: SMU_NS_CFGNS,
    #[doc = "LETIMER0_NS"]
    pub LETIMER0_NS: LETIMER0_NS,
    #[doc = "IADC0_NS"]
    pub IADC0_NS: IADC0_NS,
    #[doc = "ACMP0_NS"]
    pub ACMP0_NS: ACMP0_NS,
    #[doc = "ACMP1_NS"]
    pub ACMP1_NS: ACMP1_NS,
    #[doc = "AMUXCP0_NS"]
    pub AMUXCP0_NS: AMUXCP0_NS,
    #[doc = "VDAC0_NS"]
    pub VDAC0_NS: VDAC0_NS,
    #[doc = "PCNT0_NS"]
    pub PCNT0_NS: PCNT0_NS,
    #[doc = "LESENSE_NS"]
    pub LESENSE_NS: LESENSE_NS,
    #[doc = "HFRCOEM23_NS"]
    pub HFRCOEM23_NS: HFRCOEM23_NS,
    #[doc = "HFXO0_NS"]
    pub HFXO0_NS: HFXO0_NS,
    #[doc = "I2C0_NS"]
    pub I2C0_NS: I2C0_NS,
    #[doc = "WDOG0_NS"]
    pub WDOG0_NS: WDOG0_NS,
    #[doc = "WDOG1_NS"]
    pub WDOG1_NS: WDOG1_NS,
    #[doc = "EUSART0_NS"]
    pub EUSART0_NS: EUSART0_NS,
    #[doc = "SEMAILBOX_NS_HOST"]
    pub SEMAILBOX_NS_HOST: SEMAILBOX_NS_HOST,
    #[doc = "DEVINFO"]
    pub DEVINFO: DEVINFO,
}
impl Peripherals {
    #[doc = r" Returns all the peripherals *once*."]
    #[cfg(feature = "critical-section")]
    #[inline]
    pub fn take() -> Option<Self> {
        critical_section::with(|_| {
            if unsafe { DEVICE_PERIPHERALS } {
                return None;
            }
            Some(unsafe { Peripherals::steal() })
        })
    }
    #[doc = r" Unchecked version of `Peripherals::take`."]
    #[doc = r""]
    #[doc = r" # Safety"]
    #[doc = r""]
    #[doc = r" Each of the returned peripherals must be used at most once."]
    #[inline]
    pub unsafe fn steal() -> Self {
        DEVICE_PERIPHERALS = true;
        Peripherals {
            SCRATCHPAD_S: SCRATCHPAD_S {
                _marker: PhantomData,
            },
            EMU_S: EMU_S {
                _marker: PhantomData,
            },
            CMU_S: CMU_S {
                _marker: PhantomData,
            },
            HFRCO0_S: HFRCO0_S {
                _marker: PhantomData,
            },
            FSRCO_S: FSRCO_S {
                _marker: PhantomData,
            },
            DPLL0_S: DPLL0_S {
                _marker: PhantomData,
            },
            LFXO_S: LFXO_S {
                _marker: PhantomData,
            },
            LFRCO_S: LFRCO_S {
                _marker: PhantomData,
            },
            ULFRCO_S: ULFRCO_S {
                _marker: PhantomData,
            },
            MSC_S: MSC_S {
                _marker: PhantomData,
            },
            ICACHE0_S: ICACHE0_S {
                _marker: PhantomData,
            },
            PRS_S: PRS_S {
                _marker: PhantomData,
            },
            GPIO_S: GPIO_S {
                _marker: PhantomData,
            },
            LDMA_S: LDMA_S {
                _marker: PhantomData,
            },
            LDMAXBAR_S: LDMAXBAR_S {
                _marker: PhantomData,
            },
            TIMER0_S: TIMER0_S {
                _marker: PhantomData,
            },
            TIMER1_S: TIMER1_S {
                _marker: PhantomData,
            },
            TIMER2_S: TIMER2_S {
                _marker: PhantomData,
            },
            TIMER3_S: TIMER3_S {
                _marker: PhantomData,
            },
            TIMER4_S: TIMER4_S {
                _marker: PhantomData,
            },
            USART0_S: USART0_S {
                _marker: PhantomData,
            },
            BURTC_S: BURTC_S {
                _marker: PhantomData,
            },
            I2C1_S: I2C1_S {
                _marker: PhantomData,
            },
            SYSCFG_S_CFGNS: SYSCFG_S_CFGNS {
                _marker: PhantomData,
            },
            SYSCFG_S: SYSCFG_S {
                _marker: PhantomData,
            },
            BURAM_S: BURAM_S {
                _marker: PhantomData,
            },
            GPCRC_S: GPCRC_S {
                _marker: PhantomData,
            },
            DCDC_S: DCDC_S {
                _marker: PhantomData,
            },
            HOSTMAILBOX_S: HOSTMAILBOX_S {
                _marker: PhantomData,
            },
            EUSART1_S: EUSART1_S {
                _marker: PhantomData,
            },
            EUSART2_S: EUSART2_S {
                _marker: PhantomData,
            },
            SYSRTC0_S: SYSRTC0_S {
                _marker: PhantomData,
            },
            LCD_S: LCD_S {
                _marker: PhantomData,
            },
            KEYSCAN_S: KEYSCAN_S {
                _marker: PhantomData,
            },
            DMEM_S: DMEM_S {
                _marker: PhantomData,
            },
            LCDRF_S: LCDRF_S {
                _marker: PhantomData,
            },
            SMU_S: SMU_S {
                _marker: PhantomData,
            },
            SMU_S_CFGNS: SMU_S_CFGNS {
                _marker: PhantomData,
            },
            LETIMER0_S: LETIMER0_S {
                _marker: PhantomData,
            },
            IADC0_S: IADC0_S {
                _marker: PhantomData,
            },
            ACMP0_S: ACMP0_S {
                _marker: PhantomData,
            },
            ACMP1_S: ACMP1_S {
                _marker: PhantomData,
            },
            AMUXCP0_S: AMUXCP0_S {
                _marker: PhantomData,
            },
            VDAC0_S: VDAC0_S {
                _marker: PhantomData,
            },
            PCNT0_S: PCNT0_S {
                _marker: PhantomData,
            },
            LESENSE_S: LESENSE_S {
                _marker: PhantomData,
            },
            HFRCOEM23_S: HFRCOEM23_S {
                _marker: PhantomData,
            },
            HFXO0_S: HFXO0_S {
                _marker: PhantomData,
            },
            I2C0_S: I2C0_S {
                _marker: PhantomData,
            },
            WDOG0_S: WDOG0_S {
                _marker: PhantomData,
            },
            WDOG1_S: WDOG1_S {
                _marker: PhantomData,
            },
            EUSART0_S: EUSART0_S {
                _marker: PhantomData,
            },
            SEMAILBOX_S_HOST: SEMAILBOX_S_HOST {
                _marker: PhantomData,
            },
            SCRATCHPAD_NS: SCRATCHPAD_NS {
                _marker: PhantomData,
            },
            EMU_NS: EMU_NS {
                _marker: PhantomData,
            },
            CMU_NS: CMU_NS {
                _marker: PhantomData,
            },
            HFRCO0_NS: HFRCO0_NS {
                _marker: PhantomData,
            },
            FSRCO_NS: FSRCO_NS {
                _marker: PhantomData,
            },
            DPLL0_NS: DPLL0_NS {
                _marker: PhantomData,
            },
            LFXO_NS: LFXO_NS {
                _marker: PhantomData,
            },
            LFRCO_NS: LFRCO_NS {
                _marker: PhantomData,
            },
            ULFRCO_NS: ULFRCO_NS {
                _marker: PhantomData,
            },
            MSC_NS: MSC_NS {
                _marker: PhantomData,
            },
            ICACHE0_NS: ICACHE0_NS {
                _marker: PhantomData,
            },
            PRS_NS: PRS_NS {
                _marker: PhantomData,
            },
            GPIO_NS: GPIO_NS {
                _marker: PhantomData,
            },
            LDMA_NS: LDMA_NS {
                _marker: PhantomData,
            },
            LDMAXBAR_NS: LDMAXBAR_NS {
                _marker: PhantomData,
            },
            TIMER0_NS: TIMER0_NS {
                _marker: PhantomData,
            },
            TIMER1_NS: TIMER1_NS {
                _marker: PhantomData,
            },
            TIMER2_NS: TIMER2_NS {
                _marker: PhantomData,
            },
            TIMER3_NS: TIMER3_NS {
                _marker: PhantomData,
            },
            TIMER4_NS: TIMER4_NS {
                _marker: PhantomData,
            },
            USART0_NS: USART0_NS {
                _marker: PhantomData,
            },
            BURTC_NS: BURTC_NS {
                _marker: PhantomData,
            },
            I2C1_NS: I2C1_NS {
                _marker: PhantomData,
            },
            SYSCFG_NS_CFGNS: SYSCFG_NS_CFGNS {
                _marker: PhantomData,
            },
            SYSCFG_NS: SYSCFG_NS {
                _marker: PhantomData,
            },
            BURAM_NS: BURAM_NS {
                _marker: PhantomData,
            },
            GPCRC_NS: GPCRC_NS {
                _marker: PhantomData,
            },
            DCDC_NS: DCDC_NS {
                _marker: PhantomData,
            },
            HOSTMAILBOX_NS: HOSTMAILBOX_NS {
                _marker: PhantomData,
            },
            EUSART1_NS: EUSART1_NS {
                _marker: PhantomData,
            },
            EUSART2_NS: EUSART2_NS {
                _marker: PhantomData,
            },
            SYSRTC0_NS: SYSRTC0_NS {
                _marker: PhantomData,
            },
            LCD_NS: LCD_NS {
                _marker: PhantomData,
            },
            KEYSCAN_NS: KEYSCAN_NS {
                _marker: PhantomData,
            },
            DMEM_NS: DMEM_NS {
                _marker: PhantomData,
            },
            LCDRF_NS: LCDRF_NS {
                _marker: PhantomData,
            },
            SMU_NS: SMU_NS {
                _marker: PhantomData,
            },
            SMU_NS_CFGNS: SMU_NS_CFGNS {
                _marker: PhantomData,
            },
            LETIMER0_NS: LETIMER0_NS {
                _marker: PhantomData,
            },
            IADC0_NS: IADC0_NS {
                _marker: PhantomData,
            },
            ACMP0_NS: ACMP0_NS {
                _marker: PhantomData,
            },
            ACMP1_NS: ACMP1_NS {
                _marker: PhantomData,
            },
            AMUXCP0_NS: AMUXCP0_NS {
                _marker: PhantomData,
            },
            VDAC0_NS: VDAC0_NS {
                _marker: PhantomData,
            },
            PCNT0_NS: PCNT0_NS {
                _marker: PhantomData,
            },
            LESENSE_NS: LESENSE_NS {
                _marker: PhantomData,
            },
            HFRCOEM23_NS: HFRCOEM23_NS {
                _marker: PhantomData,
            },
            HFXO0_NS: HFXO0_NS {
                _marker: PhantomData,
            },
            I2C0_NS: I2C0_NS {
                _marker: PhantomData,
            },
            WDOG0_NS: WDOG0_NS {
                _marker: PhantomData,
            },
            WDOG1_NS: WDOG1_NS {
                _marker: PhantomData,
            },
            EUSART0_NS: EUSART0_NS {
                _marker: PhantomData,
            },
            SEMAILBOX_NS_HOST: SEMAILBOX_NS_HOST {
                _marker: PhantomData,
            },
            DEVINFO: DEVINFO {
                _marker: PhantomData,
            },
        }
    }
}