mimxrt595s 0.5.0

#![doc = "Peripheral access API for MIMXRT595S_CM33 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"]
#![deny(dead_code)]
#![deny(improper_ctypes)]
#![deny(missing_docs)]
#![deny(no_mangle_generic_items)]
#![deny(non_shorthand_field_patterns)]
#![deny(overflowing_literals)]
#![deny(path_statements)]
#![deny(patterns_in_fns_without_body)]
#![deny(unconditional_recursion)]
#![deny(unused_allocation)]
#![deny(unused_comparisons)]
#![deny(unused_parens)]
#![deny(while_true)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![no_std]
use core::marker::PhantomData;
use core::ops::Deref;
#[doc = r"Number available in the NVIC for configuring priority"]
pub const NVIC_PRIO_BITS: u8 = 3;
#[cfg(feature = "rt")]
pub use self::Interrupt as interrupt;
pub use cortex_m::peripheral::Peripherals as CorePeripherals;
pub use cortex_m::peripheral::{CBP, CPUID, DCB, DWT, FPB, FPU, ITM, MPU, NVIC, SCB, SYST, TPIU};
#[cfg(feature = "rt")]
pub use cortex_m_rt::interrupt;
#[allow(unused_imports)]
use generic::*;
#[doc = r"Common register and bit access and modify traits"]
pub mod generic;
#[cfg(feature = "rt")]
extern "C" {
    fn WDT0();
    fn DMA0();
    fn GPIO_INTA();
    fn GPIO_INTB();
    fn PIN_INT0();
    fn PIN_INT1();
    fn PIN_INT2();
    fn PIN_INT3();
    fn UTICK0();
    fn MRT0();
    fn CTIMER0();
    fn CTIMER1();
    fn SCT0();
    fn CTIMER3();
    fn FLEXCOMM0();
    fn FLEXCOMM1();
    fn FLEXCOMM2();
    fn FLEXCOMM3();
    fn FLEXCOMM4();
    fn FLEXCOMM5();
    fn FLEXCOMM14();
    fn FLEXCOMM15();
    fn ADC0();
    fn ACMP();
    fn DMIC0();
    fn HYPERVISOR();
    fn SECURE_VIOLATION();
    fn HWVAD0();
    fn RNG();
    fn RTC();
    fn DSP_TIE_EXPSTATE1();
    fn MU_A();
    fn PIN_INT4();
    fn PIN_INT5();
    fn PIN_INT6();
    fn PIN_INT7();
    fn CTIMER2();
    fn CTIMER4();
    fn OS_EVENT();
    fn FLEXSPI0_FLEXSPI1();
    fn FLEXCOMM6();
    fn FLEXCOMM7();
    fn USDHC0();
    fn USDHC1();
    fn SGPIO_INTA();
    fn SGPIO_INTB();
    fn I3C0();
    fn USB0();
    fn USB0_NEEDCLK();
    fn WDT1();
    fn USB_PHYDCD();
    fn DMA1();
    fn PUF();
    fn POWERQUAD();
    fn CASPER();
    fn PMU_PMIC();
    fn HASHCRYPT();
    fn FLEXCOMM8();
    fn FLEXCOMM9();
    fn FLEXCOMM10();
    fn FLEXCOMM11();
    fn FLEXCOMM12();
    fn FLEXCOMM13();
    fn FLEXCOMM16();
    fn I3C1();
    fn FLEXIO();
    fn LCDIF();
    fn MIPI();
}
#[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; 72] = [
    Vector { _handler: WDT0 },
    Vector { _handler: DMA0 },
    Vector {
        _handler: GPIO_INTA,
    },
    Vector {
        _handler: GPIO_INTB,
    },
    Vector { _handler: PIN_INT0 },
    Vector { _handler: PIN_INT1 },
    Vector { _handler: PIN_INT2 },
    Vector { _handler: PIN_INT3 },
    Vector { _handler: UTICK0 },
    Vector { _handler: MRT0 },
    Vector { _handler: CTIMER0 },
    Vector { _handler: CTIMER1 },
    Vector { _handler: SCT0 },
    Vector { _handler: CTIMER3 },
    Vector {
        _handler: FLEXCOMM0,
    },
    Vector {
        _handler: FLEXCOMM1,
    },
    Vector {
        _handler: FLEXCOMM2,
    },
    Vector {
        _handler: FLEXCOMM3,
    },
    Vector {
        _handler: FLEXCOMM4,
    },
    Vector {
        _handler: FLEXCOMM5,
    },
    Vector {
        _handler: FLEXCOMM14,
    },
    Vector {
        _handler: FLEXCOMM15,
    },
    Vector { _handler: ADC0 },
    Vector { _reserved: 0 },
    Vector { _handler: ACMP },
    Vector { _handler: DMIC0 },
    Vector { _reserved: 0 },
    Vector {
        _handler: HYPERVISOR,
    },
    Vector {
        _handler: SECURE_VIOLATION,
    },
    Vector { _handler: HWVAD0 },
    Vector { _reserved: 0 },
    Vector { _handler: RNG },
    Vector { _handler: RTC },
    Vector {
        _handler: DSP_TIE_EXPSTATE1,
    },
    Vector { _handler: MU_A },
    Vector { _handler: PIN_INT4 },
    Vector { _handler: PIN_INT5 },
    Vector { _handler: PIN_INT6 },
    Vector { _handler: PIN_INT7 },
    Vector { _handler: CTIMER2 },
    Vector { _handler: CTIMER4 },
    Vector { _handler: OS_EVENT },
    Vector {
        _handler: FLEXSPI0_FLEXSPI1,
    },
    Vector {
        _handler: FLEXCOMM6,
    },
    Vector {
        _handler: FLEXCOMM7,
    },
    Vector { _handler: USDHC0 },
    Vector { _handler: USDHC1 },
    Vector {
        _handler: SGPIO_INTA,
    },
    Vector {
        _handler: SGPIO_INTB,
    },
    Vector { _handler: I3C0 },
    Vector { _handler: USB0 },
    Vector {
        _handler: USB0_NEEDCLK,
    },
    Vector { _handler: WDT1 },
    Vector {
        _handler: USB_PHYDCD,
    },
    Vector { _handler: DMA1 },
    Vector { _handler: PUF },
    Vector {
        _handler: POWERQUAD,
    },
    Vector { _handler: CASPER },
    Vector { _handler: PMU_PMIC },
    Vector {
        _handler: HASHCRYPT,
    },
    Vector {
        _handler: FLEXCOMM8,
    },
    Vector {
        _handler: FLEXCOMM9,
    },
    Vector {
        _handler: FLEXCOMM10,
    },
    Vector {
        _handler: FLEXCOMM11,
    },
    Vector {
        _handler: FLEXCOMM12,
    },
    Vector {
        _handler: FLEXCOMM13,
    },
    Vector {
        _handler: FLEXCOMM16,
    },
    Vector { _handler: I3C1 },
    Vector { _handler: FLEXIO },
    Vector { _handler: LCDIF },
    Vector { _reserved: 0 },
    Vector { _handler: MIPI },
];
#[doc = r"Enumeration of all the interrupts."]
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
#[repr(u16)]
pub enum Interrupt {
    #[doc = "0 - WDT0"]
    WDT0 = 0,
    #[doc = "1 - DMA0"]
    DMA0 = 1,
    #[doc = "2 - GPIO_INTA"]
    GPIO_INTA = 2,
    #[doc = "3 - GPIO_INTB"]
    GPIO_INTB = 3,
    #[doc = "4 - PIN_INT0"]
    PIN_INT0 = 4,
    #[doc = "5 - PIN_INT1"]
    PIN_INT1 = 5,
    #[doc = "6 - PIN_INT2"]
    PIN_INT2 = 6,
    #[doc = "7 - PIN_INT3"]
    PIN_INT3 = 7,
    #[doc = "8 - UTICK0"]
    UTICK0 = 8,
    #[doc = "9 - MRT0"]
    MRT0 = 9,
    #[doc = "10 - CTIMER0"]
    CTIMER0 = 10,
    #[doc = "11 - CTIMER1"]
    CTIMER1 = 11,
    #[doc = "12 - SCT0"]
    SCT0 = 12,
    #[doc = "13 - CTIMER3"]
    CTIMER3 = 13,
    #[doc = "14 - FLEXCOMM0"]
    FLEXCOMM0 = 14,
    #[doc = "15 - FLEXCOMM1"]
    FLEXCOMM1 = 15,
    #[doc = "16 - FLEXCOMM2"]
    FLEXCOMM2 = 16,
    #[doc = "17 - FLEXCOMM3"]
    FLEXCOMM3 = 17,
    #[doc = "18 - FLEXCOMM4"]
    FLEXCOMM4 = 18,
    #[doc = "19 - FLEXCOMM5"]
    FLEXCOMM5 = 19,
    #[doc = "20 - FLEXCOMM14"]
    FLEXCOMM14 = 20,
    #[doc = "21 - FLEXCOMM15"]
    FLEXCOMM15 = 21,
    #[doc = "22 - ADC0"]
    ADC0 = 22,
    #[doc = "24 - ACMP"]
    ACMP = 24,
    #[doc = "25 - DMIC0"]
    DMIC0 = 25,
    #[doc = "27 - HYPERVISOR"]
    HYPERVISOR = 27,
    #[doc = "28 - SECURE_VIOLATION"]
    SECURE_VIOLATION = 28,
    #[doc = "29 - HWVAD0"]
    HWVAD0 = 29,
    #[doc = "31 - RNG"]
    RNG = 31,
    #[doc = "32 - RTC"]
    RTC = 32,
    #[doc = "33 - DSP_TIE_EXPSTATE1"]
    DSP_TIE_EXPSTATE1 = 33,
    #[doc = "34 - MU_A"]
    MU_A = 34,
    #[doc = "35 - PIN_INT4"]
    PIN_INT4 = 35,
    #[doc = "36 - PIN_INT5"]
    PIN_INT5 = 36,
    #[doc = "37 - PIN_INT6"]
    PIN_INT6 = 37,
    #[doc = "38 - PIN_INT7"]
    PIN_INT7 = 38,
    #[doc = "39 - CTIMER2"]
    CTIMER2 = 39,
    #[doc = "40 - CTIMER4"]
    CTIMER4 = 40,
    #[doc = "41 - OS_EVENT"]
    OS_EVENT = 41,
    #[doc = "42 - FLEXSPI0_FLEXSPI1"]
    FLEXSPI0_FLEXSPI1 = 42,
    #[doc = "43 - FLEXCOMM6"]
    FLEXCOMM6 = 43,
    #[doc = "44 - FLEXCOMM7"]
    FLEXCOMM7 = 44,
    #[doc = "45 - USDHC0"]
    USDHC0 = 45,
    #[doc = "46 - USDHC1"]
    USDHC1 = 46,
    #[doc = "47 - SGPIO_INTA"]
    SGPIO_INTA = 47,
    #[doc = "48 - SGPIO_INTB"]
    SGPIO_INTB = 48,
    #[doc = "49 - I3C0"]
    I3C0 = 49,
    #[doc = "50 - USB0"]
    USB0 = 50,
    #[doc = "51 - USB0_NEEDCLK"]
    USB0_NEEDCLK = 51,
    #[doc = "52 - WDT1"]
    WDT1 = 52,
    #[doc = "53 - USB_PHYDCD"]
    USB_PHYDCD = 53,
    #[doc = "54 - DMA1"]
    DMA1 = 54,
    #[doc = "55 - PUF"]
    PUF = 55,
    #[doc = "56 - POWERQUAD"]
    POWERQUAD = 56,
    #[doc = "57 - CASPER"]
    CASPER = 57,
    #[doc = "58 - PMU_PMIC"]
    PMU_PMIC = 58,
    #[doc = "59 - HASHCRYPT"]
    HASHCRYPT = 59,
    #[doc = "60 - FLEXCOMM8"]
    FLEXCOMM8 = 60,
    #[doc = "61 - FLEXCOMM9"]
    FLEXCOMM9 = 61,
    #[doc = "62 - FLEXCOMM10"]
    FLEXCOMM10 = 62,
    #[doc = "63 - FLEXCOMM11"]
    FLEXCOMM11 = 63,
    #[doc = "64 - FLEXCOMM12"]
    FLEXCOMM12 = 64,
    #[doc = "65 - FLEXCOMM13"]
    FLEXCOMM13 = 65,
    #[doc = "66 - FLEXCOMM16"]
    FLEXCOMM16 = 66,
    #[doc = "67 - I3C1"]
    I3C1 = 67,
    #[doc = "68 - FLEXIO"]
    FLEXIO = 68,
    #[doc = "69 - LCDIF"]
    LCDIF = 69,
    #[doc = "71 - MIPI"]
    MIPI = 71,
}
unsafe impl cortex_m::interrupt::InterruptNumber for Interrupt {
    #[inline(always)]
    fn number(self) -> u16 {
        self as u16
    }
}
#[doc = "Reset Controller 0"]
pub struct RSTCTL0 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for RSTCTL0 {}
impl RSTCTL0 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const rstctl0::RegisterBlock = 0x4000_0000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const rstctl0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for RSTCTL0 {
    type Target = rstctl0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for RSTCTL0 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("RSTCTL0").finish()
    }
}
#[doc = "Reset Controller 0"]
pub mod rstctl0;
#[doc = "Clock Controller 0"]
pub struct CLKCTL0 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for CLKCTL0 {}
impl CLKCTL0 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const clkctl0::RegisterBlock = 0x4000_1000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const clkctl0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for CLKCTL0 {
    type Target = clkctl0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for CLKCTL0 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("CLKCTL0").finish()
    }
}
#[doc = "Clock Controller 0"]
pub mod clkctl0;
#[doc = "SYSCTL0"]
pub struct SYSCTL0 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for SYSCTL0 {}
impl SYSCTL0 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const sysctl0::RegisterBlock = 0x4000_2000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const sysctl0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for SYSCTL0 {
    type Target = sysctl0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for SYSCTL0 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("SYSCTL0").finish()
    }
}
#[doc = "SYSCTL0"]
pub mod sysctl0;
#[doc = "IOPCTL"]
pub struct IOPCTL {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for IOPCTL {}
impl IOPCTL {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const iopctl::RegisterBlock = 0x4000_4000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const iopctl::RegisterBlock {
        Self::PTR
    }
}
impl Deref for IOPCTL {
    type Target = iopctl::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for IOPCTL {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("IOPCTL").finish()
    }
}
#[doc = "IOPCTL"]
pub mod iopctl;
#[doc = "PUF Controller"]
pub struct PUF {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for PUF {}
impl PUF {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const puf::RegisterBlock = 0x4000_6000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const puf::RegisterBlock {
        Self::PTR
    }
}
impl Deref for PUF {
    type Target = puf::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for PUF {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("PUF").finish()
    }
}
#[doc = "PUF Controller"]
pub mod puf;
#[doc = "WWDT"]
pub struct WWDT0 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for WWDT0 {}
impl WWDT0 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const wwdt0::RegisterBlock = 0x4000_e000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const wwdt0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for WWDT0 {
    type Target = wwdt0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for WWDT0 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("WWDT0").finish()
    }
}
#[doc = "WWDT"]
pub mod wwdt0;
#[doc = "WWDT"]
pub struct WWDT1 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for WWDT1 {}
impl WWDT1 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const wwdt0::RegisterBlock = 0x4002_e000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const wwdt0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for WWDT1 {
    type Target = wwdt0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for WWDT1 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("WWDT1").finish()
    }
}
#[doc = "WWDT"]
pub use self::wwdt0 as wwdt1;
#[doc = "UTICK"]
pub struct UTICK0 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for UTICK0 {}
impl UTICK0 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const utick0::RegisterBlock = 0x4000_f000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const utick0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for UTICK0 {
    type Target = utick0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for UTICK0 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("UTICK0").finish()
    }
}
#[doc = "UTICK"]
pub mod utick0;
#[doc = "Reset Controller 1"]
pub struct RSTCTL1 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for RSTCTL1 {}
impl RSTCTL1 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const rstctl1::RegisterBlock = 0x4002_0000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const rstctl1::RegisterBlock {
        Self::PTR
    }
}
impl Deref for RSTCTL1 {
    type Target = rstctl1::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for RSTCTL1 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("RSTCTL1").finish()
    }
}
#[doc = "Reset Controller 1"]
pub mod rstctl1;
#[doc = "Clock Controller 1"]
pub struct CLKCTL1 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for CLKCTL1 {}
impl CLKCTL1 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const clkctl1::RegisterBlock = 0x4002_1000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const clkctl1::RegisterBlock {
        Self::PTR
    }
}
impl Deref for CLKCTL1 {
    type Target = clkctl1::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for CLKCTL1 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("CLKCTL1").finish()
    }
}
#[doc = "Clock Controller 1"]
pub mod clkctl1;
#[doc = "SYSCTL1"]
pub struct SYSCTL1 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for SYSCTL1 {}
impl SYSCTL1 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const sysctl1::RegisterBlock = 0x4002_2000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const sysctl1::RegisterBlock {
        Self::PTR
    }
}
impl Deref for SYSCTL1 {
    type Target = sysctl1::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for SYSCTL1 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("SYSCTL1").finish()
    }
}
#[doc = "SYSCTL1"]
pub mod sysctl1;
#[doc = "Pin Interrupts and Pattern Match"]
pub struct PINT {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for PINT {}
impl PINT {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const pint::RegisterBlock = 0x4002_5000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const pint::RegisterBlock {
        Self::PTR
    }
}
impl Deref for PINT {
    type Target = pint::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for PINT {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("PINT").finish()
    }
}
#[doc = "Pin Interrupts and Pattern Match"]
pub mod pint;
#[doc = "INPUTMUX"]
pub struct INPUTMUX {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for INPUTMUX {}
impl INPUTMUX {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const inputmux::RegisterBlock = 0x4002_6000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const inputmux::RegisterBlock {
        Self::PTR
    }
}
impl Deref for INPUTMUX {
    type Target = inputmux::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for INPUTMUX {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("INPUTMUX").finish()
    }
}
#[doc = "INPUTMUX"]
pub mod inputmux;
#[doc = "Counter/Timer"]
pub struct CTIMER0 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for CTIMER0 {}
impl CTIMER0 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const ctimer0::RegisterBlock = 0x4002_8000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const ctimer0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for CTIMER0 {
    type Target = ctimer0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for CTIMER0 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("CTIMER0").finish()
    }
}
#[doc = "Counter/Timer"]
pub mod ctimer0;
#[doc = "Counter/Timer"]
pub struct CTIMER1 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for CTIMER1 {}
impl CTIMER1 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const ctimer0::RegisterBlock = 0x4002_9000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const ctimer0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for CTIMER1 {
    type Target = ctimer0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for CTIMER1 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("CTIMER1").finish()
    }
}
#[doc = "Counter/Timer"]
pub use self::ctimer0 as ctimer1;
#[doc = "Counter/Timer"]
pub struct CTIMER2 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for CTIMER2 {}
impl CTIMER2 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const ctimer0::RegisterBlock = 0x4002_a000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const ctimer0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for CTIMER2 {
    type Target = ctimer0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for CTIMER2 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("CTIMER2").finish()
    }
}
#[doc = "Counter/Timer"]
pub use self::ctimer0 as ctimer2;
#[doc = "Counter/Timer"]
pub struct CTIMER3 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for CTIMER3 {}
impl CTIMER3 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const ctimer0::RegisterBlock = 0x4002_b000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const ctimer0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for CTIMER3 {
    type Target = ctimer0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for CTIMER3 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("CTIMER3").finish()
    }
}
#[doc = "Counter/Timer"]
pub use self::ctimer0 as ctimer3;
#[doc = "Counter/Timer"]
pub struct CTIMER4 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for CTIMER4 {}
impl CTIMER4 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const ctimer0::RegisterBlock = 0x4002_c000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const ctimer0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for CTIMER4 {
    type Target = ctimer0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for CTIMER4 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("CTIMER4").finish()
    }
}
#[doc = "Counter/Timer"]
pub use self::ctimer0 as ctimer4;
#[doc = "Multi-Rate Timer (MRT)"]
pub struct MRT0 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for MRT0 {}
impl MRT0 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const mrt0::RegisterBlock = 0x4002_d000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const mrt0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for MRT0 {
    type Target = mrt0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for MRT0 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("MRT0").finish()
    }
}
#[doc = "Multi-Rate Timer (MRT)"]
pub mod mrt0;
#[doc = "Frequency Measurement"]
pub struct FREQME {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for FREQME {}
impl FREQME {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const freqme::RegisterBlock = 0x4002_f000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const freqme::RegisterBlock {
        Self::PTR
    }
}
impl Deref for FREQME {
    type Target = freqme::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for FREQME {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("FREQME").finish()
    }
}
#[doc = "Frequency Measurement"]
pub mod freqme;
#[doc = "RTC"]
pub struct RTC {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for RTC {}
impl RTC {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const rtc::RegisterBlock = 0x4003_0000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const rtc::RegisterBlock {
        Self::PTR
    }
}
impl Deref for RTC {
    type Target = rtc::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for RTC {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("RTC").finish()
    }
}
#[doc = "RTC"]
pub mod rtc;
#[doc = "MIPI DSI Host"]
pub struct MIPI_DSI_HOST {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for MIPI_DSI_HOST {}
impl MIPI_DSI_HOST {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const mipi_dsi_host::RegisterBlock = 0x4003_1000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const mipi_dsi_host::RegisterBlock {
        Self::PTR
    }
}
impl Deref for MIPI_DSI_HOST {
    type Target = mipi_dsi_host::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for MIPI_DSI_HOST {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("MIPI_DSI_HOST").finish()
    }
}
#[doc = "MIPI DSI Host"]
pub mod mipi_dsi_host;
#[doc = "FLEXIO"]
pub struct FLEXIO0 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for FLEXIO0 {}
impl FLEXIO0 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const flexio0::RegisterBlock = 0x4003_2000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const flexio0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for FLEXIO0 {
    type Target = flexio0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for FLEXIO0 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("FLEXIO0").finish()
    }
}
#[doc = "FLEXIO"]
pub mod flexio0;
#[doc = "CACHE64"]
pub struct CACHE64_CTRL0 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for CACHE64_CTRL0 {}
impl CACHE64_CTRL0 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const cache64_ctrl0::RegisterBlock = 0x4003_3000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const cache64_ctrl0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for CACHE64_CTRL0 {
    type Target = cache64_ctrl0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for CACHE64_CTRL0 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("CACHE64_CTRL0").finish()
    }
}
#[doc = "CACHE64"]
pub mod cache64_ctrl0;
#[doc = "CACHE64"]
pub struct CACHE64_CTRL1 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for CACHE64_CTRL1 {}
impl CACHE64_CTRL1 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const cache64_ctrl0::RegisterBlock = 0x4003_4000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const cache64_ctrl0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for CACHE64_CTRL1 {
    type Target = cache64_ctrl0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for CACHE64_CTRL1 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("CACHE64_CTRL1").finish()
    }
}
#[doc = "CACHE64"]
pub use self::cache64_ctrl0 as cache64_ctrl1;
#[doc = "CACHE64_POLSEL"]
pub struct CACHE64_POLSEL0 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for CACHE64_POLSEL0 {}
impl CACHE64_POLSEL0 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const cache64_polsel0::RegisterBlock = 0x4003_3000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const cache64_polsel0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for CACHE64_POLSEL0 {
    type Target = cache64_polsel0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for CACHE64_POLSEL0 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("CACHE64_POLSEL0").finish()
    }
}
#[doc = "CACHE64_POLSEL"]
pub mod cache64_polsel0;
#[doc = "CACHE64_POLSEL"]
pub struct CACHE64_POLSEL1 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for CACHE64_POLSEL1 {}
impl CACHE64_POLSEL1 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const cache64_polsel0::RegisterBlock = 0x4003_4000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const cache64_polsel0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for CACHE64_POLSEL1 {
    type Target = cache64_polsel0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for CACHE64_POLSEL1 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("CACHE64_POLSEL1").finish()
    }
}
#[doc = "CACHE64_POLSEL"]
pub use self::cache64_polsel0 as cache64_polsel1;
#[doc = "I3C"]
pub struct I3C0 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for I3C0 {}
impl I3C0 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const i3c0::RegisterBlock = 0x4003_6000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const i3c0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for I3C0 {
    type Target = i3c0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for I3C0 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("I3C0").finish()
    }
}
#[doc = "I3C"]
pub mod i3c0;
#[doc = "I3C"]
pub struct I3C1 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for I3C1 {}
impl I3C1 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const i3c0::RegisterBlock = 0x4003_7000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const i3c0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for I3C1 {
    type Target = i3c0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for I3C1 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("I3C1").finish()
    }
}
#[doc = "I3C"]
pub use self::i3c0 as i3c1;
#[doc = "GPIO General Purpose I/O (GPIO)"]
pub struct GPIO {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for GPIO {}
impl GPIO {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const gpio::RegisterBlock = 0x4010_0000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const gpio::RegisterBlock {
        Self::PTR
    }
}
impl Deref for GPIO {
    type Target = gpio::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for GPIO {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("GPIO").finish()
    }
}
#[doc = "GPIO General Purpose I/O (GPIO)"]
pub mod gpio;
#[doc = "DMA0 controller"]
pub struct DMA0 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for DMA0 {}
impl DMA0 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const dma0::RegisterBlock = 0x4010_4000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const dma0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for DMA0 {
    type Target = dma0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for DMA0 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("DMA0").finish()
    }
}
#[doc = "DMA0 controller"]
pub mod dma0;
#[doc = "DMA1 controller"]
pub struct DMA1 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for DMA1 {}
impl DMA1 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const dma0::RegisterBlock = 0x4010_5000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const dma0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for DMA1 {
    type Target = dma0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for DMA1 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("DMA1").finish()
    }
}
#[doc = "DMA1 controller"]
pub use self::dma0 as dma1;
#[doc = "Flexcomm"]
pub struct FLEXCOMM0 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for FLEXCOMM0 {}
impl FLEXCOMM0 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const flexcomm0::RegisterBlock = 0x4010_6000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const flexcomm0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for FLEXCOMM0 {
    type Target = flexcomm0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for FLEXCOMM0 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("FLEXCOMM0").finish()
    }
}
#[doc = "Flexcomm"]
pub mod flexcomm0;
#[doc = "Flexcomm"]
pub struct FLEXCOMM1 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for FLEXCOMM1 {}
impl FLEXCOMM1 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const flexcomm0::RegisterBlock = 0x4010_7000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const flexcomm0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for FLEXCOMM1 {
    type Target = flexcomm0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for FLEXCOMM1 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("FLEXCOMM1").finish()
    }
}
#[doc = "Flexcomm"]
pub use self::flexcomm0 as flexcomm1;
#[doc = "Flexcomm"]
pub struct FLEXCOMM2 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for FLEXCOMM2 {}
impl FLEXCOMM2 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const flexcomm0::RegisterBlock = 0x4010_8000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const flexcomm0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for FLEXCOMM2 {
    type Target = flexcomm0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for FLEXCOMM2 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("FLEXCOMM2").finish()
    }
}
#[doc = "Flexcomm"]
pub use self::flexcomm0 as flexcomm2;
#[doc = "Flexcomm"]
pub struct FLEXCOMM3 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for FLEXCOMM3 {}
impl FLEXCOMM3 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const flexcomm0::RegisterBlock = 0x4010_9000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const flexcomm0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for FLEXCOMM3 {
    type Target = flexcomm0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for FLEXCOMM3 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("FLEXCOMM3").finish()
    }
}
#[doc = "Flexcomm"]
pub use self::flexcomm0 as flexcomm3;
#[doc = "Flexcomm"]
pub struct FLEXCOMM4 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for FLEXCOMM4 {}
impl FLEXCOMM4 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const flexcomm0::RegisterBlock = 0x4012_2000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const flexcomm0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for FLEXCOMM4 {
    type Target = flexcomm0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for FLEXCOMM4 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("FLEXCOMM4").finish()
    }
}
#[doc = "Flexcomm"]
pub use self::flexcomm0 as flexcomm4;
#[doc = "Flexcomm"]
pub struct FLEXCOMM5 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for FLEXCOMM5 {}
impl FLEXCOMM5 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const flexcomm0::RegisterBlock = 0x4012_3000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const flexcomm0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for FLEXCOMM5 {
    type Target = flexcomm0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for FLEXCOMM5 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("FLEXCOMM5").finish()
    }
}
#[doc = "Flexcomm"]
pub use self::flexcomm0 as flexcomm5;
#[doc = "Flexcomm"]
pub struct FLEXCOMM6 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for FLEXCOMM6 {}
impl FLEXCOMM6 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const flexcomm0::RegisterBlock = 0x4012_4000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const flexcomm0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for FLEXCOMM6 {
    type Target = flexcomm0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for FLEXCOMM6 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("FLEXCOMM6").finish()
    }
}
#[doc = "Flexcomm"]
pub use self::flexcomm0 as flexcomm6;
#[doc = "Flexcomm"]
pub struct FLEXCOMM7 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for FLEXCOMM7 {}
impl FLEXCOMM7 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const flexcomm0::RegisterBlock = 0x4012_5000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const flexcomm0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for FLEXCOMM7 {
    type Target = flexcomm0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for FLEXCOMM7 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("FLEXCOMM7").finish()
    }
}
#[doc = "Flexcomm"]
pub use self::flexcomm0 as flexcomm7;
#[doc = "Flexcomm"]
pub struct FLEXCOMM14 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for FLEXCOMM14 {}
impl FLEXCOMM14 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const flexcomm0::RegisterBlock = 0x4012_6000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const flexcomm0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for FLEXCOMM14 {
    type Target = flexcomm0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for FLEXCOMM14 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("FLEXCOMM14").finish()
    }
}
#[doc = "Flexcomm"]
pub use self::flexcomm0 as flexcomm14;
#[doc = "Flexcomm"]
pub struct FLEXCOMM15 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for FLEXCOMM15 {}
impl FLEXCOMM15 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const flexcomm0::RegisterBlock = 0x4012_7000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const flexcomm0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for FLEXCOMM15 {
    type Target = flexcomm0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for FLEXCOMM15 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("FLEXCOMM15").finish()
    }
}
#[doc = "Flexcomm"]
pub use self::flexcomm0 as flexcomm15;
#[doc = "Flexcomm"]
pub struct FLEXCOMM16 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for FLEXCOMM16 {}
impl FLEXCOMM16 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const flexcomm0::RegisterBlock = 0x4012_8000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const flexcomm0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for FLEXCOMM16 {
    type Target = flexcomm0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for FLEXCOMM16 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("FLEXCOMM16").finish()
    }
}
#[doc = "Flexcomm"]
pub use self::flexcomm0 as flexcomm16;
#[doc = "Flexcomm"]
pub struct FLEXCOMM8 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for FLEXCOMM8 {}
impl FLEXCOMM8 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const flexcomm0::RegisterBlock = 0x4020_9000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const flexcomm0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for FLEXCOMM8 {
    type Target = flexcomm0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for FLEXCOMM8 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("FLEXCOMM8").finish()
    }
}
#[doc = "Flexcomm"]
pub use self::flexcomm0 as flexcomm8;
#[doc = "Flexcomm"]
pub struct FLEXCOMM9 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for FLEXCOMM9 {}
impl FLEXCOMM9 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const flexcomm0::RegisterBlock = 0x4020_a000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const flexcomm0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for FLEXCOMM9 {
    type Target = flexcomm0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for FLEXCOMM9 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("FLEXCOMM9").finish()
    }
}
#[doc = "Flexcomm"]
pub use self::flexcomm0 as flexcomm9;
#[doc = "Flexcomm"]
pub struct FLEXCOMM10 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for FLEXCOMM10 {}
impl FLEXCOMM10 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const flexcomm0::RegisterBlock = 0x4020_b000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const flexcomm0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for FLEXCOMM10 {
    type Target = flexcomm0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for FLEXCOMM10 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("FLEXCOMM10").finish()
    }
}
#[doc = "Flexcomm"]
pub use self::flexcomm0 as flexcomm10;
#[doc = "Flexcomm"]
pub struct FLEXCOMM11 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for FLEXCOMM11 {}
impl FLEXCOMM11 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const flexcomm0::RegisterBlock = 0x4020_c000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const flexcomm0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for FLEXCOMM11 {
    type Target = flexcomm0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for FLEXCOMM11 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("FLEXCOMM11").finish()
    }
}
#[doc = "Flexcomm"]
pub use self::flexcomm0 as flexcomm11;
#[doc = "Flexcomm"]
pub struct FLEXCOMM12 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for FLEXCOMM12 {}
impl FLEXCOMM12 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const flexcomm0::RegisterBlock = 0x4020_d000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const flexcomm0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for FLEXCOMM12 {
    type Target = flexcomm0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for FLEXCOMM12 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("FLEXCOMM12").finish()
    }
}
#[doc = "Flexcomm"]
pub use self::flexcomm0 as flexcomm12;
#[doc = "Flexcomm"]
pub struct FLEXCOMM13 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for FLEXCOMM13 {}
impl FLEXCOMM13 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const flexcomm0::RegisterBlock = 0x4020_e000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const flexcomm0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for FLEXCOMM13 {
    type Target = flexcomm0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for FLEXCOMM13 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("FLEXCOMM13").finish()
    }
}
#[doc = "Flexcomm"]
pub use self::flexcomm0 as flexcomm13;
#[doc = "I2C Bus Interface"]
pub struct I2C0 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for I2C0 {}
impl I2C0 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const i2c0::RegisterBlock = 0x4010_6000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const i2c0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for I2C0 {
    type Target = i2c0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for I2C0 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("I2C0").finish()
    }
}
#[doc = "I2C Bus Interface"]
pub mod i2c0;
#[doc = "I2C Bus Interface"]
pub struct I2C1 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for I2C1 {}
impl I2C1 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const i2c0::RegisterBlock = 0x4010_7000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const i2c0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for I2C1 {
    type Target = i2c0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for I2C1 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("I2C1").finish()
    }
}
#[doc = "I2C Bus Interface"]
pub use self::i2c0 as i2c1;
#[doc = "I2C Bus Interface"]
pub struct I2C2 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for I2C2 {}
impl I2C2 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const i2c0::RegisterBlock = 0x4010_8000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const i2c0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for I2C2 {
    type Target = i2c0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for I2C2 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("I2C2").finish()
    }
}
#[doc = "I2C Bus Interface"]
pub use self::i2c0 as i2c2;
#[doc = "I2C Bus Interface"]
pub struct I2C3 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for I2C3 {}
impl I2C3 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const i2c0::RegisterBlock = 0x4010_9000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const i2c0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for I2C3 {
    type Target = i2c0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for I2C3 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("I2C3").finish()
    }
}
#[doc = "I2C Bus Interface"]
pub use self::i2c0 as i2c3;
#[doc = "I2C Bus Interface"]
pub struct I2C4 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for I2C4 {}
impl I2C4 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const i2c0::RegisterBlock = 0x4012_2000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const i2c0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for I2C4 {
    type Target = i2c0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for I2C4 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("I2C4").finish()
    }
}
#[doc = "I2C Bus Interface"]
pub use self::i2c0 as i2c4;
#[doc = "I2C Bus Interface"]
pub struct I2C5 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for I2C5 {}
impl I2C5 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const i2c0::RegisterBlock = 0x4012_3000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const i2c0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for I2C5 {
    type Target = i2c0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for I2C5 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("I2C5").finish()
    }
}
#[doc = "I2C Bus Interface"]
pub use self::i2c0 as i2c5;
#[doc = "I2C Bus Interface"]
pub struct I2C6 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for I2C6 {}
impl I2C6 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const i2c0::RegisterBlock = 0x4012_4000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const i2c0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for I2C6 {
    type Target = i2c0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for I2C6 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("I2C6").finish()
    }
}
#[doc = "I2C Bus Interface"]
pub use self::i2c0 as i2c6;
#[doc = "I2C Bus Interface"]
pub struct I2C7 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for I2C7 {}
impl I2C7 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const i2c0::RegisterBlock = 0x4012_5000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const i2c0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for I2C7 {
    type Target = i2c0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for I2C7 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("I2C7").finish()
    }
}
#[doc = "I2C Bus Interface"]
pub use self::i2c0 as i2c7;
#[doc = "I2C Bus Interface"]
pub struct I2C15 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for I2C15 {}
impl I2C15 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const i2c0::RegisterBlock = 0x4012_7000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const i2c0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for I2C15 {
    type Target = i2c0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for I2C15 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("I2C15").finish()
    }
}
#[doc = "I2C Bus Interface"]
pub use self::i2c0 as i2c15;
#[doc = "I2C Bus Interface"]
pub struct I2C8 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for I2C8 {}
impl I2C8 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const i2c0::RegisterBlock = 0x4020_9000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const i2c0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for I2C8 {
    type Target = i2c0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for I2C8 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("I2C8").finish()
    }
}
#[doc = "I2C Bus Interface"]
pub use self::i2c0 as i2c8;
#[doc = "I2C Bus Interface"]
pub struct I2C9 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for I2C9 {}
impl I2C9 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const i2c0::RegisterBlock = 0x4020_a000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const i2c0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for I2C9 {
    type Target = i2c0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for I2C9 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("I2C9").finish()
    }
}
#[doc = "I2C Bus Interface"]
pub use self::i2c0 as i2c9;
#[doc = "I2C Bus Interface"]
pub struct I2C10 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for I2C10 {}
impl I2C10 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const i2c0::RegisterBlock = 0x4020_b000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const i2c0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for I2C10 {
    type Target = i2c0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for I2C10 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("I2C10").finish()
    }
}
#[doc = "I2C Bus Interface"]
pub use self::i2c0 as i2c10;
#[doc = "I2C Bus Interface"]
pub struct I2C11 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for I2C11 {}
impl I2C11 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const i2c0::RegisterBlock = 0x4020_c000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const i2c0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for I2C11 {
    type Target = i2c0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for I2C11 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("I2C11").finish()
    }
}
#[doc = "I2C Bus Interface"]
pub use self::i2c0 as i2c11;
#[doc = "I2C Bus Interface"]
pub struct I2C12 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for I2C12 {}
impl I2C12 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const i2c0::RegisterBlock = 0x4020_d000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const i2c0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for I2C12 {
    type Target = i2c0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for I2C12 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("I2C12").finish()
    }
}
#[doc = "I2C Bus Interface"]
pub use self::i2c0 as i2c12;
#[doc = "I2C Bus Interface"]
pub struct I2C13 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for I2C13 {}
impl I2C13 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const i2c0::RegisterBlock = 0x4020_e000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const i2c0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for I2C13 {
    type Target = i2c0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for I2C13 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("I2C13").finish()
    }
}
#[doc = "I2C Bus Interface"]
pub use self::i2c0 as i2c13;
#[doc = "I2S Interface"]
pub struct I2S0 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for I2S0 {}
impl I2S0 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const i2s0::RegisterBlock = 0x4010_6000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const i2s0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for I2S0 {
    type Target = i2s0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for I2S0 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("I2S0").finish()
    }
}
#[doc = "I2S Interface"]
pub mod i2s0;
#[doc = "I2S Interface"]
pub struct I2S1 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for I2S1 {}
impl I2S1 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const i2s0::RegisterBlock = 0x4010_7000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const i2s0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for I2S1 {
    type Target = i2s0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for I2S1 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("I2S1").finish()
    }
}
#[doc = "I2S Interface"]
pub use self::i2s0 as i2s1;
#[doc = "I2S Interface"]
pub struct I2S2 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for I2S2 {}
impl I2S2 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const i2s0::RegisterBlock = 0x4010_8000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const i2s0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for I2S2 {
    type Target = i2s0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for I2S2 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("I2S2").finish()
    }
}
#[doc = "I2S Interface"]
pub use self::i2s0 as i2s2;
#[doc = "I2S Interface"]
pub struct I2S3 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for I2S3 {}
impl I2S3 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const i2s0::RegisterBlock = 0x4010_9000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const i2s0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for I2S3 {
    type Target = i2s0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for I2S3 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("I2S3").finish()
    }
}
#[doc = "I2S Interface"]
pub use self::i2s0 as i2s3;
#[doc = "I2S Interface"]
pub struct I2S4 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for I2S4 {}
impl I2S4 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const i2s0::RegisterBlock = 0x4012_2000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const i2s0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for I2S4 {
    type Target = i2s0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for I2S4 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("I2S4").finish()
    }
}
#[doc = "I2S Interface"]
pub use self::i2s0 as i2s4;
#[doc = "I2S Interface"]
pub struct I2S5 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for I2S5 {}
impl I2S5 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const i2s0::RegisterBlock = 0x4012_3000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const i2s0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for I2S5 {
    type Target = i2s0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for I2S5 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("I2S5").finish()
    }
}
#[doc = "I2S Interface"]
pub use self::i2s0 as i2s5;
#[doc = "I2S Interface"]
pub struct I2S6 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for I2S6 {}
impl I2S6 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const i2s0::RegisterBlock = 0x4012_4000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const i2s0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for I2S6 {
    type Target = i2s0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for I2S6 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("I2S6").finish()
    }
}
#[doc = "I2S Interface"]
pub use self::i2s0 as i2s6;
#[doc = "I2S Interface"]
pub struct I2S7 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for I2S7 {}
impl I2S7 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const i2s0::RegisterBlock = 0x4012_5000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const i2s0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for I2S7 {
    type Target = i2s0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for I2S7 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("I2S7").finish()
    }
}
#[doc = "I2S Interface"]
pub use self::i2s0 as i2s7;
#[doc = "I2S Interface"]
pub struct I2S8 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for I2S8 {}
impl I2S8 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const i2s0::RegisterBlock = 0x4020_9000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const i2s0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for I2S8 {
    type Target = i2s0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for I2S8 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("I2S8").finish()
    }
}
#[doc = "I2S Interface"]
pub use self::i2s0 as i2s8;
#[doc = "I2S Interface"]
pub struct I2S9 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for I2S9 {}
impl I2S9 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const i2s0::RegisterBlock = 0x4020_a000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const i2s0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for I2S9 {
    type Target = i2s0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for I2S9 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("I2S9").finish()
    }
}
#[doc = "I2S Interface"]
pub use self::i2s0 as i2s9;
#[doc = "I2S Interface"]
pub struct I2S10 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for I2S10 {}
impl I2S10 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const i2s0::RegisterBlock = 0x4020_b000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const i2s0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for I2S10 {
    type Target = i2s0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for I2S10 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("I2S10").finish()
    }
}
#[doc = "I2S Interface"]
pub use self::i2s0 as i2s10;
#[doc = "I2S Interface"]
pub struct I2S11 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for I2S11 {}
impl I2S11 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const i2s0::RegisterBlock = 0x4020_c000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const i2s0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for I2S11 {
    type Target = i2s0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for I2S11 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("I2S11").finish()
    }
}
#[doc = "I2S Interface"]
pub use self::i2s0 as i2s11;
#[doc = "I2S Interface"]
pub struct I2S12 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for I2S12 {}
impl I2S12 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const i2s0::RegisterBlock = 0x4020_d000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const i2s0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for I2S12 {
    type Target = i2s0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for I2S12 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("I2S12").finish()
    }
}
#[doc = "I2S Interface"]
pub use self::i2s0 as i2s12;
#[doc = "I2S Interface"]
pub struct I2S13 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for I2S13 {}
impl I2S13 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const i2s0::RegisterBlock = 0x4020_e000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const i2s0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for I2S13 {
    type Target = i2s0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for I2S13 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("I2S13").finish()
    }
}
#[doc = "I2S Interface"]
pub use self::i2s0 as i2s13;
#[doc = "Serial Peripheral Interfaces (SPI)"]
pub struct SPI0 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for SPI0 {}
impl SPI0 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const spi0::RegisterBlock = 0x4010_6000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const spi0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for SPI0 {
    type Target = spi0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for SPI0 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("SPI0").finish()
    }
}
#[doc = "Serial Peripheral Interfaces (SPI)"]
pub mod spi0;
#[doc = "Serial Peripheral Interfaces (SPI)"]
pub struct SPI1 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for SPI1 {}
impl SPI1 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const spi0::RegisterBlock = 0x4010_7000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const spi0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for SPI1 {
    type Target = spi0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for SPI1 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("SPI1").finish()
    }
}
#[doc = "Serial Peripheral Interfaces (SPI)"]
pub use self::spi0 as spi1;
#[doc = "Serial Peripheral Interfaces (SPI)"]
pub struct SPI2 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for SPI2 {}
impl SPI2 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const spi0::RegisterBlock = 0x4010_8000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const spi0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for SPI2 {
    type Target = spi0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for SPI2 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("SPI2").finish()
    }
}
#[doc = "Serial Peripheral Interfaces (SPI)"]
pub use self::spi0 as spi2;
#[doc = "Serial Peripheral Interfaces (SPI)"]
pub struct SPI3 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for SPI3 {}
impl SPI3 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const spi0::RegisterBlock = 0x4010_9000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const spi0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for SPI3 {
    type Target = spi0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for SPI3 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("SPI3").finish()
    }
}
#[doc = "Serial Peripheral Interfaces (SPI)"]
pub use self::spi0 as spi3;
#[doc = "Serial Peripheral Interfaces (SPI)"]
pub struct SPI4 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for SPI4 {}
impl SPI4 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const spi0::RegisterBlock = 0x4012_2000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const spi0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for SPI4 {
    type Target = spi0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for SPI4 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("SPI4").finish()
    }
}
#[doc = "Serial Peripheral Interfaces (SPI)"]
pub use self::spi0 as spi4;
#[doc = "Serial Peripheral Interfaces (SPI)"]
pub struct SPI5 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for SPI5 {}
impl SPI5 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const spi0::RegisterBlock = 0x4012_3000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const spi0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for SPI5 {
    type Target = spi0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for SPI5 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("SPI5").finish()
    }
}
#[doc = "Serial Peripheral Interfaces (SPI)"]
pub use self::spi0 as spi5;
#[doc = "Serial Peripheral Interfaces (SPI)"]
pub struct SPI6 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for SPI6 {}
impl SPI6 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const spi0::RegisterBlock = 0x4012_4000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const spi0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for SPI6 {
    type Target = spi0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for SPI6 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("SPI6").finish()
    }
}
#[doc = "Serial Peripheral Interfaces (SPI)"]
pub use self::spi0 as spi6;
#[doc = "Serial Peripheral Interfaces (SPI)"]
pub struct SPI7 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for SPI7 {}
impl SPI7 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const spi0::RegisterBlock = 0x4012_5000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const spi0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for SPI7 {
    type Target = spi0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for SPI7 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("SPI7").finish()
    }
}
#[doc = "Serial Peripheral Interfaces (SPI)"]
pub use self::spi0 as spi7;
#[doc = "Serial Peripheral Interfaces (SPI)"]
pub struct SPI14 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for SPI14 {}
impl SPI14 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const spi0::RegisterBlock = 0x4012_6000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const spi0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for SPI14 {
    type Target = spi0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for SPI14 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("SPI14").finish()
    }
}
#[doc = "Serial Peripheral Interfaces (SPI)"]
pub use self::spi0 as spi14;
#[doc = "Serial Peripheral Interfaces (SPI)"]
pub struct SPI16 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for SPI16 {}
impl SPI16 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const spi0::RegisterBlock = 0x4012_8000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const spi0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for SPI16 {
    type Target = spi0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for SPI16 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("SPI16").finish()
    }
}
#[doc = "Serial Peripheral Interfaces (SPI)"]
pub use self::spi0 as spi16;
#[doc = "Serial Peripheral Interfaces (SPI)"]
pub struct SPI8 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for SPI8 {}
impl SPI8 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const spi0::RegisterBlock = 0x4020_9000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const spi0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for SPI8 {
    type Target = spi0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for SPI8 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("SPI8").finish()
    }
}
#[doc = "Serial Peripheral Interfaces (SPI)"]
pub use self::spi0 as spi8;
#[doc = "Serial Peripheral Interfaces (SPI)"]
pub struct SPI9 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for SPI9 {}
impl SPI9 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const spi0::RegisterBlock = 0x4020_a000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const spi0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for SPI9 {
    type Target = spi0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for SPI9 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("SPI9").finish()
    }
}
#[doc = "Serial Peripheral Interfaces (SPI)"]
pub use self::spi0 as spi9;
#[doc = "Serial Peripheral Interfaces (SPI)"]
pub struct SPI10 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for SPI10 {}
impl SPI10 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const spi0::RegisterBlock = 0x4020_b000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const spi0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for SPI10 {
    type Target = spi0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for SPI10 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("SPI10").finish()
    }
}
#[doc = "Serial Peripheral Interfaces (SPI)"]
pub use self::spi0 as spi10;
#[doc = "Serial Peripheral Interfaces (SPI)"]
pub struct SPI11 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for SPI11 {}
impl SPI11 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const spi0::RegisterBlock = 0x4020_c000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const spi0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for SPI11 {
    type Target = spi0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for SPI11 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("SPI11").finish()
    }
}
#[doc = "Serial Peripheral Interfaces (SPI)"]
pub use self::spi0 as spi11;
#[doc = "Serial Peripheral Interfaces (SPI)"]
pub struct SPI12 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for SPI12 {}
impl SPI12 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const spi0::RegisterBlock = 0x4020_d000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const spi0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for SPI12 {
    type Target = spi0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for SPI12 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("SPI12").finish()
    }
}
#[doc = "Serial Peripheral Interfaces (SPI)"]
pub use self::spi0 as spi12;
#[doc = "Serial Peripheral Interfaces (SPI)"]
pub struct SPI13 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for SPI13 {}
impl SPI13 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const spi0::RegisterBlock = 0x4020_e000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const spi0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for SPI13 {
    type Target = spi0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for SPI13 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("SPI13").finish()
    }
}
#[doc = "Serial Peripheral Interfaces (SPI)"]
pub use self::spi0 as spi13;
#[doc = "Flexcomm USART"]
pub struct USART0 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for USART0 {}
impl USART0 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const usart0::RegisterBlock = 0x4010_6000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const usart0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for USART0 {
    type Target = usart0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for USART0 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("USART0").finish()
    }
}
#[doc = "Flexcomm USART"]
pub mod usart0;
#[doc = "Flexcomm USART"]
pub struct USART1 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for USART1 {}
impl USART1 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const usart0::RegisterBlock = 0x4010_7000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const usart0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for USART1 {
    type Target = usart0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for USART1 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("USART1").finish()
    }
}
#[doc = "Flexcomm USART"]
pub use self::usart0 as usart1;
#[doc = "Flexcomm USART"]
pub struct USART2 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for USART2 {}
impl USART2 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const usart0::RegisterBlock = 0x4010_8000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const usart0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for USART2 {
    type Target = usart0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for USART2 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("USART2").finish()
    }
}
#[doc = "Flexcomm USART"]
pub use self::usart0 as usart2;
#[doc = "Flexcomm USART"]
pub struct USART3 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for USART3 {}
impl USART3 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const usart0::RegisterBlock = 0x4010_9000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const usart0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for USART3 {
    type Target = usart0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for USART3 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("USART3").finish()
    }
}
#[doc = "Flexcomm USART"]
pub use self::usart0 as usart3;
#[doc = "Flexcomm USART"]
pub struct USART4 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for USART4 {}
impl USART4 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const usart0::RegisterBlock = 0x4012_2000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const usart0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for USART4 {
    type Target = usart0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for USART4 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("USART4").finish()
    }
}
#[doc = "Flexcomm USART"]
pub use self::usart0 as usart4;
#[doc = "Flexcomm USART"]
pub struct USART5 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for USART5 {}
impl USART5 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const usart0::RegisterBlock = 0x4012_3000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const usart0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for USART5 {
    type Target = usart0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for USART5 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("USART5").finish()
    }
}
#[doc = "Flexcomm USART"]
pub use self::usart0 as usart5;
#[doc = "Flexcomm USART"]
pub struct USART6 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for USART6 {}
impl USART6 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const usart0::RegisterBlock = 0x4012_4000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const usart0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for USART6 {
    type Target = usart0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for USART6 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("USART6").finish()
    }
}
#[doc = "Flexcomm USART"]
pub use self::usart0 as usart6;
#[doc = "Flexcomm USART"]
pub struct USART7 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for USART7 {}
impl USART7 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const usart0::RegisterBlock = 0x4012_5000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const usart0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for USART7 {
    type Target = usart0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for USART7 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("USART7").finish()
    }
}
#[doc = "Flexcomm USART"]
pub use self::usart0 as usart7;
#[doc = "Flexcomm USART"]
pub struct USART8 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for USART8 {}
impl USART8 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const usart0::RegisterBlock = 0x4020_9000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const usart0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for USART8 {
    type Target = usart0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for USART8 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("USART8").finish()
    }
}
#[doc = "Flexcomm USART"]
pub use self::usart0 as usart8;
#[doc = "Flexcomm USART"]
pub struct USART9 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for USART9 {}
impl USART9 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const usart0::RegisterBlock = 0x4020_a000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const usart0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for USART9 {
    type Target = usart0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for USART9 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("USART9").finish()
    }
}
#[doc = "Flexcomm USART"]
pub use self::usart0 as usart9;
#[doc = "Flexcomm USART"]
pub struct USART10 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for USART10 {}
impl USART10 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const usart0::RegisterBlock = 0x4020_b000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const usart0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for USART10 {
    type Target = usart0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for USART10 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("USART10").finish()
    }
}
#[doc = "Flexcomm USART"]
pub use self::usart0 as usart10;
#[doc = "Flexcomm USART"]
pub struct USART11 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for USART11 {}
impl USART11 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const usart0::RegisterBlock = 0x4020_c000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const usart0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for USART11 {
    type Target = usart0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for USART11 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("USART11").finish()
    }
}
#[doc = "Flexcomm USART"]
pub use self::usart0 as usart11;
#[doc = "Flexcomm USART"]
pub struct USART12 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for USART12 {}
impl USART12 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const usart0::RegisterBlock = 0x4020_d000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const usart0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for USART12 {
    type Target = usart0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for USART12 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("USART12").finish()
    }
}
#[doc = "Flexcomm USART"]
pub use self::usart0 as usart12;
#[doc = "Flexcomm USART"]
pub struct USART13 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for USART13 {}
impl USART13 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const usart0::RegisterBlock = 0x4020_e000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const usart0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for USART13 {
    type Target = usart0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for USART13 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("USART13").finish()
    }
}
#[doc = "Flexcomm USART"]
pub use self::usart0 as usart13;
#[doc = "Debug"]
pub struct DEBUGGER_MAILBOX {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for DEBUGGER_MAILBOX {}
impl DEBUGGER_MAILBOX {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const debugger_mailbox::RegisterBlock = 0x4010_f000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const debugger_mailbox::RegisterBlock {
        Self::PTR
    }
}
impl Deref for DEBUGGER_MAILBOX {
    type Target = debugger_mailbox::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for DEBUGGER_MAILBOX {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("DEBUGGER_MAILBOX").finish()
    }
}
#[doc = "Debug"]
pub mod debugger_mailbox;
#[doc = "MUA"]
pub struct MUA {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for MUA {}
impl MUA {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const mua::RegisterBlock = 0x4011_0000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const mua::RegisterBlock {
        Self::PTR
    }
}
impl Deref for MUA {
    type Target = mua::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for MUA {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("MUA").finish()
    }
}
#[doc = "MUA"]
pub mod mua;
#[doc = "SEMA42"]
pub struct SEMA42 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for SEMA42 {}
impl SEMA42 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const sema42::RegisterBlock = 0x4011_2000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const sema42::RegisterBlock {
        Self::PTR
    }
}
impl Deref for SEMA42 {
    type Target = sema42::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for SEMA42 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("SEMA42").finish()
    }
}
#[doc = "SEMA42"]
pub mod sema42;
#[doc = "OSTIMER"]
pub struct OSTIMER0 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for OSTIMER0 {}
impl OSTIMER0 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const ostimer0::RegisterBlock = 0x4011_3000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const ostimer0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for OSTIMER0 {
    type Target = ostimer0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for OSTIMER0 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("OSTIMER0").finish()
    }
}
#[doc = "OSTIMER"]
pub mod ostimer0;
#[doc = "CRC"]
pub struct CRC_ENGINE {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for CRC_ENGINE {}
impl CRC_ENGINE {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const crc_engine::RegisterBlock = 0x4012_0000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const crc_engine::RegisterBlock {
        Self::PTR
    }
}
impl Deref for CRC_ENGINE {
    type Target = crc_engine::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for CRC_ENGINE {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("CRC_ENGINE").finish()
    }
}
#[doc = "CRC"]
pub mod crc_engine;
#[doc = "DMIC"]
pub struct DMIC0 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for DMIC0 {}
impl DMIC0 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const dmic0::RegisterBlock = 0x4012_1000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const dmic0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for DMIC0 {
    type Target = dmic0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for DMIC0 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("DMIC0").finish()
    }
}
#[doc = "DMIC"]
pub mod dmic0;
#[doc = "OCOTP Controller"]
pub struct OCOTP0 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for OCOTP0 {}
impl OCOTP0 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const ocotp0::RegisterBlock = 0x4013_0000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const ocotp0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for OCOTP0 {
    type Target = ocotp0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for OCOTP0 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("OCOTP0").finish()
    }
}
#[doc = "OCOTP Controller"]
pub mod ocotp0;
#[doc = "FlexSPI"]
pub struct FLEXSPI0 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for FLEXSPI0 {}
impl FLEXSPI0 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const flexspi0::RegisterBlock = 0x4013_4000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const flexspi0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for FLEXSPI0 {
    type Target = flexspi0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for FLEXSPI0 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("FLEXSPI0").finish()
    }
}
#[doc = "FlexSPI"]
pub mod flexspi0;
#[doc = "OTFAD"]
pub struct OTFAD0 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for OTFAD0 {}
impl OTFAD0 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const otfad0::RegisterBlock = 0x4013_4000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const otfad0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for OTFAD0 {
    type Target = otfad0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for OTFAD0 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("OTFAD0").finish()
    }
}
#[doc = "OTFAD"]
pub mod otfad0;
#[doc = "Power Management"]
pub struct PMC {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for PMC {}
impl PMC {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const pmc::RegisterBlock = 0x4013_5000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const pmc::RegisterBlock {
        Self::PTR
    }
}
impl Deref for PMC {
    type Target = pmc::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for PMC {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("PMC").finish()
    }
}
#[doc = "Power Management"]
pub mod pmc;
#[doc = "uSDHC"]
pub struct USDHC0 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for USDHC0 {}
impl USDHC0 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const usdhc0::RegisterBlock = 0x4013_6000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const usdhc0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for USDHC0 {
    type Target = usdhc0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for USDHC0 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("USDHC0").finish()
    }
}
#[doc = "uSDHC"]
pub mod usdhc0;
#[doc = "uSDHC"]
pub struct USDHC1 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for USDHC1 {}
impl USDHC1 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const usdhc1::RegisterBlock = 0x4013_7000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const usdhc1::RegisterBlock {
        Self::PTR
    }
}
impl Deref for USDHC1 {
    type Target = usdhc1::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for USDHC1 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("USDHC1").finish()
    }
}
#[doc = "uSDHC"]
pub mod usdhc1;
#[doc = "TRNG"]
pub struct TRNG {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for TRNG {}
impl TRNG {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const trng::RegisterBlock = 0x4013_8000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const trng::RegisterBlock {
        Self::PTR
    }
}
impl Deref for TRNG {
    type Target = trng::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for TRNG {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("TRNG").finish()
    }
}
#[doc = "TRNG"]
pub mod trng;
#[doc = "CMP"]
pub struct ACMP0 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for ACMP0 {}
impl ACMP0 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const acmp0::RegisterBlock = 0x4013_9000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const acmp0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for ACMP0 {
    type Target = acmp0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for ACMP0 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("ACMP0").finish()
    }
}
#[doc = "CMP"]
pub mod acmp0;
#[doc = "ADC"]
pub struct ADC0 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for ADC0 {}
impl ADC0 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const adc0::RegisterBlock = 0x4013_a000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const adc0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for ADC0 {
    type Target = adc0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for ADC0 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("ADC0").finish()
    }
}
#[doc = "ADC"]
pub mod adc0;
#[doc = "USB2.0 HS PHY"]
pub struct USBPHY {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for USBPHY {}
impl USBPHY {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const usbphy::RegisterBlock = 0x4013_b000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const usbphy::RegisterBlock {
        Self::PTR
    }
}
impl Deref for USBPHY {
    type Target = usbphy::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for USBPHY {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("USBPHY").finish()
    }
}
#[doc = "USB2.0 HS PHY"]
pub mod usbphy;
#[doc = "USBDCD"]
pub struct USBHSDCD {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for USBHSDCD {}
impl USBHSDCD {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const usbhsdcd::RegisterBlock = 0x4013_b800 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const usbhsdcd::RegisterBlock {
        Self::PTR
    }
}
impl Deref for USBHSDCD {
    type Target = usbhsdcd::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for USBHSDCD {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("USBHSDCD").finish()
    }
}
#[doc = "USBDCD"]
pub mod usbhsdcd;
#[doc = "FlexSPI"]
pub struct FLEXSPI1 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for FLEXSPI1 {}
impl FLEXSPI1 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const flexspi1::RegisterBlock = 0x4013_c000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const flexspi1::RegisterBlock {
        Self::PTR
    }
}
impl Deref for FLEXSPI1 {
    type Target = flexspi1::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for FLEXSPI1 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("FLEXSPI1").finish()
    }
}
#[doc = "FlexSPI"]
pub mod flexspi1;
#[doc = "USB2.0 HS Device Controller"]
pub struct USBHSD {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for USBHSD {}
impl USBHSD {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const usbhsd::RegisterBlock = 0x4014_4000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const usbhsd::RegisterBlock {
        Self::PTR
    }
}
impl Deref for USBHSD {
    type Target = usbhsd::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for USBHSD {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("USBHSD").finish()
    }
}
#[doc = "USB2.0 HS Device Controller"]
pub mod usbhsd;
#[doc = "USB2.0 HS Host Controller"]
pub struct USBHSH {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for USBHSH {}
impl USBHSH {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const usbhsh::RegisterBlock = 0x4014_5000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const usbhsh::RegisterBlock {
        Self::PTR
    }
}
impl Deref for USBHSH {
    type Target = usbhsh::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for USBHSH {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("USBHSH").finish()
    }
}
#[doc = "USB2.0 HS Host Controller"]
pub mod usbhsh;
#[doc = "SCTimer"]
pub struct SCT0 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for SCT0 {}
impl SCT0 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const sct0::RegisterBlock = 0x4014_6000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const sct0::RegisterBlock {
        Self::PTR
    }
}
impl Deref for SCT0 {
    type Target = sct0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for SCT0 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("SCT0").finish()
    }
}
#[doc = "SCTimer"]
pub mod sct0;
#[doc = "AHBSC"]
pub struct AHB_SECURE_CTRL {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for AHB_SECURE_CTRL {}
impl AHB_SECURE_CTRL {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const ahb_secure_ctrl::RegisterBlock = 0x4014_8000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const ahb_secure_ctrl::RegisterBlock {
        Self::PTR
    }
}
impl Deref for AHB_SECURE_CTRL {
    type Target = ahb_secure_ctrl::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for AHB_SECURE_CTRL {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("AHB_SECURE_CTRL").finish()
    }
}
#[doc = "AHBSC"]
pub mod ahb_secure_ctrl;
#[doc = "PowerQuad"]
pub struct POWERQUAD {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for POWERQUAD {}
impl POWERQUAD {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const powerquad::RegisterBlock = 0x4020_0000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const powerquad::RegisterBlock {
        Self::PTR
    }
}
impl Deref for POWERQUAD {
    type Target = powerquad::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for POWERQUAD {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("POWERQUAD").finish()
    }
}
#[doc = "PowerQuad"]
pub mod powerquad;
#[doc = "CASPER"]
pub struct CASPER {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for CASPER {}
impl CASPER {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const casper::RegisterBlock = 0x4020_1000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const casper::RegisterBlock {
        Self::PTR
    }
}
impl Deref for CASPER {
    type Target = casper::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for CASPER {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("CASPER").finish()
    }
}
#[doc = "CASPER"]
pub mod casper;
#[doc = "SECGPIO General Purpose I/O (GPIO)"]
pub struct SECGPIO {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for SECGPIO {}
impl SECGPIO {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const secgpio::RegisterBlock = 0x4020_4000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const secgpio::RegisterBlock {
        Self::PTR
    }
}
impl Deref for SECGPIO {
    type Target = secgpio::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for SECGPIO {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("SECGPIO").finish()
    }
}
#[doc = "SECGPIO General Purpose I/O (GPIO)"]
pub mod secgpio;
#[doc = "HASHCRYPT"]
pub struct HASHCRYPT {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for HASHCRYPT {}
impl HASHCRYPT {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const hashcrypt::RegisterBlock = 0x4020_8000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const hashcrypt::RegisterBlock {
        Self::PTR
    }
}
impl Deref for HASHCRYPT {
    type Target = hashcrypt::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for HASHCRYPT {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("HASHCRYPT").finish()
    }
}
#[doc = "HASHCRYPT"]
pub mod hashcrypt;
#[doc = "LCDIF"]
pub struct LCDIF {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for LCDIF {}
impl LCDIF {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const lcdif::RegisterBlock = 0x4021_0000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const lcdif::RegisterBlock {
        Self::PTR
    }
}
impl Deref for LCDIF {
    type Target = lcdif::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for LCDIF {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("LCDIF").finish()
    }
}
#[doc = "LCDIF"]
pub mod lcdif;
#[doc = "AXI SWITCH AMIB"]
pub struct AXI_SWITCH_AMIB {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for AXI_SWITCH_AMIB {}
impl AXI_SWITCH_AMIB {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const axi_switch_amib::RegisterBlock = 0x4028_2000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const axi_switch_amib::RegisterBlock {
        Self::PTR
    }
}
impl Deref for AXI_SWITCH_AMIB {
    type Target = axi_switch_amib::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for AXI_SWITCH_AMIB {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("AXI_SWITCH_AMIB").finish()
    }
}
#[doc = "AXI SWITCH AMIB"]
pub mod axi_switch_amib;
#[doc = "AXI SWITCH ASIB"]
pub struct AXI_SWITCH_ASIB {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for AXI_SWITCH_ASIB {}
impl AXI_SWITCH_ASIB {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const axi_switch_asib::RegisterBlock = 0x402c_2000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const axi_switch_asib::RegisterBlock {
        Self::PTR
    }
}
impl Deref for AXI_SWITCH_ASIB {
    type Target = axi_switch_asib::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for AXI_SWITCH_ASIB {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("AXI_SWITCH_ASIB").finish()
    }
}
#[doc = "AXI SWITCH ASIB"]
pub mod axi_switch_asib;
#[doc = "no description available"]
pub struct SCN_SCB {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for SCN_SCB {}
impl SCN_SCB {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const scn_scb::RegisterBlock = 0xe000_e000 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const scn_scb::RegisterBlock {
        Self::PTR
    }
}
impl Deref for SCN_SCB {
    type Target = scn_scb::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for SCN_SCB {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("SCN_SCB").finish()
    }
}
#[doc = "no description available"]
pub mod scn_scb;
#[doc = "no description available"]
pub struct SAU {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for SAU {}
impl SAU {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const sau::RegisterBlock = 0xe000_edd0 as *const _;
    #[doc = r"Return the pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const sau::RegisterBlock {
        Self::PTR
    }
}
impl Deref for SAU {
    type Target = sau::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
impl core::fmt::Debug for SAU {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("SAU").finish()
    }
}
#[doc = "no description available"]
pub mod sau;
#[no_mangle]
static mut DEVICE_PERIPHERALS: bool = false;
#[doc = r" All the peripherals."]
#[allow(non_snake_case)]
pub struct Peripherals {
    #[doc = "RSTCTL0"]
    pub RSTCTL0: RSTCTL0,
    #[doc = "CLKCTL0"]
    pub CLKCTL0: CLKCTL0,
    #[doc = "SYSCTL0"]
    pub SYSCTL0: SYSCTL0,
    #[doc = "IOPCTL"]
    pub IOPCTL: IOPCTL,
    #[doc = "PUF"]
    pub PUF: PUF,
    #[doc = "WWDT0"]
    pub WWDT0: WWDT0,
    #[doc = "WWDT1"]
    pub WWDT1: WWDT1,
    #[doc = "UTICK0"]
    pub UTICK0: UTICK0,
    #[doc = "RSTCTL1"]
    pub RSTCTL1: RSTCTL1,
    #[doc = "CLKCTL1"]
    pub CLKCTL1: CLKCTL1,
    #[doc = "SYSCTL1"]
    pub SYSCTL1: SYSCTL1,
    #[doc = "PINT"]
    pub PINT: PINT,
    #[doc = "INPUTMUX"]
    pub INPUTMUX: INPUTMUX,
    #[doc = "CTIMER0"]
    pub CTIMER0: CTIMER0,
    #[doc = "CTIMER1"]
    pub CTIMER1: CTIMER1,
    #[doc = "CTIMER2"]
    pub CTIMER2: CTIMER2,
    #[doc = "CTIMER3"]
    pub CTIMER3: CTIMER3,
    #[doc = "CTIMER4"]
    pub CTIMER4: CTIMER4,
    #[doc = "MRT0"]
    pub MRT0: MRT0,
    #[doc = "FREQME"]
    pub FREQME: FREQME,
    #[doc = "RTC"]
    pub RTC: RTC,
    #[doc = "MIPI_DSI_HOST"]
    pub MIPI_DSI_HOST: MIPI_DSI_HOST,
    #[doc = "FLEXIO0"]
    pub FLEXIO0: FLEXIO0,
    #[doc = "CACHE64_CTRL0"]
    pub CACHE64_CTRL0: CACHE64_CTRL0,
    #[doc = "CACHE64_CTRL1"]
    pub CACHE64_CTRL1: CACHE64_CTRL1,
    #[doc = "CACHE64_POLSEL0"]
    pub CACHE64_POLSEL0: CACHE64_POLSEL0,
    #[doc = "CACHE64_POLSEL1"]
    pub CACHE64_POLSEL1: CACHE64_POLSEL1,
    #[doc = "I3C0"]
    pub I3C0: I3C0,
    #[doc = "I3C1"]
    pub I3C1: I3C1,
    #[doc = "GPIO"]
    pub GPIO: GPIO,
    #[doc = "DMA0"]
    pub DMA0: DMA0,
    #[doc = "DMA1"]
    pub DMA1: DMA1,
    #[doc = "FLEXCOMM0"]
    pub FLEXCOMM0: FLEXCOMM0,
    #[doc = "FLEXCOMM1"]
    pub FLEXCOMM1: FLEXCOMM1,
    #[doc = "FLEXCOMM2"]
    pub FLEXCOMM2: FLEXCOMM2,
    #[doc = "FLEXCOMM3"]
    pub FLEXCOMM3: FLEXCOMM3,
    #[doc = "FLEXCOMM4"]
    pub FLEXCOMM4: FLEXCOMM4,
    #[doc = "FLEXCOMM5"]
    pub FLEXCOMM5: FLEXCOMM5,
    #[doc = "FLEXCOMM6"]
    pub FLEXCOMM6: FLEXCOMM6,
    #[doc = "FLEXCOMM7"]
    pub FLEXCOMM7: FLEXCOMM7,
    #[doc = "FLEXCOMM14"]
    pub FLEXCOMM14: FLEXCOMM14,
    #[doc = "FLEXCOMM15"]
    pub FLEXCOMM15: FLEXCOMM15,
    #[doc = "FLEXCOMM16"]
    pub FLEXCOMM16: FLEXCOMM16,
    #[doc = "FLEXCOMM8"]
    pub FLEXCOMM8: FLEXCOMM8,
    #[doc = "FLEXCOMM9"]
    pub FLEXCOMM9: FLEXCOMM9,
    #[doc = "FLEXCOMM10"]
    pub FLEXCOMM10: FLEXCOMM10,
    #[doc = "FLEXCOMM11"]
    pub FLEXCOMM11: FLEXCOMM11,
    #[doc = "FLEXCOMM12"]
    pub FLEXCOMM12: FLEXCOMM12,
    #[doc = "FLEXCOMM13"]
    pub FLEXCOMM13: FLEXCOMM13,
    #[doc = "I2C0"]
    pub I2C0: I2C0,
    #[doc = "I2C1"]
    pub I2C1: I2C1,
    #[doc = "I2C2"]
    pub I2C2: I2C2,
    #[doc = "I2C3"]
    pub I2C3: I2C3,
    #[doc = "I2C4"]
    pub I2C4: I2C4,
    #[doc = "I2C5"]
    pub I2C5: I2C5,
    #[doc = "I2C6"]
    pub I2C6: I2C6,
    #[doc = "I2C7"]
    pub I2C7: I2C7,
    #[doc = "I2C15"]
    pub I2C15: I2C15,
    #[doc = "I2C8"]
    pub I2C8: I2C8,
    #[doc = "I2C9"]
    pub I2C9: I2C9,
    #[doc = "I2C10"]
    pub I2C10: I2C10,
    #[doc = "I2C11"]
    pub I2C11: I2C11,
    #[doc = "I2C12"]
    pub I2C12: I2C12,
    #[doc = "I2C13"]
    pub I2C13: I2C13,
    #[doc = "I2S0"]
    pub I2S0: I2S0,
    #[doc = "I2S1"]
    pub I2S1: I2S1,
    #[doc = "I2S2"]
    pub I2S2: I2S2,
    #[doc = "I2S3"]
    pub I2S3: I2S3,
    #[doc = "I2S4"]
    pub I2S4: I2S4,
    #[doc = "I2S5"]
    pub I2S5: I2S5,
    #[doc = "I2S6"]
    pub I2S6: I2S6,
    #[doc = "I2S7"]
    pub I2S7: I2S7,
    #[doc = "I2S8"]
    pub I2S8: I2S8,
    #[doc = "I2S9"]
    pub I2S9: I2S9,
    #[doc = "I2S10"]
    pub I2S10: I2S10,
    #[doc = "I2S11"]
    pub I2S11: I2S11,
    #[doc = "I2S12"]
    pub I2S12: I2S12,
    #[doc = "I2S13"]
    pub I2S13: I2S13,
    #[doc = "SPI0"]
    pub SPI0: SPI0,
    #[doc = "SPI1"]
    pub SPI1: SPI1,
    #[doc = "SPI2"]
    pub SPI2: SPI2,
    #[doc = "SPI3"]
    pub SPI3: SPI3,
    #[doc = "SPI4"]
    pub SPI4: SPI4,
    #[doc = "SPI5"]
    pub SPI5: SPI5,
    #[doc = "SPI6"]
    pub SPI6: SPI6,
    #[doc = "SPI7"]
    pub SPI7: SPI7,
    #[doc = "SPI14"]
    pub SPI14: SPI14,
    #[doc = "SPI16"]
    pub SPI16: SPI16,
    #[doc = "SPI8"]
    pub SPI8: SPI8,
    #[doc = "SPI9"]
    pub SPI9: SPI9,
    #[doc = "SPI10"]
    pub SPI10: SPI10,
    #[doc = "SPI11"]
    pub SPI11: SPI11,
    #[doc = "SPI12"]
    pub SPI12: SPI12,
    #[doc = "SPI13"]
    pub SPI13: SPI13,
    #[doc = "USART0"]
    pub USART0: USART0,
    #[doc = "USART1"]
    pub USART1: USART1,
    #[doc = "USART2"]
    pub USART2: USART2,
    #[doc = "USART3"]
    pub USART3: USART3,
    #[doc = "USART4"]
    pub USART4: USART4,
    #[doc = "USART5"]
    pub USART5: USART5,
    #[doc = "USART6"]
    pub USART6: USART6,
    #[doc = "USART7"]
    pub USART7: USART7,
    #[doc = "USART8"]
    pub USART8: USART8,
    #[doc = "USART9"]
    pub USART9: USART9,
    #[doc = "USART10"]
    pub USART10: USART10,
    #[doc = "USART11"]
    pub USART11: USART11,
    #[doc = "USART12"]
    pub USART12: USART12,
    #[doc = "USART13"]
    pub USART13: USART13,
    #[doc = "DEBUGGER_MAILBOX"]
    pub DEBUGGER_MAILBOX: DEBUGGER_MAILBOX,
    #[doc = "MUA"]
    pub MUA: MUA,
    #[doc = "SEMA42"]
    pub SEMA42: SEMA42,
    #[doc = "OSTIMER0"]
    pub OSTIMER0: OSTIMER0,
    #[doc = "CRC_ENGINE"]
    pub CRC_ENGINE: CRC_ENGINE,
    #[doc = "DMIC0"]
    pub DMIC0: DMIC0,
    #[doc = "OCOTP0"]
    pub OCOTP0: OCOTP0,
    #[doc = "FLEXSPI0"]
    pub FLEXSPI0: FLEXSPI0,
    #[doc = "OTFAD0"]
    pub OTFAD0: OTFAD0,
    #[doc = "PMC"]
    pub PMC: PMC,
    #[doc = "USDHC0"]
    pub USDHC0: USDHC0,
    #[doc = "USDHC1"]
    pub USDHC1: USDHC1,
    #[doc = "TRNG"]
    pub TRNG: TRNG,
    #[doc = "ACMP0"]
    pub ACMP0: ACMP0,
    #[doc = "ADC0"]
    pub ADC0: ADC0,
    #[doc = "USBPHY"]
    pub USBPHY: USBPHY,
    #[doc = "USBHSDCD"]
    pub USBHSDCD: USBHSDCD,
    #[doc = "FLEXSPI1"]
    pub FLEXSPI1: FLEXSPI1,
    #[doc = "USBHSD"]
    pub USBHSD: USBHSD,
    #[doc = "USBHSH"]
    pub USBHSH: USBHSH,
    #[doc = "SCT0"]
    pub SCT0: SCT0,
    #[doc = "AHB_SECURE_CTRL"]
    pub AHB_SECURE_CTRL: AHB_SECURE_CTRL,
    #[doc = "POWERQUAD"]
    pub POWERQUAD: POWERQUAD,
    #[doc = "CASPER"]
    pub CASPER: CASPER,
    #[doc = "SECGPIO"]
    pub SECGPIO: SECGPIO,
    #[doc = "HASHCRYPT"]
    pub HASHCRYPT: HASHCRYPT,
    #[doc = "LCDIF"]
    pub LCDIF: LCDIF,
    #[doc = "AXI_SWITCH_AMIB"]
    pub AXI_SWITCH_AMIB: AXI_SWITCH_AMIB,
    #[doc = "AXI_SWITCH_ASIB"]
    pub AXI_SWITCH_ASIB: AXI_SWITCH_ASIB,
    #[doc = "SCN_SCB"]
    pub SCN_SCB: SCN_SCB,
    #[doc = "SAU"]
    pub SAU: SAU,
}
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 {
            RSTCTL0: RSTCTL0 {
                _marker: PhantomData,
            },
            CLKCTL0: CLKCTL0 {
                _marker: PhantomData,
            },
            SYSCTL0: SYSCTL0 {
                _marker: PhantomData,
            },
            IOPCTL: IOPCTL {
                _marker: PhantomData,
            },
            PUF: PUF {
                _marker: PhantomData,
            },
            WWDT0: WWDT0 {
                _marker: PhantomData,
            },
            WWDT1: WWDT1 {
                _marker: PhantomData,
            },
            UTICK0: UTICK0 {
                _marker: PhantomData,
            },
            RSTCTL1: RSTCTL1 {
                _marker: PhantomData,
            },
            CLKCTL1: CLKCTL1 {
                _marker: PhantomData,
            },
            SYSCTL1: SYSCTL1 {
                _marker: PhantomData,
            },
            PINT: PINT {
                _marker: PhantomData,
            },
            INPUTMUX: INPUTMUX {
                _marker: PhantomData,
            },
            CTIMER0: CTIMER0 {
                _marker: PhantomData,
            },
            CTIMER1: CTIMER1 {
                _marker: PhantomData,
            },
            CTIMER2: CTIMER2 {
                _marker: PhantomData,
            },
            CTIMER3: CTIMER3 {
                _marker: PhantomData,
            },
            CTIMER4: CTIMER4 {
                _marker: PhantomData,
            },
            MRT0: MRT0 {
                _marker: PhantomData,
            },
            FREQME: FREQME {
                _marker: PhantomData,
            },
            RTC: RTC {
                _marker: PhantomData,
            },
            MIPI_DSI_HOST: MIPI_DSI_HOST {
                _marker: PhantomData,
            },
            FLEXIO0: FLEXIO0 {
                _marker: PhantomData,
            },
            CACHE64_CTRL0: CACHE64_CTRL0 {
                _marker: PhantomData,
            },
            CACHE64_CTRL1: CACHE64_CTRL1 {
                _marker: PhantomData,
            },
            CACHE64_POLSEL0: CACHE64_POLSEL0 {
                _marker: PhantomData,
            },
            CACHE64_POLSEL1: CACHE64_POLSEL1 {
                _marker: PhantomData,
            },
            I3C0: I3C0 {
                _marker: PhantomData,
            },
            I3C1: I3C1 {
                _marker: PhantomData,
            },
            GPIO: GPIO {
                _marker: PhantomData,
            },
            DMA0: DMA0 {
                _marker: PhantomData,
            },
            DMA1: DMA1 {
                _marker: PhantomData,
            },
            FLEXCOMM0: FLEXCOMM0 {
                _marker: PhantomData,
            },
            FLEXCOMM1: FLEXCOMM1 {
                _marker: PhantomData,
            },
            FLEXCOMM2: FLEXCOMM2 {
                _marker: PhantomData,
            },
            FLEXCOMM3: FLEXCOMM3 {
                _marker: PhantomData,
            },
            FLEXCOMM4: FLEXCOMM4 {
                _marker: PhantomData,
            },
            FLEXCOMM5: FLEXCOMM5 {
                _marker: PhantomData,
            },
            FLEXCOMM6: FLEXCOMM6 {
                _marker: PhantomData,
            },
            FLEXCOMM7: FLEXCOMM7 {
                _marker: PhantomData,
            },
            FLEXCOMM14: FLEXCOMM14 {
                _marker: PhantomData,
            },
            FLEXCOMM15: FLEXCOMM15 {
                _marker: PhantomData,
            },
            FLEXCOMM16: FLEXCOMM16 {
                _marker: PhantomData,
            },
            FLEXCOMM8: FLEXCOMM8 {
                _marker: PhantomData,
            },
            FLEXCOMM9: FLEXCOMM9 {
                _marker: PhantomData,
            },
            FLEXCOMM10: FLEXCOMM10 {
                _marker: PhantomData,
            },
            FLEXCOMM11: FLEXCOMM11 {
                _marker: PhantomData,
            },
            FLEXCOMM12: FLEXCOMM12 {
                _marker: PhantomData,
            },
            FLEXCOMM13: FLEXCOMM13 {
                _marker: PhantomData,
            },
            I2C0: I2C0 {
                _marker: PhantomData,
            },
            I2C1: I2C1 {
                _marker: PhantomData,
            },
            I2C2: I2C2 {
                _marker: PhantomData,
            },
            I2C3: I2C3 {
                _marker: PhantomData,
            },
            I2C4: I2C4 {
                _marker: PhantomData,
            },
            I2C5: I2C5 {
                _marker: PhantomData,
            },
            I2C6: I2C6 {
                _marker: PhantomData,
            },
            I2C7: I2C7 {
                _marker: PhantomData,
            },
            I2C15: I2C15 {
                _marker: PhantomData,
            },
            I2C8: I2C8 {
                _marker: PhantomData,
            },
            I2C9: I2C9 {
                _marker: PhantomData,
            },
            I2C10: I2C10 {
                _marker: PhantomData,
            },
            I2C11: I2C11 {
                _marker: PhantomData,
            },
            I2C12: I2C12 {
                _marker: PhantomData,
            },
            I2C13: I2C13 {
                _marker: PhantomData,
            },
            I2S0: I2S0 {
                _marker: PhantomData,
            },
            I2S1: I2S1 {
                _marker: PhantomData,
            },
            I2S2: I2S2 {
                _marker: PhantomData,
            },
            I2S3: I2S3 {
                _marker: PhantomData,
            },
            I2S4: I2S4 {
                _marker: PhantomData,
            },
            I2S5: I2S5 {
                _marker: PhantomData,
            },
            I2S6: I2S6 {
                _marker: PhantomData,
            },
            I2S7: I2S7 {
                _marker: PhantomData,
            },
            I2S8: I2S8 {
                _marker: PhantomData,
            },
            I2S9: I2S9 {
                _marker: PhantomData,
            },
            I2S10: I2S10 {
                _marker: PhantomData,
            },
            I2S11: I2S11 {
                _marker: PhantomData,
            },
            I2S12: I2S12 {
                _marker: PhantomData,
            },
            I2S13: I2S13 {
                _marker: PhantomData,
            },
            SPI0: SPI0 {
                _marker: PhantomData,
            },
            SPI1: SPI1 {
                _marker: PhantomData,
            },
            SPI2: SPI2 {
                _marker: PhantomData,
            },
            SPI3: SPI3 {
                _marker: PhantomData,
            },
            SPI4: SPI4 {
                _marker: PhantomData,
            },
            SPI5: SPI5 {
                _marker: PhantomData,
            },
            SPI6: SPI6 {
                _marker: PhantomData,
            },
            SPI7: SPI7 {
                _marker: PhantomData,
            },
            SPI14: SPI14 {
                _marker: PhantomData,
            },
            SPI16: SPI16 {
                _marker: PhantomData,
            },
            SPI8: SPI8 {
                _marker: PhantomData,
            },
            SPI9: SPI9 {
                _marker: PhantomData,
            },
            SPI10: SPI10 {
                _marker: PhantomData,
            },
            SPI11: SPI11 {
                _marker: PhantomData,
            },
            SPI12: SPI12 {
                _marker: PhantomData,
            },
            SPI13: SPI13 {
                _marker: PhantomData,
            },
            USART0: USART0 {
                _marker: PhantomData,
            },
            USART1: USART1 {
                _marker: PhantomData,
            },
            USART2: USART2 {
                _marker: PhantomData,
            },
            USART3: USART3 {
                _marker: PhantomData,
            },
            USART4: USART4 {
                _marker: PhantomData,
            },
            USART5: USART5 {
                _marker: PhantomData,
            },
            USART6: USART6 {
                _marker: PhantomData,
            },
            USART7: USART7 {
                _marker: PhantomData,
            },
            USART8: USART8 {
                _marker: PhantomData,
            },
            USART9: USART9 {
                _marker: PhantomData,
            },
            USART10: USART10 {
                _marker: PhantomData,
            },
            USART11: USART11 {
                _marker: PhantomData,
            },
            USART12: USART12 {
                _marker: PhantomData,
            },
            USART13: USART13 {
                _marker: PhantomData,
            },
            DEBUGGER_MAILBOX: DEBUGGER_MAILBOX {
                _marker: PhantomData,
            },
            MUA: MUA {
                _marker: PhantomData,
            },
            SEMA42: SEMA42 {
                _marker: PhantomData,
            },
            OSTIMER0: OSTIMER0 {
                _marker: PhantomData,
            },
            CRC_ENGINE: CRC_ENGINE {
                _marker: PhantomData,
            },
            DMIC0: DMIC0 {
                _marker: PhantomData,
            },
            OCOTP0: OCOTP0 {
                _marker: PhantomData,
            },
            FLEXSPI0: FLEXSPI0 {
                _marker: PhantomData,
            },
            OTFAD0: OTFAD0 {
                _marker: PhantomData,
            },
            PMC: PMC {
                _marker: PhantomData,
            },
            USDHC0: USDHC0 {
                _marker: PhantomData,
            },
            USDHC1: USDHC1 {
                _marker: PhantomData,
            },
            TRNG: TRNG {
                _marker: PhantomData,
            },
            ACMP0: ACMP0 {
                _marker: PhantomData,
            },
            ADC0: ADC0 {
                _marker: PhantomData,
            },
            USBPHY: USBPHY {
                _marker: PhantomData,
            },
            USBHSDCD: USBHSDCD {
                _marker: PhantomData,
            },
            FLEXSPI1: FLEXSPI1 {
                _marker: PhantomData,
            },
            USBHSD: USBHSD {
                _marker: PhantomData,
            },
            USBHSH: USBHSH {
                _marker: PhantomData,
            },
            SCT0: SCT0 {
                _marker: PhantomData,
            },
            AHB_SECURE_CTRL: AHB_SECURE_CTRL {
                _marker: PhantomData,
            },
            POWERQUAD: POWERQUAD {
                _marker: PhantomData,
            },
            CASPER: CASPER {
                _marker: PhantomData,
            },
            SECGPIO: SECGPIO {
                _marker: PhantomData,
            },
            HASHCRYPT: HASHCRYPT {
                _marker: PhantomData,
            },
            LCDIF: LCDIF {
                _marker: PhantomData,
            },
            AXI_SWITCH_AMIB: AXI_SWITCH_AMIB {
                _marker: PhantomData,
            },
            AXI_SWITCH_ASIB: AXI_SWITCH_ASIB {
                _marker: PhantomData,
            },
            SCN_SCB: SCN_SCB {
                _marker: PhantomData,
            },
            SAU: SAU {
                _marker: PhantomData,
            },
        }
    }
}