#![doc = "Peripheral access API for ATSAMV71Q20 microcontrollers (generated using svd2rust v0.21.0 ( ))\n\nYou can find an overview of the generated API [here].\n\nAPI features to be included in the [next]
svd2rust release can be generated by cloning the svd2rust [repository], checking out the above commit, and running `cargo doc --open`.\n\n[here]: https://docs.rs/svd2rust/0.21.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 SUPC();
fn RSTC();
fn RTC();
fn RTT();
fn WDT();
fn PMC();
fn EFC();
fn UART0();
fn UART1();
fn PIOA();
fn PIOB();
fn PIOC();
fn USART0();
fn USART1();
fn USART2();
fn PIOD();
fn PIOE();
fn HSMCI();
fn TWIHS0();
fn TWIHS1();
fn SPI0();
fn SSC();
fn TC0();
fn TC1();
fn TC2();
fn TC3();
fn TC4();
fn TC5();
fn AFEC0();
fn DACC();
fn PWM0();
fn ICM();
fn ACC();
fn USBHS();
fn MCAN0_INT0();
fn MCAN0_INT1();
fn MCAN1_INT0();
fn MCAN1_INT1();
fn GMAC();
fn AFEC1();
fn TWIHS2();
fn SPI1();
fn QSPI();
fn UART2();
fn UART3();
fn UART4();
fn TC6();
fn TC7();
fn TC8();
fn TC9();
fn TC10();
fn TC11();
fn MLB();
fn AES();
fn TRNG();
fn XDMAC();
fn ISI();
fn PWM1();
fn FPU();
fn SDRAMC();
fn RSWDT();
fn GMAC_Q1();
fn GMAC_Q2();
fn IXC();
}
#[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; 69] = [
Vector { _handler: SUPC },
Vector { _handler: RSTC },
Vector { _handler: RTC },
Vector { _handler: RTT },
Vector { _handler: WDT },
Vector { _handler: PMC },
Vector { _handler: EFC },
Vector { _handler: UART0 },
Vector { _handler: UART1 },
Vector { _reserved: 0 },
Vector { _handler: PIOA },
Vector { _handler: PIOB },
Vector { _handler: PIOC },
Vector { _handler: USART0 },
Vector { _handler: USART1 },
Vector { _handler: USART2 },
Vector { _handler: PIOD },
Vector { _handler: PIOE },
Vector { _handler: HSMCI },
Vector { _handler: TWIHS0 },
Vector { _handler: TWIHS1 },
Vector { _handler: SPI0 },
Vector { _handler: SSC },
Vector { _handler: TC0 },
Vector { _handler: TC1 },
Vector { _handler: TC2 },
Vector { _handler: TC3 },
Vector { _handler: TC4 },
Vector { _handler: TC5 },
Vector { _handler: AFEC0 },
Vector { _handler: DACC },
Vector { _handler: PWM0 },
Vector { _handler: ICM },
Vector { _handler: ACC },
Vector { _handler: USBHS },
Vector {
_handler: MCAN0_INT0,
},
Vector {
_handler: MCAN0_INT1,
},
Vector {
_handler: MCAN1_INT0,
},
Vector {
_handler: MCAN1_INT1,
},
Vector { _handler: GMAC },
Vector { _handler: AFEC1 },
Vector { _handler: TWIHS2 },
Vector { _handler: SPI1 },
Vector { _handler: QSPI },
Vector { _handler: UART2 },
Vector { _handler: UART3 },
Vector { _handler: UART4 },
Vector { _handler: TC6 },
Vector { _handler: TC7 },
Vector { _handler: TC8 },
Vector { _handler: TC9 },
Vector { _handler: TC10 },
Vector { _handler: TC11 },
Vector { _handler: MLB },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _handler: AES },
Vector { _handler: TRNG },
Vector { _handler: XDMAC },
Vector { _handler: ISI },
Vector { _handler: PWM1 },
Vector { _handler: FPU },
Vector { _handler: SDRAMC },
Vector { _handler: RSWDT },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _handler: GMAC_Q1 },
Vector { _handler: GMAC_Q2 },
Vector { _handler: IXC },
];
#[doc = r"Enumeration of all the interrupts."]
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
#[repr(u16)]
pub enum Interrupt {
#[doc = "0 - SUPC"]
SUPC = 0,
#[doc = "1 - RSTC"]
RSTC = 1,
#[doc = "2 - RTC"]
RTC = 2,
#[doc = "3 - RTT"]
RTT = 3,
#[doc = "4 - WDT"]
WDT = 4,
#[doc = "5 - PMC"]
PMC = 5,
#[doc = "6 - EFC"]
EFC = 6,
#[doc = "7 - UART0"]
UART0 = 7,
#[doc = "8 - UART1"]
UART1 = 8,
#[doc = "10 - PIOA"]
PIOA = 10,
#[doc = "11 - PIOB"]
PIOB = 11,
#[doc = "12 - PIOC"]
PIOC = 12,
#[doc = "13 - USART0"]
USART0 = 13,
#[doc = "14 - USART1"]
USART1 = 14,
#[doc = "15 - USART2"]
USART2 = 15,
#[doc = "16 - PIOD"]
PIOD = 16,
#[doc = "17 - PIOE"]
PIOE = 17,
#[doc = "18 - HSMCI"]
HSMCI = 18,
#[doc = "19 - TWIHS0"]
TWIHS0 = 19,
#[doc = "20 - TWIHS1"]
TWIHS1 = 20,
#[doc = "21 - SPI0"]
SPI0 = 21,
#[doc = "22 - SSC"]
SSC = 22,
#[doc = "23 - TC0"]
TC0 = 23,
#[doc = "24 - TC1"]
TC1 = 24,
#[doc = "25 - TC2"]
TC2 = 25,
#[doc = "26 - TC3"]
TC3 = 26,
#[doc = "27 - TC4"]
TC4 = 27,
#[doc = "28 - TC5"]
TC5 = 28,
#[doc = "29 - AFEC0"]
AFEC0 = 29,
#[doc = "30 - DACC"]
DACC = 30,
#[doc = "31 - PWM0"]
PWM0 = 31,
#[doc = "32 - ICM"]
ICM = 32,
#[doc = "33 - ACC"]
ACC = 33,
#[doc = "34 - USBHS"]
USBHS = 34,
#[doc = "35 - MCAN0_INT0"]
MCAN0_INT0 = 35,
#[doc = "36 - MCAN0_INT1"]
MCAN0_INT1 = 36,
#[doc = "37 - MCAN1_INT0"]
MCAN1_INT0 = 37,
#[doc = "38 - MCAN1_INT1"]
MCAN1_INT1 = 38,
#[doc = "39 - GMAC"]
GMAC = 39,
#[doc = "40 - AFEC1"]
AFEC1 = 40,
#[doc = "41 - TWIHS2"]
TWIHS2 = 41,
#[doc = "42 - SPI1"]
SPI1 = 42,
#[doc = "43 - QSPI"]
QSPI = 43,
#[doc = "44 - UART2"]
UART2 = 44,
#[doc = "45 - UART3"]
UART3 = 45,
#[doc = "46 - UART4"]
UART4 = 46,
#[doc = "47 - TC6"]
TC6 = 47,
#[doc = "48 - TC7"]
TC7 = 48,
#[doc = "49 - TC8"]
TC8 = 49,
#[doc = "50 - TC9"]
TC9 = 50,
#[doc = "51 - TC10"]
TC10 = 51,
#[doc = "52 - TC11"]
TC11 = 52,
#[doc = "53 - MLB"]
MLB = 53,
#[doc = "56 - AES"]
AES = 56,
#[doc = "57 - TRNG"]
TRNG = 57,
#[doc = "58 - XDMAC"]
XDMAC = 58,
#[doc = "59 - ISI"]
ISI = 59,
#[doc = "60 - PWM1"]
PWM1 = 60,
#[doc = "61 - FPU"]
FPU = 61,
#[doc = "62 - SDRAMC"]
SDRAMC = 62,
#[doc = "63 - RSWDT"]
RSWDT = 63,
#[doc = "66 - GMAC_Q1"]
GMAC_Q1 = 66,
#[doc = "67 - GMAC_Q2"]
GMAC_Q2 = 67,
#[doc = "68 - IXC"]
IXC = 68,
}
unsafe impl cortex_m::interrupt::InterruptNumber for Interrupt {
#[inline(always)]
fn number(self) -> u16 {
self as u16
}
}
#[doc = "Analog Comparator Controller"]
pub struct ACC {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for ACC {}
impl ACC {
#[doc = r"Pointer to the register block"]
pub const PTR: *const acc::RegisterBlock = 0x4004_4000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const acc::RegisterBlock {
Self::PTR
}
}
impl Deref for ACC {
type Target = acc::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for ACC {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("ACC").finish()
}
}
#[doc = "Analog Comparator Controller"]
pub mod acc;
#[doc = "Advanced Encryption Standard"]
pub struct AES {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for AES {}
impl AES {
#[doc = r"Pointer to the register block"]
pub const PTR: *const aes::RegisterBlock = 0x4006_c000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const aes::RegisterBlock {
Self::PTR
}
}
impl Deref for AES {
type Target = aes::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for AES {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("AES").finish()
}
}
#[doc = "Advanced Encryption Standard"]
pub mod aes;
#[doc = "Analog Front-End Controller"]
pub struct AFEC0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for AFEC0 {}
impl AFEC0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const afec0::RegisterBlock = 0x4003_c000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const afec0::RegisterBlock {
Self::PTR
}
}
impl Deref for AFEC0 {
type Target = afec0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for AFEC0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("AFEC0").finish()
}
}
#[doc = "Analog Front-End Controller"]
pub mod afec0;
#[doc = "Analog Front-End Controller"]
pub struct AFEC1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for AFEC1 {}
impl AFEC1 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const afec0::RegisterBlock = 0x4006_4000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const afec0::RegisterBlock {
Self::PTR
}
}
impl Deref for AFEC1 {
type Target = afec0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for AFEC1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("AFEC1").finish()
}
}
#[doc = "Analog Front-End Controller"]
pub use afec0 as afec1;
#[doc = "Chip Identifier"]
pub struct CHIPID {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for CHIPID {}
impl CHIPID {
#[doc = r"Pointer to the register block"]
pub const PTR: *const chipid::RegisterBlock = 0x400e_0940 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const chipid::RegisterBlock {
Self::PTR
}
}
impl Deref for CHIPID {
type Target = chipid::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for CHIPID {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("CHIPID").finish()
}
}
#[doc = "Chip Identifier"]
pub mod chipid;
#[doc = "Digital-to-Analog Converter Controller"]
pub struct DACC {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for DACC {}
impl DACC {
#[doc = r"Pointer to the register block"]
pub const PTR: *const dacc::RegisterBlock = 0x4004_0000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const dacc::RegisterBlock {
Self::PTR
}
}
impl Deref for DACC {
type Target = dacc::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for DACC {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("DACC").finish()
}
}
#[doc = "Digital-to-Analog Converter Controller"]
pub mod dacc;
#[doc = "Embedded Flash Controller"]
pub struct EFC {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for EFC {}
impl EFC {
#[doc = r"Pointer to the register block"]
pub const PTR: *const efc::RegisterBlock = 0x400e_0c00 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const efc::RegisterBlock {
Self::PTR
}
}
impl Deref for EFC {
type Target = efc::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for EFC {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("EFC").finish()
}
}
#[doc = "Embedded Flash Controller"]
pub mod efc;
#[doc = "Gigabit Ethernet MAC"]
pub struct GMAC {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for GMAC {}
impl GMAC {
#[doc = r"Pointer to the register block"]
pub const PTR: *const gmac::RegisterBlock = 0x4005_0000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const gmac::RegisterBlock {
Self::PTR
}
}
impl Deref for GMAC {
type Target = gmac::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for GMAC {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("GMAC").finish()
}
}
#[doc = "Gigabit Ethernet MAC"]
pub mod gmac;
#[doc = "General Purpose Backup Registers"]
pub struct GPBR {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for GPBR {}
impl GPBR {
#[doc = r"Pointer to the register block"]
pub const PTR: *const gpbr::RegisterBlock = 0x400e_1890 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const gpbr::RegisterBlock {
Self::PTR
}
}
impl Deref for GPBR {
type Target = gpbr::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for GPBR {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("GPBR").finish()
}
}
#[doc = "General Purpose Backup Registers"]
pub mod gpbr;
#[doc = "High Speed MultiMedia Card Interface"]
pub struct HSMCI {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for HSMCI {}
impl HSMCI {
#[doc = r"Pointer to the register block"]
pub const PTR: *const hsmci::RegisterBlock = 0x4000_0000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const hsmci::RegisterBlock {
Self::PTR
}
}
impl Deref for HSMCI {
type Target = hsmci::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for HSMCI {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("HSMCI").finish()
}
}
#[doc = "High Speed MultiMedia Card Interface"]
pub mod hsmci;
#[doc = "Integrity Check Monitor"]
pub struct ICM {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for ICM {}
impl ICM {
#[doc = r"Pointer to the register block"]
pub const PTR: *const icm::RegisterBlock = 0x4004_8000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const icm::RegisterBlock {
Self::PTR
}
}
impl Deref for ICM {
type Target = icm::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for ICM {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("ICM").finish()
}
}
#[doc = "Integrity Check Monitor"]
pub mod icm;
#[doc = "Image Sensor Interface"]
pub struct ISI {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for ISI {}
impl ISI {
#[doc = r"Pointer to the register block"]
pub const PTR: *const isi::RegisterBlock = 0x4004_c000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const isi::RegisterBlock {
Self::PTR
}
}
impl Deref for ISI {
type Target = isi::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for ISI {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("ISI").finish()
}
}
#[doc = "Image Sensor Interface"]
pub mod isi;
#[doc = "AHB Bus Matrix"]
pub struct MATRIX {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for MATRIX {}
impl MATRIX {
#[doc = r"Pointer to the register block"]
pub const PTR: *const matrix::RegisterBlock = 0x4008_8000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const matrix::RegisterBlock {
Self::PTR
}
}
impl Deref for MATRIX {
type Target = matrix::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for MATRIX {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("MATRIX").finish()
}
}
#[doc = "AHB Bus Matrix"]
pub mod matrix;
#[doc = "Controller Area Network"]
pub struct MCAN0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for MCAN0 {}
impl MCAN0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const mcan0::RegisterBlock = 0x4003_0000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const mcan0::RegisterBlock {
Self::PTR
}
}
impl Deref for MCAN0 {
type Target = mcan0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for MCAN0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("MCAN0").finish()
}
}
#[doc = "Controller Area Network"]
pub mod mcan0;
#[doc = "Controller Area Network"]
pub struct MCAN1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for MCAN1 {}
impl MCAN1 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const mcan0::RegisterBlock = 0x4003_4000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const mcan0::RegisterBlock {
Self::PTR
}
}
impl Deref for MCAN1 {
type Target = mcan0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for MCAN1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("MCAN1").finish()
}
}
#[doc = "Controller Area Network"]
pub use mcan0 as mcan1;
#[doc = "MediaLB"]
pub struct MLB {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for MLB {}
impl MLB {
#[doc = r"Pointer to the register block"]
pub const PTR: *const mlb::RegisterBlock = 0x4006_8000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const mlb::RegisterBlock {
Self::PTR
}
}
impl Deref for MLB {
type Target = mlb::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for MLB {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("MLB").finish()
}
}
#[doc = "MediaLB"]
pub mod mlb;
#[doc = "Parallel Input/Output Controller"]
pub struct PIOA {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PIOA {}
impl PIOA {
#[doc = r"Pointer to the register block"]
pub const PTR: *const pioa::RegisterBlock = 0x400e_0e00 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const pioa::RegisterBlock {
Self::PTR
}
}
impl Deref for PIOA {
type Target = pioa::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for PIOA {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("PIOA").finish()
}
}
#[doc = "Parallel Input/Output Controller"]
pub mod pioa;
#[doc = "Parallel Input/Output Controller"]
pub struct PIOB {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PIOB {}
impl PIOB {
#[doc = r"Pointer to the register block"]
pub const PTR: *const pioa::RegisterBlock = 0x400e_1000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const pioa::RegisterBlock {
Self::PTR
}
}
impl Deref for PIOB {
type Target = pioa::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for PIOB {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("PIOB").finish()
}
}
#[doc = "Parallel Input/Output Controller"]
pub use pioa as piob;
#[doc = "Parallel Input/Output Controller"]
pub struct PIOC {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PIOC {}
impl PIOC {
#[doc = r"Pointer to the register block"]
pub const PTR: *const pioa::RegisterBlock = 0x400e_1200 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const pioa::RegisterBlock {
Self::PTR
}
}
impl Deref for PIOC {
type Target = pioa::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for PIOC {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("PIOC").finish()
}
}
#[doc = "Parallel Input/Output Controller"]
pub use pioa as pioc;
#[doc = "Parallel Input/Output Controller"]
pub struct PIOD {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PIOD {}
impl PIOD {
#[doc = r"Pointer to the register block"]
pub const PTR: *const pioa::RegisterBlock = 0x400e_1400 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const pioa::RegisterBlock {
Self::PTR
}
}
impl Deref for PIOD {
type Target = pioa::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for PIOD {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("PIOD").finish()
}
}
#[doc = "Parallel Input/Output Controller"]
pub use pioa as piod;
#[doc = "Parallel Input/Output Controller"]
pub struct PIOE {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PIOE {}
impl PIOE {
#[doc = r"Pointer to the register block"]
pub const PTR: *const pioa::RegisterBlock = 0x400e_1600 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const pioa::RegisterBlock {
Self::PTR
}
}
impl Deref for PIOE {
type Target = pioa::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for PIOE {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("PIOE").finish()
}
}
#[doc = "Parallel Input/Output Controller"]
pub use pioa as pioe;
#[doc = "Power Management Controller"]
pub struct PMC {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PMC {}
impl PMC {
#[doc = r"Pointer to the register block"]
pub const PTR: *const pmc::RegisterBlock = 0x400e_0600 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const pmc::RegisterBlock {
Self::PTR
}
}
impl Deref for PMC {
type Target = pmc::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for PMC {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("PMC").finish()
}
}
#[doc = "Power Management Controller"]
pub mod pmc;
#[doc = "Pulse Width Modulation Controller"]
pub struct PWM0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PWM0 {}
impl PWM0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const pwm0::RegisterBlock = 0x4002_0000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const pwm0::RegisterBlock {
Self::PTR
}
}
impl Deref for PWM0 {
type Target = pwm0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for PWM0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("PWM0").finish()
}
}
#[doc = "Pulse Width Modulation Controller"]
pub mod pwm0;
#[doc = "Pulse Width Modulation Controller"]
pub struct PWM1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PWM1 {}
impl PWM1 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const pwm0::RegisterBlock = 0x4005_c000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const pwm0::RegisterBlock {
Self::PTR
}
}
impl Deref for PWM1 {
type Target = pwm0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for PWM1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("PWM1").finish()
}
}
#[doc = "Pulse Width Modulation Controller"]
pub use pwm0 as pwm1;
#[doc = "Quad Serial Peripheral Interface"]
pub struct QSPI {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for QSPI {}
impl QSPI {
#[doc = r"Pointer to the register block"]
pub const PTR: *const qspi::RegisterBlock = 0x4007_c000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const qspi::RegisterBlock {
Self::PTR
}
}
impl Deref for QSPI {
type Target = qspi::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for QSPI {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("QSPI").finish()
}
}
#[doc = "Quad Serial Peripheral Interface"]
pub mod qspi;
#[doc = "Reset Controller"]
pub struct RSTC {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for RSTC {}
impl RSTC {
#[doc = r"Pointer to the register block"]
pub const PTR: *const rstc::RegisterBlock = 0x400e_1800 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const rstc::RegisterBlock {
Self::PTR
}
}
impl Deref for RSTC {
type Target = rstc::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for RSTC {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("RSTC").finish()
}
}
#[doc = "Reset Controller"]
pub mod rstc;
#[doc = "Reinforced Safety Watchdog Timer"]
pub struct RSWDT {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for RSWDT {}
impl RSWDT {
#[doc = r"Pointer to the register block"]
pub const PTR: *const rswdt::RegisterBlock = 0x400e_1900 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const rswdt::RegisterBlock {
Self::PTR
}
}
impl Deref for RSWDT {
type Target = rswdt::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for RSWDT {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("RSWDT").finish()
}
}
#[doc = "Reinforced Safety Watchdog Timer"]
pub mod rswdt;
#[doc = "Real-time Clock"]
pub struct RTC {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for RTC {}
impl RTC {
#[doc = r"Pointer to the register block"]
pub const PTR: *const rtc::RegisterBlock = 0x400e_1860 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const rtc::RegisterBlock {
Self::PTR
}
}
impl Deref for RTC {
type Target = rtc::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for RTC {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("RTC").finish()
}
}
#[doc = "Real-time Clock"]
pub mod rtc;
#[doc = "Real-time Timer"]
pub struct RTT {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for RTT {}
impl RTT {
#[doc = r"Pointer to the register block"]
pub const PTR: *const rtt::RegisterBlock = 0x400e_1830 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const rtt::RegisterBlock {
Self::PTR
}
}
impl Deref for RTT {
type Target = rtt::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for RTT {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("RTT").finish()
}
}
#[doc = "Real-time Timer"]
pub mod rtt;
#[doc = "SDRAM Controller"]
pub struct SDRAMC {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SDRAMC {}
impl SDRAMC {
#[doc = r"Pointer to the register block"]
pub const PTR: *const sdramc::RegisterBlock = 0x4008_4000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const sdramc::RegisterBlock {
Self::PTR
}
}
impl Deref for SDRAMC {
type Target = sdramc::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for SDRAMC {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("SDRAMC").finish()
}
}
#[doc = "SDRAM Controller"]
pub mod sdramc;
#[doc = "Static Memory Controller"]
pub struct SMC {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SMC {}
impl SMC {
#[doc = r"Pointer to the register block"]
pub const PTR: *const smc::RegisterBlock = 0x4008_0000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const smc::RegisterBlock {
Self::PTR
}
}
impl Deref for SMC {
type Target = smc::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for SMC {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("SMC").finish()
}
}
#[doc = "Static Memory Controller"]
pub mod smc;
#[doc = "Serial Peripheral Interface"]
pub struct SPI0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SPI0 {}
impl SPI0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const spi0::RegisterBlock = 0x4000_8000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const spi0::RegisterBlock {
Self::PTR
}
}
impl Deref for SPI0 {
type Target = spi0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for SPI0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("SPI0").finish()
}
}
#[doc = "Serial Peripheral Interface"]
pub mod spi0;
#[doc = "Serial Peripheral Interface"]
pub struct SPI1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SPI1 {}
impl SPI1 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const spi0::RegisterBlock = 0x4005_8000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const spi0::RegisterBlock {
Self::PTR
}
}
impl Deref for SPI1 {
type Target = spi0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for SPI1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("SPI1").finish()
}
}
#[doc = "Serial Peripheral Interface"]
pub use spi0 as spi1;
#[doc = "Synchronous Serial Controller"]
pub struct SSC {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SSC {}
impl SSC {
#[doc = r"Pointer to the register block"]
pub const PTR: *const ssc::RegisterBlock = 0x4000_4000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const ssc::RegisterBlock {
Self::PTR
}
}
impl Deref for SSC {
type Target = ssc::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for SSC {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("SSC").finish()
}
}
#[doc = "Synchronous Serial Controller"]
pub mod ssc;
#[doc = "Supply Controller"]
pub struct SUPC {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SUPC {}
impl SUPC {
#[doc = r"Pointer to the register block"]
pub const PTR: *const supc::RegisterBlock = 0x400e_1810 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const supc::RegisterBlock {
Self::PTR
}
}
impl Deref for SUPC {
type Target = supc::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for SUPC {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("SUPC").finish()
}
}
#[doc = "Supply Controller"]
pub mod supc;
#[doc = "Timer Counter"]
pub struct TC0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for TC0 {}
impl TC0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const tc0::RegisterBlock = 0x4000_c000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const tc0::RegisterBlock {
Self::PTR
}
}
impl Deref for TC0 {
type Target = tc0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for TC0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("TC0").finish()
}
}
#[doc = "Timer Counter"]
pub mod tc0;
#[doc = "Timer Counter"]
pub struct TC1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for TC1 {}
impl TC1 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const tc0::RegisterBlock = 0x4001_0000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const tc0::RegisterBlock {
Self::PTR
}
}
impl Deref for TC1 {
type Target = tc0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for TC1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("TC1").finish()
}
}
#[doc = "Timer Counter"]
pub use tc0 as tc1;
#[doc = "Timer Counter"]
pub struct TC2 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for TC2 {}
impl TC2 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const tc0::RegisterBlock = 0x4001_4000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const tc0::RegisterBlock {
Self::PTR
}
}
impl Deref for TC2 {
type Target = tc0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for TC2 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("TC2").finish()
}
}
#[doc = "Timer Counter"]
pub use tc0 as tc2;
#[doc = "Timer Counter"]
pub struct TC3 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for TC3 {}
impl TC3 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const tc0::RegisterBlock = 0x4005_4000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const tc0::RegisterBlock {
Self::PTR
}
}
impl Deref for TC3 {
type Target = tc0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for TC3 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("TC3").finish()
}
}
#[doc = "Timer Counter"]
pub use tc0 as tc3;
#[doc = "True Random Number Generator"]
pub struct TRNG {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for TRNG {}
impl TRNG {
#[doc = r"Pointer to the register block"]
pub const PTR: *const trng::RegisterBlock = 0x4007_0000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const trng::RegisterBlock {
Self::PTR
}
}
impl Deref for TRNG {
type Target = trng::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for TRNG {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("TRNG").finish()
}
}
#[doc = "True Random Number Generator"]
pub mod trng;
#[doc = "Two-wire Interface High Speed"]
pub struct TWIHS0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for TWIHS0 {}
impl TWIHS0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const twihs0::RegisterBlock = 0x4001_8000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const twihs0::RegisterBlock {
Self::PTR
}
}
impl Deref for TWIHS0 {
type Target = twihs0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for TWIHS0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("TWIHS0").finish()
}
}
#[doc = "Two-wire Interface High Speed"]
pub mod twihs0;
#[doc = "Two-wire Interface High Speed"]
pub struct TWIHS1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for TWIHS1 {}
impl TWIHS1 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const twihs0::RegisterBlock = 0x4001_c000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const twihs0::RegisterBlock {
Self::PTR
}
}
impl Deref for TWIHS1 {
type Target = twihs0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for TWIHS1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("TWIHS1").finish()
}
}
#[doc = "Two-wire Interface High Speed"]
pub use twihs0 as twihs1;
#[doc = "Two-wire Interface High Speed"]
pub struct TWIHS2 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for TWIHS2 {}
impl TWIHS2 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const twihs0::RegisterBlock = 0x4006_0000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const twihs0::RegisterBlock {
Self::PTR
}
}
impl Deref for TWIHS2 {
type Target = twihs0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for TWIHS2 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("TWIHS2").finish()
}
}
#[doc = "Two-wire Interface High Speed"]
pub use twihs0 as twihs2;
#[doc = "Universal Asynchronous Receiver Transmitter"]
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 = 0x400e_0800 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 = "Universal Asynchronous Receiver Transmitter"]
pub mod uart0;
#[doc = "Universal Asynchronous Receiver Transmitter"]
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 = 0x400e_0a00 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 = "Universal Asynchronous Receiver Transmitter"]
pub use uart0 as uart1;
#[doc = "Universal Asynchronous Receiver Transmitter"]
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 = 0x400e_1a00 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 = "Universal Asynchronous Receiver Transmitter"]
pub use uart0 as uart2;
#[doc = "Universal Asynchronous Receiver Transmitter"]
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 = 0x400e_1c00 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 = "Universal Asynchronous Receiver Transmitter"]
pub use uart0 as uart3;
#[doc = "Universal Asynchronous Receiver Transmitter"]
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 = 0x400e_1e00 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 = "Universal Asynchronous Receiver Transmitter"]
pub use uart0 as uart4;
#[doc = "Universal Synchronous Asynchronous Receiver Transmitter"]
pub struct USART0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for USART0 {}
impl USART0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const usart0::RegisterBlock = 0x4002_4000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const usart0::RegisterBlock {
Self::PTR
}
}
impl Deref for USART0 {
type Target = usart0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for USART0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("USART0").finish()
}
}
#[doc = "Universal Synchronous Asynchronous Receiver Transmitter"]
pub mod usart0;
#[doc = "Universal Synchronous Asynchronous Receiver Transmitter"]
pub struct USART1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for USART1 {}
impl USART1 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const usart0::RegisterBlock = 0x4002_8000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const usart0::RegisterBlock {
Self::PTR
}
}
impl Deref for USART1 {
type Target = usart0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for USART1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("USART1").finish()
}
}
#[doc = "Universal Synchronous Asynchronous Receiver Transmitter"]
pub use usart0 as usart1;
#[doc = "Universal Synchronous Asynchronous Receiver Transmitter"]
pub struct USART2 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for USART2 {}
impl USART2 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const usart0::RegisterBlock = 0x4002_c000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const usart0::RegisterBlock {
Self::PTR
}
}
impl Deref for USART2 {
type Target = usart0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for USART2 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("USART2").finish()
}
}
#[doc = "Universal Synchronous Asynchronous Receiver Transmitter"]
pub use usart0 as usart2;
#[doc = "USB High-Speed Interface"]
pub struct USBHS {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for USBHS {}
impl USBHS {
#[doc = r"Pointer to the register block"]
pub const PTR: *const usbhs::RegisterBlock = 0x4003_8000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const usbhs::RegisterBlock {
Self::PTR
}
}
impl Deref for USBHS {
type Target = usbhs::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for USBHS {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("USBHS").finish()
}
}
#[doc = "USB High-Speed Interface"]
pub mod usbhs;
#[doc = "USB Transmitter Interface Macrocell"]
pub struct UTMI {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for UTMI {}
impl UTMI {
#[doc = r"Pointer to the register block"]
pub const PTR: *const utmi::RegisterBlock = 0x400e_0400 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const utmi::RegisterBlock {
Self::PTR
}
}
impl Deref for UTMI {
type Target = utmi::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for UTMI {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("UTMI").finish()
}
}
#[doc = "USB Transmitter Interface Macrocell"]
pub mod utmi;
#[doc = "Watchdog Timer"]
pub struct WDT {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for WDT {}
impl WDT {
#[doc = r"Pointer to the register block"]
pub const PTR: *const wdt::RegisterBlock = 0x400e_1850 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const wdt::RegisterBlock {
Self::PTR
}
}
impl Deref for WDT {
type Target = wdt::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for WDT {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("WDT").finish()
}
}
#[doc = "Watchdog Timer"]
pub mod wdt;
#[doc = "Extensible DMA Controller"]
pub struct XDMAC {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for XDMAC {}
impl XDMAC {
#[doc = r"Pointer to the register block"]
pub const PTR: *const xdmac::RegisterBlock = 0x4007_8000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const xdmac::RegisterBlock {
Self::PTR
}
}
impl Deref for XDMAC {
type Target = xdmac::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for XDMAC {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("XDMAC").finish()
}
}
#[doc = "Extensible DMA Controller"]
pub mod xdmac;
#[doc = "LOCKBIT"]
pub struct LOCKBIT {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for LOCKBIT {}
impl LOCKBIT {
#[doc = r"Pointer to the register block"]
pub const PTR: *const lockbit::RegisterBlock = 0 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const lockbit::RegisterBlock {
Self::PTR
}
}
impl Deref for LOCKBIT {
type Target = lockbit::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for LOCKBIT {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("LOCKBIT").finish()
}
}
#[doc = "LOCKBIT"]
pub mod lockbit;
#[doc = "System control not in SCB"]
pub struct SCNSCB {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SCNSCB {}
impl SCNSCB {
#[doc = r"Pointer to the register block"]
pub const PTR: *const scn_scb::RegisterBlock = 0xe000_e000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const scn_scb::RegisterBlock {
Self::PTR
}
}
impl Deref for SCNSCB {
type Target = scn_scb::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for SCNSCB {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("SCNSCB").finish()
}
}
#[doc = "System control not in SCB"]
pub mod scn_scb;
#[doc = "System timer"]
pub struct SYSTICK {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SYSTICK {}
impl SYSTICK {
#[doc = r"Pointer to the register block"]
pub const PTR: *const sys_tick::RegisterBlock = 0xe000_e010 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const sys_tick::RegisterBlock {
Self::PTR
}
}
impl Deref for SYSTICK {
type Target = sys_tick::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for SYSTICK {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("SYSTICK").finish()
}
}
#[doc = "System timer"]
pub mod sys_tick;
#[no_mangle]
static mut DEVICE_PERIPHERALS: bool = false;
#[doc = r"All the peripherals"]
#[allow(non_snake_case)]
pub struct Peripherals {
#[doc = "ACC"]
pub ACC: ACC,
#[doc = "AES"]
pub AES: AES,
#[doc = "AFEC0"]
pub AFEC0: AFEC0,
#[doc = "AFEC1"]
pub AFEC1: AFEC1,
#[doc = "CHIPID"]
pub CHIPID: CHIPID,
#[doc = "DACC"]
pub DACC: DACC,
#[doc = "EFC"]
pub EFC: EFC,
#[doc = "GMAC"]
pub GMAC: GMAC,
#[doc = "GPBR"]
pub GPBR: GPBR,
#[doc = "HSMCI"]
pub HSMCI: HSMCI,
#[doc = "ICM"]
pub ICM: ICM,
#[doc = "ISI"]
pub ISI: ISI,
#[doc = "MATRIX"]
pub MATRIX: MATRIX,
#[doc = "MCAN0"]
pub MCAN0: MCAN0,
#[doc = "MCAN1"]
pub MCAN1: MCAN1,
#[doc = "MLB"]
pub MLB: MLB,
#[doc = "PIOA"]
pub PIOA: PIOA,
#[doc = "PIOB"]
pub PIOB: PIOB,
#[doc = "PIOC"]
pub PIOC: PIOC,
#[doc = "PIOD"]
pub PIOD: PIOD,
#[doc = "PIOE"]
pub PIOE: PIOE,
#[doc = "PMC"]
pub PMC: PMC,
#[doc = "PWM0"]
pub PWM0: PWM0,
#[doc = "PWM1"]
pub PWM1: PWM1,
#[doc = "QSPI"]
pub QSPI: QSPI,
#[doc = "RSTC"]
pub RSTC: RSTC,
#[doc = "RSWDT"]
pub RSWDT: RSWDT,
#[doc = "RTC"]
pub RTC: RTC,
#[doc = "RTT"]
pub RTT: RTT,
#[doc = "SDRAMC"]
pub SDRAMC: SDRAMC,
#[doc = "SMC"]
pub SMC: SMC,
#[doc = "SPI0"]
pub SPI0: SPI0,
#[doc = "SPI1"]
pub SPI1: SPI1,
#[doc = "SSC"]
pub SSC: SSC,
#[doc = "SUPC"]
pub SUPC: SUPC,
#[doc = "TC0"]
pub TC0: TC0,
#[doc = "TC1"]
pub TC1: TC1,
#[doc = "TC2"]
pub TC2: TC2,
#[doc = "TC3"]
pub TC3: TC3,
#[doc = "TRNG"]
pub TRNG: TRNG,
#[doc = "TWIHS0"]
pub TWIHS0: TWIHS0,
#[doc = "TWIHS1"]
pub TWIHS1: TWIHS1,
#[doc = "TWIHS2"]
pub TWIHS2: TWIHS2,
#[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 = "USART0"]
pub USART0: USART0,
#[doc = "USART1"]
pub USART1: USART1,
#[doc = "USART2"]
pub USART2: USART2,
#[doc = "USBHS"]
pub USBHS: USBHS,
#[doc = "UTMI"]
pub UTMI: UTMI,
#[doc = "WDT"]
pub WDT: WDT,
#[doc = "XDMAC"]
pub XDMAC: XDMAC,
#[doc = "LOCKBIT"]
pub LOCKBIT: LOCKBIT,
#[doc = "SCNSCB"]
pub SCNSCB: SCNSCB,
#[doc = "SYSTICK"]
pub SYSTICK: SYSTICK,
}
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 {
ACC: ACC {
_marker: PhantomData,
},
AES: AES {
_marker: PhantomData,
},
AFEC0: AFEC0 {
_marker: PhantomData,
},
AFEC1: AFEC1 {
_marker: PhantomData,
},
CHIPID: CHIPID {
_marker: PhantomData,
},
DACC: DACC {
_marker: PhantomData,
},
EFC: EFC {
_marker: PhantomData,
},
GMAC: GMAC {
_marker: PhantomData,
},
GPBR: GPBR {
_marker: PhantomData,
},
HSMCI: HSMCI {
_marker: PhantomData,
},
ICM: ICM {
_marker: PhantomData,
},
ISI: ISI {
_marker: PhantomData,
},
MATRIX: MATRIX {
_marker: PhantomData,
},
MCAN0: MCAN0 {
_marker: PhantomData,
},
MCAN1: MCAN1 {
_marker: PhantomData,
},
MLB: MLB {
_marker: PhantomData,
},
PIOA: PIOA {
_marker: PhantomData,
},
PIOB: PIOB {
_marker: PhantomData,
},
PIOC: PIOC {
_marker: PhantomData,
},
PIOD: PIOD {
_marker: PhantomData,
},
PIOE: PIOE {
_marker: PhantomData,
},
PMC: PMC {
_marker: PhantomData,
},
PWM0: PWM0 {
_marker: PhantomData,
},
PWM1: PWM1 {
_marker: PhantomData,
},
QSPI: QSPI {
_marker: PhantomData,
},
RSTC: RSTC {
_marker: PhantomData,
},
RSWDT: RSWDT {
_marker: PhantomData,
},
RTC: RTC {
_marker: PhantomData,
},
RTT: RTT {
_marker: PhantomData,
},
SDRAMC: SDRAMC {
_marker: PhantomData,
},
SMC: SMC {
_marker: PhantomData,
},
SPI0: SPI0 {
_marker: PhantomData,
},
SPI1: SPI1 {
_marker: PhantomData,
},
SSC: SSC {
_marker: PhantomData,
},
SUPC: SUPC {
_marker: PhantomData,
},
TC0: TC0 {
_marker: PhantomData,
},
TC1: TC1 {
_marker: PhantomData,
},
TC2: TC2 {
_marker: PhantomData,
},
TC3: TC3 {
_marker: PhantomData,
},
TRNG: TRNG {
_marker: PhantomData,
},
TWIHS0: TWIHS0 {
_marker: PhantomData,
},
TWIHS1: TWIHS1 {
_marker: PhantomData,
},
TWIHS2: TWIHS2 {
_marker: PhantomData,
},
UART0: UART0 {
_marker: PhantomData,
},
UART1: UART1 {
_marker: PhantomData,
},
UART2: UART2 {
_marker: PhantomData,
},
UART3: UART3 {
_marker: PhantomData,
},
UART4: UART4 {
_marker: PhantomData,
},
USART0: USART0 {
_marker: PhantomData,
},
USART1: USART1 {
_marker: PhantomData,
},
USART2: USART2 {
_marker: PhantomData,
},
USBHS: USBHS {
_marker: PhantomData,
},
UTMI: UTMI {
_marker: PhantomData,
},
WDT: WDT {
_marker: PhantomData,
},
XDMAC: XDMAC {
_marker: PhantomData,
},
LOCKBIT: LOCKBIT {
_marker: PhantomData,
},
SCNSCB: SCNSCB {
_marker: PhantomData,
},
SYSTICK: SYSTICK {
_marker: PhantomData,
},
}
}
}