#![doc = "Peripheral access API for SSE300 microcontrollers (generated using svd2rust v0.26.0 ( ))\n\nYou can find an overview of the generated API [here].\n\nAPI features to be included in the [next]
// Copyright 2022 Arm Limited and/or its affiliates <open-source-office@arm.com>
//
// SPDX-License-Identifier: MIT
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.26.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(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]
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 NONSEC_WATCHDOG_RST_REQ();
fn NONSEC_WATCHDOG_IRQ();
fn S32K_TIMER();
fn TIMER0();
fn TIMER1();
fn DUALTIMER();
fn MPC();
fn PPC();
fn MSC();
fn BRG();
fn MGMT_PPU();
fn SYS_PPU();
fn CPU0_PPU();
fn PPU_DEBUG();
fn TIMER3();
fn SYSTEM_TIMESTAMP_COUNTER();
fn UART0_RX();
fn UART0_TX();
fn UART1_RX();
fn UART1_TX();
fn UART2_RX();
fn UART2_TX();
fn UART3_RX();
fn UART3_TX();
fn UART4_RX();
fn UART4_TX();
fn UART0_COMBINED();
fn UART1_COMBINED();
fn UART2_COMBINED();
fn UART3_COMBINED();
fn UART4_COMBINED();
fn UART_OVERFLOW();
fn ETHERNET();
fn AUDIO_I2S();
fn TOUCH_SCREEN();
fn USB();
fn SPI2();
fn SPI0();
fn SPI1();
fn GPIO0_COMBINED();
fn GPIO1_COMBINED();
fn GPIO2_COMBINED();
fn GPIO3_COMBINED();
fn UART5_RX();
fn UART5_TX();
fn UART5_COMBINED();
}
#[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; 128] = [
Vector {
_handler: NONSEC_WATCHDOG_RST_REQ,
},
Vector {
_handler: NONSEC_WATCHDOG_IRQ,
},
Vector {
_handler: S32K_TIMER,
},
Vector { _handler: TIMER0 },
Vector { _handler: TIMER1 },
Vector {
_handler: DUALTIMER,
},
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _handler: MPC },
Vector { _handler: PPC },
Vector { _handler: MSC },
Vector { _handler: BRG },
Vector { _reserved: 0 },
Vector { _handler: MGMT_PPU },
Vector { _handler: SYS_PPU },
Vector { _handler: CPU0_PPU },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector {
_handler: PPU_DEBUG,
},
Vector { _handler: TIMER3 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector {
_handler: SYSTEM_TIMESTAMP_COUNTER,
},
Vector { _handler: UART0_RX },
Vector { _handler: UART0_TX },
Vector { _handler: UART1_RX },
Vector { _handler: UART1_TX },
Vector { _handler: UART2_RX },
Vector { _handler: UART2_TX },
Vector { _handler: UART3_RX },
Vector { _handler: UART3_TX },
Vector { _handler: UART4_RX },
Vector { _handler: UART4_TX },
Vector {
_handler: UART0_COMBINED,
},
Vector {
_handler: UART1_COMBINED,
},
Vector {
_handler: UART2_COMBINED,
},
Vector {
_handler: UART3_COMBINED,
},
Vector {
_handler: UART4_COMBINED,
},
Vector {
_handler: UART_OVERFLOW,
},
Vector { _handler: ETHERNET },
Vector {
_handler: AUDIO_I2S,
},
Vector {
_handler: TOUCH_SCREEN,
},
Vector { _handler: USB },
Vector { _handler: SPI2 },
Vector { _handler: SPI0 },
Vector { _handler: SPI1 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector {
_handler: GPIO0_COMBINED,
},
Vector {
_handler: GPIO1_COMBINED,
},
Vector {
_handler: GPIO2_COMBINED,
},
Vector {
_handler: GPIO3_COMBINED,
},
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _handler: UART5_RX },
Vector { _handler: UART5_TX },
Vector {
_handler: UART5_COMBINED,
},
];
#[doc = r"Enumeration of all the interrupts."]
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
#[repr(u16)]
pub enum Interrupt {
#[doc = "0 - Non-Secure Watchdog reset Request"]
NONSEC_WATCHDOG_RST_REQ = 0,
#[doc = "1 - Non-Secure Watchdog Interrupt"]
NONSEC_WATCHDOG_IRQ = 1,
#[doc = "2 - S32K Timer"]
S32K_TIMER = 2,
#[doc = "3 - Timer 0"]
TIMER0 = 3,
#[doc = "4 - Timer 1"]
TIMER1 = 4,
#[doc = "5 - Timer 2"]
DUALTIMER = 5,
#[doc = "9 - MPC Combined"]
MPC = 9,
#[doc = "10 - PPC Combined"]
PPC = 10,
#[doc = "11 - MSC Combined"]
MSC = 11,
#[doc = "12 - Bridge Buffer Error"]
BRG = 12,
#[doc = "14 - MGMT_PPU"]
MGMT_PPU = 14,
#[doc = "15 - SYS_PPU"]
SYS_PPU = 15,
#[doc = "16 - CPU0_PPU"]
CPU0_PPU = 16,
#[doc = "26 - PPU_DEBUG"]
PPU_DEBUG = 26,
#[doc = "27 - Timer 3"]
TIMER3 = 27,
#[doc = "32 - System_Timestamp_Counter"]
SYSTEM_TIMESTAMP_COUNTER = 32,
#[doc = "33 - UART 0 RX"]
UART0_RX = 33,
#[doc = "34 - UART 0 TX"]
UART0_TX = 34,
#[doc = "35 - UART 1 RX"]
UART1_RX = 35,
#[doc = "36 - UART 1 TX"]
UART1_TX = 36,
#[doc = "37 - UART 2 RX"]
UART2_RX = 37,
#[doc = "38 - UART 2 TX"]
UART2_TX = 38,
#[doc = "39 - UART 3 RX"]
UART3_RX = 39,
#[doc = "40 - UART 3 TX"]
UART3_TX = 40,
#[doc = "41 - UART 4 RX"]
UART4_RX = 41,
#[doc = "42 - UART 4 TX"]
UART4_TX = 42,
#[doc = "43 - UART 0 Combined interrupt"]
UART0_COMBINED = 43,
#[doc = "44 - UART 1 Combined interrupt"]
UART1_COMBINED = 44,
#[doc = "45 - UART 2 Combined interrupt"]
UART2_COMBINED = 45,
#[doc = "46 - UART 3 Combined interrupt"]
UART3_COMBINED = 46,
#[doc = "47 - UART 4 Combined interrupt"]
UART4_COMBINED = 47,
#[doc = "48 - UART 0 to 5 combined overflow/overrun"]
UART_OVERFLOW = 48,
#[doc = "49 - Ethernet"]
ETHERNET = 49,
#[doc = "50 - AudioI2S"]
AUDIO_I2S = 50,
#[doc = "51 - TouchScreen"]
TOUCH_SCREEN = 51,
#[doc = "52 - USB"]
USB = 52,
#[doc = "53 - SPI 2"]
SPI2 = 53,
#[doc = "54 - SPI 0"]
SPI0 = 54,
#[doc = "55 - SPI 1"]
SPI1 = 55,
#[doc = "69 - GPIO 0 combined"]
GPIO0_COMBINED = 69,
#[doc = "70 - GPIO 1 combined"]
GPIO1_COMBINED = 70,
#[doc = "71 - GPIO 2 combined"]
GPIO2_COMBINED = 71,
#[doc = "72 - GPIO 3 combined"]
GPIO3_COMBINED = 72,
#[doc = "125 - UART 5 RX"]
UART5_RX = 125,
#[doc = "126 - UART 5 TX"]
UART5_TX = 126,
#[doc = "127 - UART 5 Combined interrupt"]
UART5_COMBINED = 127,
}
unsafe impl cortex_m::interrupt::InterruptNumber for Interrupt {
#[inline(always)]
fn number(self) -> u16 {
self as u16
}
}
#[doc = "System counter control"]
pub struct SYSCOUNTER_CNTRL {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SYSCOUNTER_CNTRL {}
impl SYSCOUNTER_CNTRL {
#[doc = r"Pointer to the register block"]
pub const PTR: *const syscounter_cntrl::RegisterBlock = 0x5810_0000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const syscounter_cntrl::RegisterBlock {
Self::PTR
}
}
impl Deref for SYSCOUNTER_CNTRL {
type Target = syscounter_cntrl::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for SYSCOUNTER_CNTRL {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("SYSCOUNTER_CNTRL").finish()
}
}
#[doc = "System counter control"]
pub mod syscounter_cntrl;
#[doc = "System counter read"]
pub struct SYSCOUNTER_READ {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SYSCOUNTER_READ {}
impl SYSCOUNTER_READ {
#[doc = r"Pointer to the register block"]
pub const PTR: *const syscounter_read::RegisterBlock = 0x4810_1000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const syscounter_read::RegisterBlock {
Self::PTR
}
}
impl Deref for SYSCOUNTER_READ {
type Target = syscounter_read::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for SYSCOUNTER_READ {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("SYSCOUNTER_READ").finish()
}
}
#[doc = "System counter read"]
pub mod syscounter_read;
#[doc = "System Counter Read (Secure)"]
pub struct SYSCOUNTER_READ_SECURE {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SYSCOUNTER_READ_SECURE {}
impl SYSCOUNTER_READ_SECURE {
#[doc = r"Pointer to the register block"]
pub const PTR: *const syscounter_read::RegisterBlock = 0x5810_1000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const syscounter_read::RegisterBlock {
Self::PTR
}
}
impl Deref for SYSCOUNTER_READ_SECURE {
type Target = syscounter_read::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for SYSCOUNTER_READ_SECURE {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("SYSCOUNTER_READ_SECURE").finish()
}
}
#[doc = "System Counter Read (Secure)"]
pub use self::syscounter_read as syscounter_read_secure;
#[doc = "System Information"]
pub struct SYSINFO {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SYSINFO {}
impl SYSINFO {
#[doc = r"Pointer to the register block"]
pub const PTR: *const sysinfo::RegisterBlock = 0x4802_0000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const sysinfo::RegisterBlock {
Self::PTR
}
}
impl Deref for SYSINFO {
type Target = sysinfo::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for SYSINFO {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("SYSINFO").finish()
}
}
#[doc = "System Information"]
pub mod sysinfo;
#[doc = "System Information (Secure)"]
pub struct SYSINFO_SECURE {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SYSINFO_SECURE {}
impl SYSINFO_SECURE {
#[doc = r"Pointer to the register block"]
pub const PTR: *const sysinfo::RegisterBlock = 0x5802_0000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const sysinfo::RegisterBlock {
Self::PTR
}
}
impl Deref for SYSINFO_SECURE {
type Target = sysinfo::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for SYSINFO_SECURE {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("SYSINFO_SECURE").finish()
}
}
#[doc = "System Information (Secure)"]
pub use self::sysinfo as sysinfo_secure;
#[doc = "System Control"]
pub struct SYSCONTROL {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SYSCONTROL {}
impl SYSCONTROL {
#[doc = r"Pointer to the register block"]
pub const PTR: *const syscontrol::RegisterBlock = 0x5802_1000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const syscontrol::RegisterBlock {
Self::PTR
}
}
impl Deref for SYSCONTROL {
type Target = syscontrol::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for SYSCONTROL {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("SYSCONTROL").finish()
}
}
#[doc = "System Control"]
pub mod syscontrol;
#[doc = "Security Attribution Unit"]
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 = "Security Attribution Unit"]
pub mod sau;
#[doc = "Timer 0"]
pub struct TIMER0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for TIMER0 {}
impl TIMER0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const timer0::RegisterBlock = 0x4800_0000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const timer0::RegisterBlock {
Self::PTR
}
}
impl Deref for TIMER0 {
type Target = timer0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for TIMER0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("TIMER0").finish()
}
}
#[doc = "Timer 0"]
pub mod timer0;
#[doc = "Timer 1"]
pub struct TIMER1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for TIMER1 {}
impl TIMER1 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const timer0::RegisterBlock = 0x4800_1000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const timer0::RegisterBlock {
Self::PTR
}
}
impl Deref for TIMER1 {
type Target = timer0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for TIMER1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("TIMER1").finish()
}
}
#[doc = "Timer 1"]
pub use self::timer0 as timer1;
#[doc = "Timer 2"]
pub struct TIMER2 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for TIMER2 {}
impl TIMER2 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const timer0::RegisterBlock = 0x4800_2000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const timer0::RegisterBlock {
Self::PTR
}
}
impl Deref for TIMER2 {
type Target = timer0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for TIMER2 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("TIMER2").finish()
}
}
#[doc = "Timer 2"]
pub use self::timer0 as timer2;
#[doc = "AON Timer 3"]
pub struct TIMER3 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for TIMER3 {}
impl TIMER3 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const timer0::RegisterBlock = 0x4800_3000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const timer0::RegisterBlock {
Self::PTR
}
}
impl Deref for TIMER3 {
type Target = timer0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for TIMER3 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("TIMER3").finish()
}
}
#[doc = "AON Timer 3"]
pub use self::timer0 as timer3;
#[doc = "SLOWCLK AON Timer"]
pub struct SLOWCLK {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SLOWCLK {}
impl SLOWCLK {
#[doc = r"Pointer to the register block"]
pub const PTR: *const slowclk::RegisterBlock = 0x4802_f000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const slowclk::RegisterBlock {
Self::PTR
}
}
impl Deref for SLOWCLK {
type Target = slowclk::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for SLOWCLK {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("SLOWCLK").finish()
}
}
#[doc = "SLOWCLK AON Timer"]
pub mod slowclk;
#[doc = "Timer 0 (Secure)"]
pub struct TIMER0_SECURE {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for TIMER0_SECURE {}
impl TIMER0_SECURE {
#[doc = r"Pointer to the register block"]
pub const PTR: *const timer0::RegisterBlock = 0x5800_0000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const timer0::RegisterBlock {
Self::PTR
}
}
impl Deref for TIMER0_SECURE {
type Target = timer0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for TIMER0_SECURE {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("TIMER0_SECURE").finish()
}
}
#[doc = "Timer 0 (Secure)"]
pub use self::timer0 as timer0_secure;
#[doc = "Timer 1 (Secure)"]
pub struct TIMER1_SECURE {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for TIMER1_SECURE {}
impl TIMER1_SECURE {
#[doc = r"Pointer to the register block"]
pub const PTR: *const timer0::RegisterBlock = 0x5800_1000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const timer0::RegisterBlock {
Self::PTR
}
}
impl Deref for TIMER1_SECURE {
type Target = timer0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for TIMER1_SECURE {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("TIMER1_SECURE").finish()
}
}
#[doc = "Timer 1 (Secure)"]
pub use self::timer0 as timer1_secure;
#[doc = "Timer 2 (Secure)"]
pub struct TIMER2_SECURE {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for TIMER2_SECURE {}
impl TIMER2_SECURE {
#[doc = r"Pointer to the register block"]
pub const PTR: *const timer0::RegisterBlock = 0x5800_2000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const timer0::RegisterBlock {
Self::PTR
}
}
impl Deref for TIMER2_SECURE {
type Target = timer0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for TIMER2_SECURE {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("TIMER2_SECURE").finish()
}
}
#[doc = "Timer 2 (Secure)"]
pub use self::timer0 as timer2_secure;
#[doc = "Timer 3 (Secure)"]
pub struct TIMER3_SECURE {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for TIMER3_SECURE {}
impl TIMER3_SECURE {
#[doc = r"Pointer to the register block"]
pub const PTR: *const timer0::RegisterBlock = 0x5800_3000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const timer0::RegisterBlock {
Self::PTR
}
}
impl Deref for TIMER3_SECURE {
type Target = timer0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for TIMER3_SECURE {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("TIMER3_SECURE").finish()
}
}
#[doc = "Timer 3 (Secure)"]
pub use self::timer0 as timer3_secure;
#[doc = "SLOWCLK AON Timer (Secure)"]
pub struct SLOWCLK_SECURE {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SLOWCLK_SECURE {}
impl SLOWCLK_SECURE {
#[doc = r"Pointer to the register block"]
pub const PTR: *const slowclk::RegisterBlock = 0x5802_f000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const slowclk::RegisterBlock {
Self::PTR
}
}
impl Deref for SLOWCLK_SECURE {
type Target = slowclk::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for SLOWCLK_SECURE {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("SLOWCLK_SECURE").finish()
}
}
#[doc = "SLOWCLK AON Timer (Secure)"]
pub use self::slowclk as slowclk_secure;
#[doc = "General-purpose I/O 0"]
pub struct GPIO0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for GPIO0 {}
impl GPIO0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const gpio0::RegisterBlock = 0x4110_0000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const gpio0::RegisterBlock {
Self::PTR
}
}
impl Deref for GPIO0 {
type Target = gpio0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for GPIO0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("GPIO0").finish()
}
}
#[doc = "General-purpose I/O 0"]
pub mod gpio0;
#[doc = "General-purpose I/O 1"]
pub struct GPIO1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for GPIO1 {}
impl GPIO1 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const gpio0::RegisterBlock = 0x4110_1000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const gpio0::RegisterBlock {
Self::PTR
}
}
impl Deref for GPIO1 {
type Target = gpio0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for GPIO1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("GPIO1").finish()
}
}
#[doc = "General-purpose I/O 1"]
pub use self::gpio0 as gpio1;
#[doc = "General-purpose I/O 2"]
pub struct GPIO2 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for GPIO2 {}
impl GPIO2 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const gpio0::RegisterBlock = 0x4110_2000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const gpio0::RegisterBlock {
Self::PTR
}
}
impl Deref for GPIO2 {
type Target = gpio0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for GPIO2 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("GPIO2").finish()
}
}
#[doc = "General-purpose I/O 2"]
pub use self::gpio0 as gpio2;
#[doc = "General-purpose I/O 3"]
pub struct GPIO3 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for GPIO3 {}
impl GPIO3 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const gpio0::RegisterBlock = 0x4110_3000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const gpio0::RegisterBlock {
Self::PTR
}
}
impl Deref for GPIO3 {
type Target = gpio0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for GPIO3 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("GPIO3").finish()
}
}
#[doc = "General-purpose I/O 3"]
pub use self::gpio0 as gpio3;
#[doc = "General-purpose I/O 0 (Secure)"]
pub struct GPIO0_SECURE {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for GPIO0_SECURE {}
impl GPIO0_SECURE {
#[doc = r"Pointer to the register block"]
pub const PTR: *const gpio0::RegisterBlock = 0x5010_0000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const gpio0::RegisterBlock {
Self::PTR
}
}
impl Deref for GPIO0_SECURE {
type Target = gpio0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for GPIO0_SECURE {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("GPIO0_SECURE").finish()
}
}
#[doc = "General-purpose I/O 0 (Secure)"]
pub use self::gpio0 as gpio0_secure;
#[doc = "General-purpose I/O 1 (Secure)"]
pub struct GPIO1_SECURE {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for GPIO1_SECURE {}
impl GPIO1_SECURE {
#[doc = r"Pointer to the register block"]
pub const PTR: *const gpio0::RegisterBlock = 0x5010_1000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const gpio0::RegisterBlock {
Self::PTR
}
}
impl Deref for GPIO1_SECURE {
type Target = gpio0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for GPIO1_SECURE {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("GPIO1_SECURE").finish()
}
}
#[doc = "General-purpose I/O 1 (Secure)"]
pub use self::gpio0 as gpio1_secure;
#[doc = "General-purpose I/O 2 (Secure)"]
pub struct GPIO2_SECURE {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for GPIO2_SECURE {}
impl GPIO2_SECURE {
#[doc = r"Pointer to the register block"]
pub const PTR: *const gpio0::RegisterBlock = 0x5010_2000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const gpio0::RegisterBlock {
Self::PTR
}
}
impl Deref for GPIO2_SECURE {
type Target = gpio0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for GPIO2_SECURE {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("GPIO2_SECURE").finish()
}
}
#[doc = "General-purpose I/O 2 (Secure)"]
pub use self::gpio0 as gpio2_secure;
#[doc = "General-purpose I/O 3 (Secure)"]
pub struct GPIO3_SECURE {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for GPIO3_SECURE {}
impl GPIO3_SECURE {
#[doc = r"Pointer to the register block"]
pub const PTR: *const gpio0::RegisterBlock = 0x5010_3000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const gpio0::RegisterBlock {
Self::PTR
}
}
impl Deref for GPIO3_SECURE {
type Target = gpio0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for GPIO3_SECURE {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("GPIO3_SECURE").finish()
}
}
#[doc = "General-purpose I/O 3 (Secure)"]
pub use self::gpio0 as gpio3_secure;
#[doc = "Direct Memory Access 0 (PL081)"]
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 = 0x4120_0000 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 = "Direct Memory Access 0 (PL081)"]
pub mod dma0;
#[doc = "Direct Memory Access 1"]
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 = 0x4110_1000 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 = "Direct Memory Access 1"]
pub use self::dma0 as dma1;
#[doc = "Direct Memory Access 2"]
pub struct DMA2 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for DMA2 {}
impl DMA2 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const dma0::RegisterBlock = 0x4120_2000 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 DMA2 {
type Target = dma0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for DMA2 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("DMA2").finish()
}
}
#[doc = "Direct Memory Access 2"]
pub use self::dma0 as dma2;
#[doc = "Direct Memory Access 3"]
pub struct DMA3 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for DMA3 {}
impl DMA3 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const dma0::RegisterBlock = 0x4120_3000 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 DMA3 {
type Target = dma0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for DMA3 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("DMA3").finish()
}
}
#[doc = "Direct Memory Access 3"]
pub use self::dma0 as dma3;
#[doc = "Direct Memory Access 0 (Secure)"]
pub struct DMA0_SECURE {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for DMA0_SECURE {}
impl DMA0_SECURE {
#[doc = r"Pointer to the register block"]
pub const PTR: *const dma0::RegisterBlock = 0x5120_0000 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_SECURE {
type Target = dma0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for DMA0_SECURE {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("DMA0_SECURE").finish()
}
}
#[doc = "Direct Memory Access 0 (Secure)"]
pub use self::dma0 as dma0_secure;
#[doc = "Direct Memory Access 1 (Secure)"]
pub struct DMA1_SECURE {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for DMA1_SECURE {}
impl DMA1_SECURE {
#[doc = r"Pointer to the register block"]
pub const PTR: *const dma0::RegisterBlock = 0x5120_1000 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_SECURE {
type Target = dma0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for DMA1_SECURE {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("DMA1_SECURE").finish()
}
}
#[doc = "Direct Memory Access 1 (Secure)"]
pub use self::dma0 as dma1_secure;
#[doc = "Direct Memory Access 2 (Secure)"]
pub struct DMA2_SECURE {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for DMA2_SECURE {}
impl DMA2_SECURE {
#[doc = r"Pointer to the register block"]
pub const PTR: *const dma0::RegisterBlock = 0x5120_2000 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 DMA2_SECURE {
type Target = dma0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for DMA2_SECURE {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("DMA2_SECURE").finish()
}
}
#[doc = "Direct Memory Access 2 (Secure)"]
pub use self::dma0 as dma2_secure;
#[doc = "Direct Memory Access 3 (Secure)"]
pub struct DMA3_SECURE {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for DMA3_SECURE {}
impl DMA3_SECURE {
#[doc = r"Pointer to the register block"]
pub const PTR: *const dma0::RegisterBlock = 0x5120_3000 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 DMA3_SECURE {
type Target = dma0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for DMA3_SECURE {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("DMA3_SECURE").finish()
}
}
#[doc = "Direct Memory Access 3 (Secure)"]
pub use self::dma0 as dma3_secure;
#[doc = "UART 0"]
pub struct UART0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for UART0 {}
impl UART0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const uart0::RegisterBlock = 0x4930_3000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const uart0::RegisterBlock {
Self::PTR
}
}
impl Deref for UART0 {
type Target = uart0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for UART0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("UART0").finish()
}
}
#[doc = "UART 0"]
pub mod uart0;
#[doc = "UART 1"]
pub struct UART1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for UART1 {}
impl UART1 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const uart0::RegisterBlock = 0x4930_4000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const uart0::RegisterBlock {
Self::PTR
}
}
impl Deref for UART1 {
type Target = uart0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for UART1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("UART1").finish()
}
}
#[doc = "UART 1"]
pub use self::uart0 as uart1;
#[doc = "UART 2"]
pub struct UART2 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for UART2 {}
impl UART2 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const uart0::RegisterBlock = 0x4930_5000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const uart0::RegisterBlock {
Self::PTR
}
}
impl Deref for UART2 {
type Target = uart0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for UART2 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("UART2").finish()
}
}
#[doc = "UART 2"]
pub use self::uart0 as uart2;
#[doc = "UART 3"]
pub struct UART3 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for UART3 {}
impl UART3 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const uart0::RegisterBlock = 0x4930_6000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const uart0::RegisterBlock {
Self::PTR
}
}
impl Deref for UART3 {
type Target = uart0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for UART3 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("UART3").finish()
}
}
#[doc = "UART 3"]
pub use self::uart0 as uart3;
#[doc = "UART 4"]
pub struct UART4 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for UART4 {}
impl UART4 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const uart0::RegisterBlock = 0x4930_7000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const uart0::RegisterBlock {
Self::PTR
}
}
impl Deref for UART4 {
type Target = uart0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for UART4 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("UART4").finish()
}
}
#[doc = "UART 4"]
pub use self::uart0 as uart4;
#[doc = "UART 5"]
pub struct UART5 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for UART5 {}
impl UART5 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const uart0::RegisterBlock = 0x4930_8000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const uart0::RegisterBlock {
Self::PTR
}
}
impl Deref for UART5 {
type Target = uart0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for UART5 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("UART5").finish()
}
}
#[doc = "UART 5"]
pub use self::uart0 as uart5;
#[doc = "UART 0 (Secure)"]
pub struct UART0_SECURE {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for UART0_SECURE {}
impl UART0_SECURE {
#[doc = r"Pointer to the register block"]
pub const PTR: *const uart0::RegisterBlock = 0x5930_3000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const uart0::RegisterBlock {
Self::PTR
}
}
impl Deref for UART0_SECURE {
type Target = uart0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for UART0_SECURE {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("UART0_SECURE").finish()
}
}
#[doc = "UART 0 (Secure)"]
pub use self::uart0 as uart0_secure;
#[doc = "UART 1 (Secure)"]
pub struct UART1_SECURE {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for UART1_SECURE {}
impl UART1_SECURE {
#[doc = r"Pointer to the register block"]
pub const PTR: *const uart0::RegisterBlock = 0x5930_4000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const uart0::RegisterBlock {
Self::PTR
}
}
impl Deref for UART1_SECURE {
type Target = uart0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for UART1_SECURE {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("UART1_SECURE").finish()
}
}
#[doc = "UART 1 (Secure)"]
pub use self::uart0 as uart1_secure;
#[doc = "UART 2 (Secure)"]
pub struct UART2_SECURE {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for UART2_SECURE {}
impl UART2_SECURE {
#[doc = r"Pointer to the register block"]
pub const PTR: *const uart0::RegisterBlock = 0x5930_5000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const uart0::RegisterBlock {
Self::PTR
}
}
impl Deref for UART2_SECURE {
type Target = uart0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for UART2_SECURE {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("UART2_SECURE").finish()
}
}
#[doc = "UART 2 (Secure)"]
pub use self::uart0 as uart2_secure;
#[doc = "UART 3 (Secure)"]
pub struct UART3_SECURE {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for UART3_SECURE {}
impl UART3_SECURE {
#[doc = r"Pointer to the register block"]
pub const PTR: *const uart0::RegisterBlock = 0x5930_6000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const uart0::RegisterBlock {
Self::PTR
}
}
impl Deref for UART3_SECURE {
type Target = uart0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for UART3_SECURE {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("UART3_SECURE").finish()
}
}
#[doc = "UART 3 (Secure)"]
pub use self::uart0 as uart3_secure;
#[doc = "UART 4 (Secure)"]
pub struct UART4_SECURE {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for UART4_SECURE {}
impl UART4_SECURE {
#[doc = r"Pointer to the register block"]
pub const PTR: *const uart0::RegisterBlock = 0x5930_7000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const uart0::RegisterBlock {
Self::PTR
}
}
impl Deref for UART4_SECURE {
type Target = uart0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for UART4_SECURE {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("UART4_SECURE").finish()
}
}
#[doc = "UART 4 (Secure)"]
pub use self::uart0 as uart4_secure;
#[doc = "UART 5 (Secure)"]
pub struct UART5_SECURE {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for UART5_SECURE {}
impl UART5_SECURE {
#[doc = r"Pointer to the register block"]
pub const PTR: *const uart0::RegisterBlock = 0x5930_8000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const uart0::RegisterBlock {
Self::PTR
}
}
impl Deref for UART5_SECURE {
type Target = uart0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for UART5_SECURE {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("UART5_SECURE").finish()
}
}
#[doc = "UART 5 (Secure)"]
pub use self::uart0 as uart5_secure;
#[doc = "I2C Touch"]
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 = 0x4920_0000 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 Touch"]
pub mod i2c0;
#[doc = "I2C Audio"]
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 = 0x4920_1000 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 Audio"]
pub use self::i2c0 as i2c1;
#[doc = "I2C Touch (Secure)"]
pub struct I2C0_SECURE {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for I2C0_SECURE {}
impl I2C0_SECURE {
#[doc = r"Pointer to the register block"]
pub const PTR: *const i2c0::RegisterBlock = 0x5920_0000 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_SECURE {
type Target = i2c0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for I2C0_SECURE {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("I2C0_SECURE").finish()
}
}
#[doc = "I2C Touch (Secure)"]
pub use self::i2c0 as i2c0_secure;
#[doc = "I2C Audio (Secure)"]
pub struct I2C1_SECURE {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for I2C1_SECURE {}
impl I2C1_SECURE {
#[doc = r"Pointer to the register block"]
pub const PTR: *const i2c0::RegisterBlock = 0x5920_1000 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_SECURE {
type Target = i2c0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for I2C1_SECURE {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("I2C1_SECURE").finish()
}
}
#[doc = "I2C Audio (Secure)"]
pub use self::i2c0 as i2c1_secure;
#[doc = "SPI 0"]
pub struct SSP0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SSP0 {}
impl SSP0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const ssp0::RegisterBlock = 0x4920_3000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const ssp0::RegisterBlock {
Self::PTR
}
}
impl Deref for SSP0 {
type Target = ssp0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for SSP0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("SSP0").finish()
}
}
#[doc = "SPI 0"]
pub mod ssp0;
#[doc = "SPI 1"]
pub struct SSP1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SSP1 {}
impl SSP1 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const ssp0::RegisterBlock = 0x4920_4000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const ssp0::RegisterBlock {
Self::PTR
}
}
impl Deref for SSP1 {
type Target = ssp0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for SSP1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("SSP1").finish()
}
}
#[doc = "SPI 1"]
pub use self::ssp0 as ssp1;
#[doc = "SPI 2"]
pub struct SSP2 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SSP2 {}
impl SSP2 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const ssp0::RegisterBlock = 0x4920_2000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const ssp0::RegisterBlock {
Self::PTR
}
}
impl Deref for SSP2 {
type Target = ssp0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for SSP2 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("SSP2").finish()
}
}
#[doc = "SPI 2"]
pub use self::ssp0 as ssp2;
#[doc = "SPI 0 (Secure)"]
pub struct SSP0_SECURE {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SSP0_SECURE {}
impl SSP0_SECURE {
#[doc = r"Pointer to the register block"]
pub const PTR: *const ssp0::RegisterBlock = 0x5920_3000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const ssp0::RegisterBlock {
Self::PTR
}
}
impl Deref for SSP0_SECURE {
type Target = ssp0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for SSP0_SECURE {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("SSP0_SECURE").finish()
}
}
#[doc = "SPI 0 (Secure)"]
pub use self::ssp0 as ssp0_secure;
#[doc = "SPI 1 (Secure)"]
pub struct SSP1_SECURE {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SSP1_SECURE {}
impl SSP1_SECURE {
#[doc = r"Pointer to the register block"]
pub const PTR: *const ssp0::RegisterBlock = 0x5920_4000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const ssp0::RegisterBlock {
Self::PTR
}
}
impl Deref for SSP1_SECURE {
type Target = ssp0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for SSP1_SECURE {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("SSP1_SECURE").finish()
}
}
#[doc = "SPI 1 (Secure)"]
pub use self::ssp0 as ssp1_secure;
#[doc = "SPI 2 (Secure)"]
pub struct SSP2_SECURE {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SSP2_SECURE {}
impl SSP2_SECURE {
#[doc = r"Pointer to the register block"]
pub const PTR: *const ssp0::RegisterBlock = 0x5920_2000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const ssp0::RegisterBlock {
Self::PTR
}
}
impl Deref for SSP2_SECURE {
type Target = ssp0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for SSP2_SECURE {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("SSP2_SECURE").finish()
}
}
#[doc = "SPI 2 (Secure)"]
pub use self::ssp0 as ssp2_secure;
#[doc = "Non-secure Watchdog Timer"]
pub struct WATCHDOG {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for WATCHDOG {}
impl WATCHDOG {
#[doc = r"Pointer to the register block"]
pub const PTR: *const watchdog::RegisterBlock = 0x4804_0000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const watchdog::RegisterBlock {
Self::PTR
}
}
impl Deref for WATCHDOG {
type Target = watchdog::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for WATCHDOG {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("WATCHDOG").finish()
}
}
#[doc = "Non-secure Watchdog Timer"]
pub mod watchdog;
#[doc = "Watchdog (Secure)"]
pub struct WATCHDOG_SECURE {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for WATCHDOG_SECURE {}
impl WATCHDOG_SECURE {
#[doc = r"Pointer to the register block"]
pub const PTR: *const watchdog::RegisterBlock = 0x5804_0000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const watchdog::RegisterBlock {
Self::PTR
}
}
impl Deref for WATCHDOG_SECURE {
type Target = watchdog::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for WATCHDOG_SECURE {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("WATCHDOG_SECURE").finish()
}
}
#[doc = "Watchdog (Secure)"]
pub use self::watchdog as watchdog_secure;
#[doc = "SLOWCLK Watchdog (Secure)"]
pub struct SLOWCLKWATCHDOG {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SLOWCLKWATCHDOG {}
impl SLOWCLKWATCHDOG {
#[doc = r"Pointer to the register block"]
pub const PTR: *const slowclk::RegisterBlock = 0x5802_e000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const slowclk::RegisterBlock {
Self::PTR
}
}
impl Deref for SLOWCLKWATCHDOG {
type Target = slowclk::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for SLOWCLKWATCHDOG {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("SLOWCLKWATCHDOG").finish()
}
}
#[doc = "SLOWCLK Watchdog (Secure)"]
pub use self::slowclk as slowclkwatchdog;
#[doc = "FPGA System Control I/O"]
pub struct FPGAIO {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for FPGAIO {}
impl FPGAIO {
#[doc = r"Pointer to the register block"]
pub const PTR: *const fpgaio::RegisterBlock = 0x4930_2000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const fpgaio::RegisterBlock {
Self::PTR
}
}
impl Deref for FPGAIO {
type Target = fpgaio::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for FPGAIO {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("FPGAIO").finish()
}
}
#[doc = "FPGA System Control I/O"]
pub mod fpgaio;
#[doc = "FPGA System Control I/O (Secure)"]
pub struct FPGAIO_SECURE {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for FPGAIO_SECURE {}
impl FPGAIO_SECURE {
#[doc = r"Pointer to the register block"]
pub const PTR: *const fpgaio::RegisterBlock = 0x5930_2000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const fpgaio::RegisterBlock {
Self::PTR
}
}
impl Deref for FPGAIO_SECURE {
type Target = fpgaio::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for FPGAIO_SECURE {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("FPGAIO_SECURE").finish()
}
}
#[doc = "FPGA System Control I/O (Secure)"]
pub use self::fpgaio as fpgaio_secure;
#[doc = "Serial Communication Controller"]
pub struct SCC {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SCC {}
impl SCC {
#[doc = r"Pointer to the register block"]
pub const PTR: *const scc::RegisterBlock = 0x4930_0000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const scc::RegisterBlock {
Self::PTR
}
}
impl Deref for SCC {
type Target = scc::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for SCC {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("SCC").finish()
}
}
#[doc = "Serial Communication Controller"]
pub mod scc;
#[doc = "Serial Communication Controller"]
pub struct SCC_SECURE {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SCC_SECURE {}
impl SCC_SECURE {
#[doc = r"Pointer to the register block"]
pub const PTR: *const scc::RegisterBlock = 0x5930_0000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const scc::RegisterBlock {
Self::PTR
}
}
impl Deref for SCC_SECURE {
type Target = scc::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for SCC_SECURE {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("SCC_SECURE").finish()
}
}
#[doc = "Serial Communication Controller"]
pub use self::scc as scc_secure;
#[doc = "Secure Access Configuration Register Block"]
pub struct SACRB {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SACRB {}
impl SACRB {
#[doc = r"Pointer to the register block"]
pub const PTR: *const sacrb::RegisterBlock = 0x5008_0000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const sacrb::RegisterBlock {
Self::PTR
}
}
impl Deref for SACRB {
type Target = sacrb::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for SACRB {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("SACRB").finish()
}
}
#[doc = "Secure Access Configuration Register Block"]
pub mod sacrb;
#[doc = "Non-secure Access Configuration Register Block"]
pub struct NSACRB {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for NSACRB {}
impl NSACRB {
#[doc = r"Pointer to the register block"]
pub const PTR: *const nsacrb::RegisterBlock = 0x4008_0000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const nsacrb::RegisterBlock {
Self::PTR
}
}
impl Deref for NSACRB {
type Target = nsacrb::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for NSACRB {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("NSACRB").finish()
}
}
#[doc = "Non-secure Access Configuration Register Block"]
pub mod nsacrb;
#[doc = "ISRAM 0 Memory Protection Controller"]
pub struct ISRAM0MPC {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for ISRAM0MPC {}
impl ISRAM0MPC {
#[doc = r"Pointer to the register block"]
pub const PTR: *const isram0mpc::RegisterBlock = 0x5008_3000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const isram0mpc::RegisterBlock {
Self::PTR
}
}
impl Deref for ISRAM0MPC {
type Target = isram0mpc::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for ISRAM0MPC {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("ISRAM0MPC").finish()
}
}
#[doc = "ISRAM 0 Memory Protection Controller"]
pub mod isram0mpc;
#[doc = "ISRAM 1 Memory Protection Controller"]
pub struct ISRAM1MPC {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for ISRAM1MPC {}
impl ISRAM1MPC {
#[doc = r"Pointer to the register block"]
pub const PTR: *const isram0mpc::RegisterBlock = 0x5008_4000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const isram0mpc::RegisterBlock {
Self::PTR
}
}
impl Deref for ISRAM1MPC {
type Target = isram0mpc::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for ISRAM1MPC {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("ISRAM1MPC").finish()
}
}
#[doc = "ISRAM 1 Memory Protection Controller"]
pub use self::isram0mpc as isram1mpc;
#[doc = "SMSC LAN9220"]
pub struct ETHERNET {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for ETHERNET {}
impl ETHERNET {
#[doc = r"Pointer to the register block"]
pub const PTR: *const ethernet::RegisterBlock = 0x4140_0000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const ethernet::RegisterBlock {
Self::PTR
}
}
impl Deref for ETHERNET {
type Target = ethernet::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for ETHERNET {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("ETHERNET").finish()
}
}
#[doc = "SMSC LAN9220"]
pub mod ethernet;
#[doc = "AudioI2S"]
pub struct AUDIO_I2S {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for AUDIO_I2S {}
impl AUDIO_I2S {
#[doc = r"Pointer to the register block"]
pub const PTR: *const audio_i2s::RegisterBlock = 0x4930_1000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const audio_i2s::RegisterBlock {
Self::PTR
}
}
impl Deref for AUDIO_I2S {
type Target = audio_i2s::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for AUDIO_I2S {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("AUDIO_I2S").finish()
}
}
#[doc = "AudioI2S"]
pub mod audio_i2s;
#[no_mangle]
static mut DEVICE_PERIPHERALS: bool = false;
#[doc = r" All the peripherals."]
#[allow(non_snake_case)]
pub struct Peripherals {
#[doc = "SYSCOUNTER_CNTRL"]
pub SYSCOUNTER_CNTRL: SYSCOUNTER_CNTRL,
#[doc = "SYSCOUNTER_READ"]
pub SYSCOUNTER_READ: SYSCOUNTER_READ,
#[doc = "SYSCOUNTER_READ_SECURE"]
pub SYSCOUNTER_READ_SECURE: SYSCOUNTER_READ_SECURE,
#[doc = "SYSINFO"]
pub SYSINFO: SYSINFO,
#[doc = "SYSINFO_SECURE"]
pub SYSINFO_SECURE: SYSINFO_SECURE,
#[doc = "SYSCONTROL"]
pub SYSCONTROL: SYSCONTROL,
#[doc = "SAU"]
pub SAU: SAU,
#[doc = "TIMER0"]
pub TIMER0: TIMER0,
#[doc = "TIMER1"]
pub TIMER1: TIMER1,
#[doc = "TIMER2"]
pub TIMER2: TIMER2,
#[doc = "TIMER3"]
pub TIMER3: TIMER3,
#[doc = "SLOWCLK"]
pub SLOWCLK: SLOWCLK,
#[doc = "TIMER0_SECURE"]
pub TIMER0_SECURE: TIMER0_SECURE,
#[doc = "TIMER1_SECURE"]
pub TIMER1_SECURE: TIMER1_SECURE,
#[doc = "TIMER2_SECURE"]
pub TIMER2_SECURE: TIMER2_SECURE,
#[doc = "TIMER3_SECURE"]
pub TIMER3_SECURE: TIMER3_SECURE,
#[doc = "SLOWCLK_SECURE"]
pub SLOWCLK_SECURE: SLOWCLK_SECURE,
#[doc = "GPIO0"]
pub GPIO0: GPIO0,
#[doc = "GPIO1"]
pub GPIO1: GPIO1,
#[doc = "GPIO2"]
pub GPIO2: GPIO2,
#[doc = "GPIO3"]
pub GPIO3: GPIO3,
#[doc = "GPIO0_SECURE"]
pub GPIO0_SECURE: GPIO0_SECURE,
#[doc = "GPIO1_SECURE"]
pub GPIO1_SECURE: GPIO1_SECURE,
#[doc = "GPIO2_SECURE"]
pub GPIO2_SECURE: GPIO2_SECURE,
#[doc = "GPIO3_SECURE"]
pub GPIO3_SECURE: GPIO3_SECURE,
#[doc = "DMA0"]
pub DMA0: DMA0,
#[doc = "DMA1"]
pub DMA1: DMA1,
#[doc = "DMA2"]
pub DMA2: DMA2,
#[doc = "DMA3"]
pub DMA3: DMA3,
#[doc = "DMA0_SECURE"]
pub DMA0_SECURE: DMA0_SECURE,
#[doc = "DMA1_SECURE"]
pub DMA1_SECURE: DMA1_SECURE,
#[doc = "DMA2_SECURE"]
pub DMA2_SECURE: DMA2_SECURE,
#[doc = "DMA3_SECURE"]
pub DMA3_SECURE: DMA3_SECURE,
#[doc = "UART0"]
pub UART0: UART0,
#[doc = "UART1"]
pub UART1: UART1,
#[doc = "UART2"]
pub UART2: UART2,
#[doc = "UART3"]
pub UART3: UART3,
#[doc = "UART4"]
pub UART4: UART4,
#[doc = "UART5"]
pub UART5: UART5,
#[doc = "UART0_SECURE"]
pub UART0_SECURE: UART0_SECURE,
#[doc = "UART1_SECURE"]
pub UART1_SECURE: UART1_SECURE,
#[doc = "UART2_SECURE"]
pub UART2_SECURE: UART2_SECURE,
#[doc = "UART3_SECURE"]
pub UART3_SECURE: UART3_SECURE,
#[doc = "UART4_SECURE"]
pub UART4_SECURE: UART4_SECURE,
#[doc = "UART5_SECURE"]
pub UART5_SECURE: UART5_SECURE,
#[doc = "I2C0"]
pub I2C0: I2C0,
#[doc = "I2C1"]
pub I2C1: I2C1,
#[doc = "I2C0_SECURE"]
pub I2C0_SECURE: I2C0_SECURE,
#[doc = "I2C1_SECURE"]
pub I2C1_SECURE: I2C1_SECURE,
#[doc = "SSP0"]
pub SSP0: SSP0,
#[doc = "SSP1"]
pub SSP1: SSP1,
#[doc = "SSP2"]
pub SSP2: SSP2,
#[doc = "SSP0_SECURE"]
pub SSP0_SECURE: SSP0_SECURE,
#[doc = "SSP1_SECURE"]
pub SSP1_SECURE: SSP1_SECURE,
#[doc = "SSP2_SECURE"]
pub SSP2_SECURE: SSP2_SECURE,
#[doc = "WATCHDOG"]
pub WATCHDOG: WATCHDOG,
#[doc = "WATCHDOG_SECURE"]
pub WATCHDOG_SECURE: WATCHDOG_SECURE,
#[doc = "SLOWCLKWATCHDOG"]
pub SLOWCLKWATCHDOG: SLOWCLKWATCHDOG,
#[doc = "FPGAIO"]
pub FPGAIO: FPGAIO,
#[doc = "FPGAIO_SECURE"]
pub FPGAIO_SECURE: FPGAIO_SECURE,
#[doc = "SCC"]
pub SCC: SCC,
#[doc = "SCC_SECURE"]
pub SCC_SECURE: SCC_SECURE,
#[doc = "SACRB"]
pub SACRB: SACRB,
#[doc = "NSACRB"]
pub NSACRB: NSACRB,
#[doc = "ISRAM0MPC"]
pub ISRAM0MPC: ISRAM0MPC,
#[doc = "ISRAM1MPC"]
pub ISRAM1MPC: ISRAM1MPC,
#[doc = "ETHERNET"]
pub ETHERNET: ETHERNET,
#[doc = "AUDIO_I2S"]
pub AUDIO_I2S: AUDIO_I2S,
}
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 {
SYSCOUNTER_CNTRL: SYSCOUNTER_CNTRL {
_marker: PhantomData,
},
SYSCOUNTER_READ: SYSCOUNTER_READ {
_marker: PhantomData,
},
SYSCOUNTER_READ_SECURE: SYSCOUNTER_READ_SECURE {
_marker: PhantomData,
},
SYSINFO: SYSINFO {
_marker: PhantomData,
},
SYSINFO_SECURE: SYSINFO_SECURE {
_marker: PhantomData,
},
SYSCONTROL: SYSCONTROL {
_marker: PhantomData,
},
SAU: SAU {
_marker: PhantomData,
},
TIMER0: TIMER0 {
_marker: PhantomData,
},
TIMER1: TIMER1 {
_marker: PhantomData,
},
TIMER2: TIMER2 {
_marker: PhantomData,
},
TIMER3: TIMER3 {
_marker: PhantomData,
},
SLOWCLK: SLOWCLK {
_marker: PhantomData,
},
TIMER0_SECURE: TIMER0_SECURE {
_marker: PhantomData,
},
TIMER1_SECURE: TIMER1_SECURE {
_marker: PhantomData,
},
TIMER2_SECURE: TIMER2_SECURE {
_marker: PhantomData,
},
TIMER3_SECURE: TIMER3_SECURE {
_marker: PhantomData,
},
SLOWCLK_SECURE: SLOWCLK_SECURE {
_marker: PhantomData,
},
GPIO0: GPIO0 {
_marker: PhantomData,
},
GPIO1: GPIO1 {
_marker: PhantomData,
},
GPIO2: GPIO2 {
_marker: PhantomData,
},
GPIO3: GPIO3 {
_marker: PhantomData,
},
GPIO0_SECURE: GPIO0_SECURE {
_marker: PhantomData,
},
GPIO1_SECURE: GPIO1_SECURE {
_marker: PhantomData,
},
GPIO2_SECURE: GPIO2_SECURE {
_marker: PhantomData,
},
GPIO3_SECURE: GPIO3_SECURE {
_marker: PhantomData,
},
DMA0: DMA0 {
_marker: PhantomData,
},
DMA1: DMA1 {
_marker: PhantomData,
},
DMA2: DMA2 {
_marker: PhantomData,
},
DMA3: DMA3 {
_marker: PhantomData,
},
DMA0_SECURE: DMA0_SECURE {
_marker: PhantomData,
},
DMA1_SECURE: DMA1_SECURE {
_marker: PhantomData,
},
DMA2_SECURE: DMA2_SECURE {
_marker: PhantomData,
},
DMA3_SECURE: DMA3_SECURE {
_marker: PhantomData,
},
UART0: UART0 {
_marker: PhantomData,
},
UART1: UART1 {
_marker: PhantomData,
},
UART2: UART2 {
_marker: PhantomData,
},
UART3: UART3 {
_marker: PhantomData,
},
UART4: UART4 {
_marker: PhantomData,
},
UART5: UART5 {
_marker: PhantomData,
},
UART0_SECURE: UART0_SECURE {
_marker: PhantomData,
},
UART1_SECURE: UART1_SECURE {
_marker: PhantomData,
},
UART2_SECURE: UART2_SECURE {
_marker: PhantomData,
},
UART3_SECURE: UART3_SECURE {
_marker: PhantomData,
},
UART4_SECURE: UART4_SECURE {
_marker: PhantomData,
},
UART5_SECURE: UART5_SECURE {
_marker: PhantomData,
},
I2C0: I2C0 {
_marker: PhantomData,
},
I2C1: I2C1 {
_marker: PhantomData,
},
I2C0_SECURE: I2C0_SECURE {
_marker: PhantomData,
},
I2C1_SECURE: I2C1_SECURE {
_marker: PhantomData,
},
SSP0: SSP0 {
_marker: PhantomData,
},
SSP1: SSP1 {
_marker: PhantomData,
},
SSP2: SSP2 {
_marker: PhantomData,
},
SSP0_SECURE: SSP0_SECURE {
_marker: PhantomData,
},
SSP1_SECURE: SSP1_SECURE {
_marker: PhantomData,
},
SSP2_SECURE: SSP2_SECURE {
_marker: PhantomData,
},
WATCHDOG: WATCHDOG {
_marker: PhantomData,
},
WATCHDOG_SECURE: WATCHDOG_SECURE {
_marker: PhantomData,
},
SLOWCLKWATCHDOG: SLOWCLKWATCHDOG {
_marker: PhantomData,
},
FPGAIO: FPGAIO {
_marker: PhantomData,
},
FPGAIO_SECURE: FPGAIO_SECURE {
_marker: PhantomData,
},
SCC: SCC {
_marker: PhantomData,
},
SCC_SECURE: SCC_SECURE {
_marker: PhantomData,
},
SACRB: SACRB {
_marker: PhantomData,
},
NSACRB: NSACRB {
_marker: PhantomData,
},
ISRAM0MPC: ISRAM0MPC {
_marker: PhantomData,
},
ISRAM1MPC: ISRAM1MPC {
_marker: PhantomData,
},
ETHERNET: ETHERNET {
_marker: PhantomData,
},
AUDIO_I2S: AUDIO_I2S {
_marker: PhantomData,
},
}
}
}