#![doc = "Peripheral access API for NUC1XX_REGISTERS microcontrollers (generated using svd2rust v0.17.0)\n\nYou can find an overview of the API [here].\n\n[here]: https://docs.rs/svd2rust/0.17.0/svd2rust/#peripheral-api"]
#![deny(const_err)]
#![deny(dead_code)]
#![deny(improper_ctypes)]
#![deny(missing_docs)]
#![deny(no_mangle_generic_items)]
#![deny(non_shorthand_field_patterns)]
#![deny(overflowing_literals)]
#![deny(path_statements)]
#![deny(patterns_in_fns_without_body)]
#![deny(private_in_public)]
#![deny(unconditional_recursion)]
#![deny(unused_allocation)]
#![deny(unused_comparisons)]
#![deny(unused_parens)]
#![deny(while_true)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![no_std]
extern crate bare_metal;
extern crate cortex_m;
#[cfg(feature = "rt")]
extern crate cortex_m_rt;
extern crate vcell;
use core::marker::PhantomData;
use core::ops::Deref;
#[cfg(feature = "rt")]
extern "C" {
    fn BOD_OUT();
    fn WDT_INT();
    fn EINT0();
    fn EINT1();
    fn GPAB_INT();
    fn GPCDE_INT();
    fn PWMA_INT();
    fn PWMB_INT();
    fn TMR0_INT();
    fn TMR1_INT();
    fn TMR2_INT();
    fn TMR3_INT();
    fn UART02_INT();
    fn UART1_INT();
    fn SPI0_INT();
    fn SPI1_INT();
    fn SPI2_INT();
    fn SPI3_INT();
    fn I2C0_INT();
    fn I2C1_INT();
    fn CAN0_INT();
    fn USB_INT();
    fn PS2_INT();
    fn ACMP_INT();
    fn PDMA_INT();
    fn I2S_INT();
    fn PWRWU_INT();
    fn ADC_INT();
    fn RTC_INT();
}
#[doc(hidden)]
pub union Vector {
    _handler: unsafe extern "C" fn(),
    _reserved: u32,
}
#[cfg(feature = "rt")]
#[doc(hidden)]
#[link_section = ".vector_table.interrupts"]
#[no_mangle]
pub static __INTERRUPTS: [Vector; 32] = [
    Vector { _handler: BOD_OUT },
    Vector { _handler: WDT_INT },
    Vector { _handler: EINT0 },
    Vector { _handler: EINT1 },
    Vector { _handler: GPAB_INT },
    Vector {
        _handler: GPCDE_INT,
    },
    Vector { _handler: PWMA_INT },
    Vector { _handler: PWMB_INT },
    Vector { _handler: TMR0_INT },
    Vector { _handler: TMR1_INT },
    Vector { _handler: TMR2_INT },
    Vector { _handler: TMR3_INT },
    Vector {
        _handler: UART02_INT,
    },
    Vector {
        _handler: UART1_INT,
    },
    Vector { _handler: SPI0_INT },
    Vector { _handler: SPI1_INT },
    Vector { _handler: SPI2_INT },
    Vector { _handler: SPI3_INT },
    Vector { _handler: I2C0_INT },
    Vector { _handler: I2C1_INT },
    Vector { _handler: CAN0_INT },
    Vector { _reserved: 0 },
    Vector { _reserved: 0 },
    Vector { _handler: USB_INT },
    Vector { _handler: PS2_INT },
    Vector { _handler: ACMP_INT },
    Vector { _handler: PDMA_INT },
    Vector { _handler: I2S_INT },
    Vector {
        _handler: PWRWU_INT,
    },
    Vector { _handler: ADC_INT },
    Vector { _reserved: 0 },
    Vector { _handler: RTC_INT },
];
#[doc = r"Enumeration of all the interrupts"]
#[derive(Copy, Clone, Debug)]
#[repr(u8)]
pub enum Interrupt {
    #[doc = "0 - BOD_OUT"]
    BOD_OUT = 0,
    #[doc = "1 - WDT_INT"]
    WDT_INT = 1,
    #[doc = "2 - EINT0"]
    EINT0 = 2,
    #[doc = "3 - EINT1"]
    EINT1 = 3,
    #[doc = "4 - GPAB_INT"]
    GPAB_INT = 4,
    #[doc = "5 - GPCDE_INT"]
    GPCDE_INT = 5,
    #[doc = "6 - PWMA_INT"]
    PWMA_INT = 6,
    #[doc = "7 - PWMB_INT"]
    PWMB_INT = 7,
    #[doc = "8 - TMR0_INT"]
    TMR0_INT = 8,
    #[doc = "9 - TMR1_INT"]
    TMR1_INT = 9,
    #[doc = "10 - TMR2_INT"]
    TMR2_INT = 10,
    #[doc = "11 - TMR3_INT"]
    TMR3_INT = 11,
    #[doc = "12 - UART02_INT"]
    UART02_INT = 12,
    #[doc = "13 - UART1_INT"]
    UART1_INT = 13,
    #[doc = "14 - SPI0_INT"]
    SPI0_INT = 14,
    #[doc = "15 - SPI1_INT"]
    SPI1_INT = 15,
    #[doc = "16 - SPI2_INT"]
    SPI2_INT = 16,
    #[doc = "17 - SPI3_INT"]
    SPI3_INT = 17,
    #[doc = "18 - I2C0_INT"]
    I2C0_INT = 18,
    #[doc = "19 - I2C1_INT"]
    I2C1_INT = 19,
    #[doc = "20 - CAN0_INT"]
    CAN0_INT = 20,
    #[doc = "23 - USB_INT"]
    USB_INT = 23,
    #[doc = "24 - PS2_INT"]
    PS2_INT = 24,
    #[doc = "25 - ACMP_INT"]
    ACMP_INT = 25,
    #[doc = "26 - PDMA_INT"]
    PDMA_INT = 26,
    #[doc = "27 - I2S_INT"]
    I2S_INT = 27,
    #[doc = "28 - PWRWU_INT"]
    PWRWU_INT = 28,
    #[doc = "29 - ADC_INT"]
    ADC_INT = 29,
    #[doc = "31 - RTC_INT"]
    RTC_INT = 31,
}
unsafe impl bare_metal::Nr for Interrupt {
    #[inline(always)]
    fn nr(&self) -> u8 {
        *self as u8
    }
}
#[cfg(feature = "rt")]
pub use self::Interrupt as interrupt;
pub use cortex_m::peripheral::Peripherals as CorePeripherals;
pub use cortex_m::peripheral::{CBP, CPUID, DCB, DWT, FPB, FPU, ITM, MPU, NVIC, SCB, SYST, TPIU};
#[cfg(feature = "rt")]
pub use cortex_m_rt::interrupt;
#[allow(unused_imports)]
use generic::*;
#[doc = r"Common register and bit access and modify traits"]
pub mod generic;
#[doc = "Registers group"]
pub struct PWMA {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for PWMA {}
impl PWMA {
    #[doc = r"Returns a pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const pwma::RegisterBlock {
        0x4004_0000 as *const _
    }
}
impl Deref for PWMA {
    type Target = pwma::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*PWMA::ptr() }
    }
}
#[doc = "Registers group"]
pub mod pwma;
#[doc = "Registers group"]
pub struct PWMB {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for PWMB {}
impl PWMB {
    #[doc = r"Returns a pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const pwma::RegisterBlock {
        0x4014_0000 as *const _
    }
}
impl Deref for PWMB {
    type Target = pwma::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*PWMB::ptr() }
    }
}
#[doc = "Registers group"]
pub struct ADC {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for ADC {}
impl ADC {
    #[doc = r"Returns a pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const adc::RegisterBlock {
        0x400e_0000 as *const _
    }
}
impl Deref for ADC {
    type Target = adc::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*ADC::ptr() }
    }
}
#[doc = "Registers group"]
pub mod adc;
#[doc = "Registers group"]
pub struct CAN {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for CAN {}
impl CAN {
    #[doc = r"Returns a pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const can::RegisterBlock {
        0x4018_0000 as *const _
    }
}
impl Deref for CAN {
    type Target = can::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*CAN::ptr() }
    }
}
#[doc = "Registers group"]
pub mod can;
#[doc = "Registers group"]
pub struct CLK {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for CLK {}
impl CLK {
    #[doc = r"Returns a pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const clk::RegisterBlock {
        0x5000_0200 as *const _
    }
}
impl Deref for CLK {
    type Target = clk::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*CLK::ptr() }
    }
}
#[doc = "Registers group"]
pub mod clk;
#[doc = "Registers group"]
pub struct CMP {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for CMP {}
impl CMP {
    #[doc = r"Returns a pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const cmp::RegisterBlock {
        0x400d_0000 as *const _
    }
}
impl Deref for CMP {
    type Target = cmp::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*CMP::ptr() }
    }
}
#[doc = "Registers group"]
pub mod cmp;
#[doc = "Registers group"]
pub struct EBI {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for EBI {}
impl EBI {
    #[doc = r"Returns a pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const ebi::RegisterBlock {
        0x5001_0000 as *const _
    }
}
impl Deref for EBI {
    type Target = ebi::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*EBI::ptr() }
    }
}
#[doc = "Registers group"]
pub mod ebi;
#[doc = "Registers group"]
pub struct FMC {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for FMC {}
impl FMC {
    #[doc = r"Returns a pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const fmc::RegisterBlock {
        0x5000_c000 as *const _
    }
}
impl Deref for FMC {
    type Target = fmc::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*FMC::ptr() }
    }
}
#[doc = "Registers group"]
pub mod fmc;
#[doc = "Registers group"]
pub struct GCR {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for GCR {}
impl GCR {
    #[doc = r"Returns a pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const gcr::RegisterBlock {
        0x5000_0000 as *const _
    }
}
impl Deref for GCR {
    type Target = gcr::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*GCR::ptr() }
    }
}
#[doc = "Registers group"]
pub mod gcr;
#[doc = "Registers group"]
pub struct GPA {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for GPA {}
impl GPA {
    #[doc = r"Returns a pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const gpa::RegisterBlock {
        0x5000_4000 as *const _
    }
}
impl Deref for GPA {
    type Target = gpa::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*GPA::ptr() }
    }
}
#[doc = "Registers group"]
pub mod gpa;
#[doc = "Registers group"]
pub struct GPB {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for GPB {}
impl GPB {
    #[doc = r"Returns a pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const gpa::RegisterBlock {
        0x5000_4040 as *const _
    }
}
impl Deref for GPB {
    type Target = gpa::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*GPB::ptr() }
    }
}
#[doc = "Registers group"]
pub struct GPC {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for GPC {}
impl GPC {
    #[doc = r"Returns a pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const gpa::RegisterBlock {
        0x5000_4080 as *const _
    }
}
impl Deref for GPC {
    type Target = gpa::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*GPC::ptr() }
    }
}
#[doc = "Registers group"]
pub struct GPD {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for GPD {}
impl GPD {
    #[doc = r"Returns a pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const gpa::RegisterBlock {
        0x5000_40c0 as *const _
    }
}
impl Deref for GPD {
    type Target = gpa::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*GPD::ptr() }
    }
}
#[doc = "Registers group"]
pub struct GPE {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for GPE {}
impl GPE {
    #[doc = r"Returns a pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const gpa::RegisterBlock {
        0x5000_4100 as *const _
    }
}
impl Deref for GPE {
    type Target = gpa::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*GPE::ptr() }
    }
}
#[doc = "Registers group"]
pub struct GPIO {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for GPIO {}
impl GPIO {
    #[doc = r"Returns a pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const gpio::RegisterBlock {
        0x5000_4180 as *const _
    }
}
impl Deref for GPIO {
    type Target = gpio::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*GPIO::ptr() }
    }
}
#[doc = "Registers group"]
pub mod gpio;
#[doc = "Registers group"]
pub struct GPA_BITS {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for GPA_BITS {}
impl GPA_BITS {
    #[doc = r"Returns a pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const gpa_bits::RegisterBlock {
        0x5000_4200 as *const _
    }
}
impl Deref for GPA_BITS {
    type Target = gpa_bits::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*GPA_BITS::ptr() }
    }
}
#[doc = "Registers group"]
pub mod gpa_bits;
#[doc = "Registers group"]
pub struct GPB_BITS {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for GPB_BITS {}
impl GPB_BITS {
    #[doc = r"Returns a pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const gpa_bits::RegisterBlock {
        0x5000_4240 as *const _
    }
}
impl Deref for GPB_BITS {
    type Target = gpa_bits::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*GPB_BITS::ptr() }
    }
}
#[doc = "Registers group"]
pub struct GPC_BITS {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for GPC_BITS {}
impl GPC_BITS {
    #[doc = r"Returns a pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const gpa_bits::RegisterBlock {
        0x5000_4280 as *const _
    }
}
impl Deref for GPC_BITS {
    type Target = gpa_bits::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*GPC_BITS::ptr() }
    }
}
#[doc = "Registers group"]
pub struct GPD_BITS {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for GPD_BITS {}
impl GPD_BITS {
    #[doc = r"Returns a pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const gpa_bits::RegisterBlock {
        0x5000_42c0 as *const _
    }
}
impl Deref for GPD_BITS {
    type Target = gpa_bits::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*GPD_BITS::ptr() }
    }
}
#[doc = "Registers group"]
pub struct GPE_BITS {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for GPE_BITS {}
impl GPE_BITS {
    #[doc = r"Returns a pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const gpa_bits::RegisterBlock {
        0x5000_4300 as *const _
    }
}
impl Deref for GPE_BITS {
    type Target = gpa_bits::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*GPE_BITS::ptr() }
    }
}
#[doc = "Registers group"]
pub struct I2C0 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for I2C0 {}
impl I2C0 {
    #[doc = r"Returns a pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const i2c0::RegisterBlock {
        0x4002_0000 as *const _
    }
}
impl Deref for I2C0 {
    type Target = i2c0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*I2C0::ptr() }
    }
}
#[doc = "Registers group"]
pub mod i2c0;
#[doc = "Registers group"]
pub struct I2C1 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for I2C1 {}
impl I2C1 {
    #[doc = r"Returns a pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const i2c0::RegisterBlock {
        0x4012_0000 as *const _
    }
}
impl Deref for I2C1 {
    type Target = i2c0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*I2C1::ptr() }
    }
}
#[doc = "Registers group"]
pub struct I2S {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for I2S {}
impl I2S {
    #[doc = r"Returns a pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const i2s::RegisterBlock {
        0x401a_0000 as *const _
    }
}
impl Deref for I2S {
    type Target = i2s::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*I2S::ptr() }
    }
}
#[doc = "Registers group"]
pub mod i2s;
#[doc = "Registers group"]
pub struct INT {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for INT {}
impl INT {
    #[doc = r"Returns a pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const int::RegisterBlock {
        0x5000_0300 as *const _
    }
}
impl Deref for INT {
    type Target = int::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*INT::ptr() }
    }
}
#[doc = "Registers group"]
pub mod int;
#[doc = "Registers group"]
pub struct PDMA0 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for PDMA0 {}
impl PDMA0 {
    #[doc = r"Returns a pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const pdma0::RegisterBlock {
        0x5000_8000 as *const _
    }
}
impl Deref for PDMA0 {
    type Target = pdma0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*PDMA0::ptr() }
    }
}
#[doc = "Registers group"]
pub mod pdma0;
#[doc = "Registers group"]
pub struct PDMA1 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for PDMA1 {}
impl PDMA1 {
    #[doc = r"Returns a pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const pdma0::RegisterBlock {
        0x5000_8100 as *const _
    }
}
impl Deref for PDMA1 {
    type Target = pdma0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*PDMA1::ptr() }
    }
}
#[doc = "Registers group"]
pub struct PDMA2 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for PDMA2 {}
impl PDMA2 {
    #[doc = r"Returns a pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const pdma0::RegisterBlock {
        0x5000_8200 as *const _
    }
}
impl Deref for PDMA2 {
    type Target = pdma0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*PDMA2::ptr() }
    }
}
#[doc = "Registers group"]
pub struct PDMA3 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for PDMA3 {}
impl PDMA3 {
    #[doc = r"Returns a pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const pdma0::RegisterBlock {
        0x5000_8300 as *const _
    }
}
impl Deref for PDMA3 {
    type Target = pdma0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*PDMA3::ptr() }
    }
}
#[doc = "Registers group"]
pub struct PDMA4 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for PDMA4 {}
impl PDMA4 {
    #[doc = r"Returns a pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const pdma0::RegisterBlock {
        0x5000_8400 as *const _
    }
}
impl Deref for PDMA4 {
    type Target = pdma0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*PDMA4::ptr() }
    }
}
#[doc = "Registers group"]
pub struct PDMA5 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for PDMA5 {}
impl PDMA5 {
    #[doc = r"Returns a pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const pdma0::RegisterBlock {
        0x5000_8500 as *const _
    }
}
impl Deref for PDMA5 {
    type Target = pdma0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*PDMA5::ptr() }
    }
}
#[doc = "Registers group"]
pub struct PDMA6 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for PDMA6 {}
impl PDMA6 {
    #[doc = r"Returns a pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const pdma0::RegisterBlock {
        0x5000_8600 as *const _
    }
}
impl Deref for PDMA6 {
    type Target = pdma0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*PDMA6::ptr() }
    }
}
#[doc = "Registers group"]
pub struct PDMA7 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for PDMA7 {}
impl PDMA7 {
    #[doc = r"Returns a pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const pdma0::RegisterBlock {
        0x5000_8700 as *const _
    }
}
impl Deref for PDMA7 {
    type Target = pdma0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*PDMA7::ptr() }
    }
}
#[doc = "Registers group"]
pub struct PDMA8 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for PDMA8 {}
impl PDMA8 {
    #[doc = r"Returns a pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const pdma0::RegisterBlock {
        0x5000_8800 as *const _
    }
}
impl Deref for PDMA8 {
    type Target = pdma0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*PDMA8::ptr() }
    }
}
#[doc = "Registers group"]
pub struct PDMA_GCR {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for PDMA_GCR {}
impl PDMA_GCR {
    #[doc = r"Returns a pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const pdma_gcr::RegisterBlock {
        0x5000_8f00 as *const _
    }
}
impl Deref for PDMA_GCR {
    type Target = pdma_gcr::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*PDMA_GCR::ptr() }
    }
}
#[doc = "Registers group"]
pub mod pdma_gcr;
#[doc = "Registers group"]
pub struct PS2 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for PS2 {}
impl PS2 {
    #[doc = r"Returns a pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const ps2::RegisterBlock {
        0x4010_0000 as *const _
    }
}
impl Deref for PS2 {
    type Target = ps2::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*PS2::ptr() }
    }
}
#[doc = "Registers group"]
pub mod ps2;
#[doc = "Registers group"]
pub struct RTC {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for RTC {}
impl RTC {
    #[doc = r"Returns a pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const rtc::RegisterBlock {
        0x4000_8000 as *const _
    }
}
impl Deref for RTC {
    type Target = rtc::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*RTC::ptr() }
    }
}
#[doc = "Registers group"]
pub mod rtc;
#[doc = "Registers group"]
pub struct SCS {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for SCS {}
impl SCS {
    #[doc = r"Returns a pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const scs::RegisterBlock {
        0xe000_e000 as *const _
    }
}
impl Deref for SCS {
    type Target = scs::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*SCS::ptr() }
    }
}
#[doc = "Registers group"]
pub mod scs;
#[doc = "Registers group"]
pub struct SPI0 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for SPI0 {}
impl SPI0 {
    #[doc = r"Returns a pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const spi0::RegisterBlock {
        0x4003_0000 as *const _
    }
}
impl Deref for SPI0 {
    type Target = spi0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*SPI0::ptr() }
    }
}
#[doc = "Registers group"]
pub mod spi0;
#[doc = "Registers group"]
pub struct SPI1 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for SPI1 {}
impl SPI1 {
    #[doc = r"Returns a pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const spi0::RegisterBlock {
        0x4003_4000 as *const _
    }
}
impl Deref for SPI1 {
    type Target = spi0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*SPI1::ptr() }
    }
}
#[doc = "Registers group"]
pub struct SPI2 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for SPI2 {}
impl SPI2 {
    #[doc = r"Returns a pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const spi0::RegisterBlock {
        0x4013_0000 as *const _
    }
}
impl Deref for SPI2 {
    type Target = spi0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*SPI2::ptr() }
    }
}
#[doc = "Registers group"]
pub struct SPI3 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for SPI3 {}
impl SPI3 {
    #[doc = r"Returns a pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const spi0::RegisterBlock {
        0x4013_4000 as *const _
    }
}
impl Deref for SPI3 {
    type Target = spi0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*SPI3::ptr() }
    }
}
#[doc = "Registers group"]
pub struct TMR0 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for TMR0 {}
impl TMR0 {
    #[doc = r"Returns a pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const tmr0::RegisterBlock {
        0x4001_0000 as *const _
    }
}
impl Deref for TMR0 {
    type Target = tmr0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*TMR0::ptr() }
    }
}
#[doc = "Registers group"]
pub mod tmr0;
#[doc = "Registers group"]
pub struct TMR1 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for TMR1 {}
impl TMR1 {
    #[doc = r"Returns a pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const tmr0::RegisterBlock {
        0x4001_0020 as *const _
    }
}
impl Deref for TMR1 {
    type Target = tmr0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*TMR1::ptr() }
    }
}
#[doc = "Registers group"]
pub struct TMR2 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for TMR2 {}
impl TMR2 {
    #[doc = r"Returns a pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const tmr0::RegisterBlock {
        0x4011_0000 as *const _
    }
}
impl Deref for TMR2 {
    type Target = tmr0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*TMR2::ptr() }
    }
}
#[doc = "Registers group"]
pub struct TMR3 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for TMR3 {}
impl TMR3 {
    #[doc = r"Returns a pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const tmr0::RegisterBlock {
        0x4011_0020 as *const _
    }
}
impl Deref for TMR3 {
    type Target = tmr0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*TMR3::ptr() }
    }
}
#[doc = "Registers group"]
pub struct UART0 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for UART0 {}
impl UART0 {
    #[doc = r"Returns a pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const uart0::RegisterBlock {
        0x4005_0000 as *const _
    }
}
impl Deref for UART0 {
    type Target = uart0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*UART0::ptr() }
    }
}
#[doc = "Registers group"]
pub mod uart0;
#[doc = "Registers group"]
pub struct UART1 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for UART1 {}
impl UART1 {
    #[doc = r"Returns a pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const uart0::RegisterBlock {
        0x4015_0000 as *const _
    }
}
impl Deref for UART1 {
    type Target = uart0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*UART1::ptr() }
    }
}
#[doc = "Registers group"]
pub struct UART2 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for UART2 {}
impl UART2 {
    #[doc = r"Returns a pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const uart0::RegisterBlock {
        0x4015_4000 as *const _
    }
}
impl Deref for UART2 {
    type Target = uart0::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*UART2::ptr() }
    }
}
#[doc = "Registers group"]
pub struct USB {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for USB {}
impl USB {
    #[doc = r"Returns a pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const usb::RegisterBlock {
        0x4006_0000 as *const _
    }
}
impl Deref for USB {
    type Target = usb::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*USB::ptr() }
    }
}
#[doc = "Registers group"]
pub mod usb;
#[doc = "Registers group"]
pub struct WDT {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for WDT {}
impl WDT {
    #[doc = r"Returns a pointer to the register block"]
    #[inline(always)]
    pub const fn ptr() -> *const wdt::RegisterBlock {
        0x4000_4000 as *const _
    }
}
impl Deref for WDT {
    type Target = wdt::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*WDT::ptr() }
    }
}
#[doc = "Registers group"]
pub mod wdt;
#[no_mangle]
static mut DEVICE_PERIPHERALS: bool = false;
#[doc = r"All the peripherals"]
#[allow(non_snake_case)]
pub struct Peripherals {
    #[doc = "PWMA"]
    pub PWMA: PWMA,
    #[doc = "PWMB"]
    pub PWMB: PWMB,
    #[doc = "ADC"]
    pub ADC: ADC,
    #[doc = "CAN"]
    pub CAN: CAN,
    #[doc = "CLK"]
    pub CLK: CLK,
    #[doc = "CMP"]
    pub CMP: CMP,
    #[doc = "EBI"]
    pub EBI: EBI,
    #[doc = "FMC"]
    pub FMC: FMC,
    #[doc = "GCR"]
    pub GCR: GCR,
    #[doc = "GPA"]
    pub GPA: GPA,
    #[doc = "GPB"]
    pub GPB: GPB,
    #[doc = "GPC"]
    pub GPC: GPC,
    #[doc = "GPD"]
    pub GPD: GPD,
    #[doc = "GPE"]
    pub GPE: GPE,
    #[doc = "GPIO"]
    pub GPIO: GPIO,
    #[doc = "GPA_BITS"]
    pub GPA_BITS: GPA_BITS,
    #[doc = "GPB_BITS"]
    pub GPB_BITS: GPB_BITS,
    #[doc = "GPC_BITS"]
    pub GPC_BITS: GPC_BITS,
    #[doc = "GPD_BITS"]
    pub GPD_BITS: GPD_BITS,
    #[doc = "GPE_BITS"]
    pub GPE_BITS: GPE_BITS,
    #[doc = "I2C0"]
    pub I2C0: I2C0,
    #[doc = "I2C1"]
    pub I2C1: I2C1,
    #[doc = "I2S"]
    pub I2S: I2S,
    #[doc = "INT"]
    pub INT: INT,
    #[doc = "PDMA0"]
    pub PDMA0: PDMA0,
    #[doc = "PDMA1"]
    pub PDMA1: PDMA1,
    #[doc = "PDMA2"]
    pub PDMA2: PDMA2,
    #[doc = "PDMA3"]
    pub PDMA3: PDMA3,
    #[doc = "PDMA4"]
    pub PDMA4: PDMA4,
    #[doc = "PDMA5"]
    pub PDMA5: PDMA5,
    #[doc = "PDMA6"]
    pub PDMA6: PDMA6,
    #[doc = "PDMA7"]
    pub PDMA7: PDMA7,
    #[doc = "PDMA8"]
    pub PDMA8: PDMA8,
    #[doc = "PDMA_GCR"]
    pub PDMA_GCR: PDMA_GCR,
    #[doc = "PS2"]
    pub PS2: PS2,
    #[doc = "RTC"]
    pub RTC: RTC,
    #[doc = "SCS"]
    pub SCS: SCS,
    #[doc = "SPI0"]
    pub SPI0: SPI0,
    #[doc = "SPI1"]
    pub SPI1: SPI1,
    #[doc = "SPI2"]
    pub SPI2: SPI2,
    #[doc = "SPI3"]
    pub SPI3: SPI3,
    #[doc = "TMR0"]
    pub TMR0: TMR0,
    #[doc = "TMR1"]
    pub TMR1: TMR1,
    #[doc = "TMR2"]
    pub TMR2: TMR2,
    #[doc = "TMR3"]
    pub TMR3: TMR3,
    #[doc = "UART0"]
    pub UART0: UART0,
    #[doc = "UART1"]
    pub UART1: UART1,
    #[doc = "UART2"]
    pub UART2: UART2,
    #[doc = "USB"]
    pub USB: USB,
    #[doc = "WDT"]
    pub WDT: WDT,
}
impl Peripherals {
    #[doc = r"Returns all the peripherals *once*"]
    #[inline]
    pub fn take() -> Option<Self> {
        cortex_m::interrupt::free(|_| {
            if unsafe { DEVICE_PERIPHERALS } {
                None
            } else {
                Some(unsafe { Peripherals::steal() })
            }
        })
    }
    #[doc = r"Unchecked version of `Peripherals::take`"]
    #[inline]
    pub unsafe fn steal() -> Self {
        DEVICE_PERIPHERALS = true;
        Peripherals {
            PWMA: PWMA {
                _marker: PhantomData,
            },
            PWMB: PWMB {
                _marker: PhantomData,
            },
            ADC: ADC {
                _marker: PhantomData,
            },
            CAN: CAN {
                _marker: PhantomData,
            },
            CLK: CLK {
                _marker: PhantomData,
            },
            CMP: CMP {
                _marker: PhantomData,
            },
            EBI: EBI {
                _marker: PhantomData,
            },
            FMC: FMC {
                _marker: PhantomData,
            },
            GCR: GCR {
                _marker: PhantomData,
            },
            GPA: GPA {
                _marker: PhantomData,
            },
            GPB: GPB {
                _marker: PhantomData,
            },
            GPC: GPC {
                _marker: PhantomData,
            },
            GPD: GPD {
                _marker: PhantomData,
            },
            GPE: GPE {
                _marker: PhantomData,
            },
            GPIO: GPIO {
                _marker: PhantomData,
            },
            GPA_BITS: GPA_BITS {
                _marker: PhantomData,
            },
            GPB_BITS: GPB_BITS {
                _marker: PhantomData,
            },
            GPC_BITS: GPC_BITS {
                _marker: PhantomData,
            },
            GPD_BITS: GPD_BITS {
                _marker: PhantomData,
            },
            GPE_BITS: GPE_BITS {
                _marker: PhantomData,
            },
            I2C0: I2C0 {
                _marker: PhantomData,
            },
            I2C1: I2C1 {
                _marker: PhantomData,
            },
            I2S: I2S {
                _marker: PhantomData,
            },
            INT: INT {
                _marker: PhantomData,
            },
            PDMA0: PDMA0 {
                _marker: PhantomData,
            },
            PDMA1: PDMA1 {
                _marker: PhantomData,
            },
            PDMA2: PDMA2 {
                _marker: PhantomData,
            },
            PDMA3: PDMA3 {
                _marker: PhantomData,
            },
            PDMA4: PDMA4 {
                _marker: PhantomData,
            },
            PDMA5: PDMA5 {
                _marker: PhantomData,
            },
            PDMA6: PDMA6 {
                _marker: PhantomData,
            },
            PDMA7: PDMA7 {
                _marker: PhantomData,
            },
            PDMA8: PDMA8 {
                _marker: PhantomData,
            },
            PDMA_GCR: PDMA_GCR {
                _marker: PhantomData,
            },
            PS2: PS2 {
                _marker: PhantomData,
            },
            RTC: RTC {
                _marker: PhantomData,
            },
            SCS: SCS {
                _marker: PhantomData,
            },
            SPI0: SPI0 {
                _marker: PhantomData,
            },
            SPI1: SPI1 {
                _marker: PhantomData,
            },
            SPI2: SPI2 {
                _marker: PhantomData,
            },
            SPI3: SPI3 {
                _marker: PhantomData,
            },
            TMR0: TMR0 {
                _marker: PhantomData,
            },
            TMR1: TMR1 {
                _marker: PhantomData,
            },
            TMR2: TMR2 {
                _marker: PhantomData,
            },
            TMR3: TMR3 {
                _marker: PhantomData,
            },
            UART0: UART0 {
                _marker: PhantomData,
            },
            UART1: UART1 {
                _marker: PhantomData,
            },
            UART2: UART2 {
                _marker: PhantomData,
            },
            USB: USB {
                _marker: PhantomData,
            },
            WDT: WDT {
                _marker: PhantomData,
            },
        }
    }
}