#![doc = "Peripheral access API for ATSAM3U1C microcontrollers (generated using svd2rust v0.33.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.33.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"] #![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 = 4; #[allow(unused_imports)] use generic::*; #[doc = "Common register and bit access and modify traits"] pub mod generic; #[cfg(feature = "rt")] extern "C" { fn PMC(); fn EFC0(); fn UART(); fn PIOA(); fn PIOB(); fn USART0(); fn USART1(); fn USART2(); fn HSMCI(); fn TWI0(); fn TWI1(); fn SPI(); fn SSC(); fn TC0(); fn TC1(); fn TC2(); fn PWM(); fn ADC12B(); fn ADC(); fn DMAC(); fn UDPHS(); } #[doc(hidden)] #[repr(C)] 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; 30] = [ Vector { _reserved: 0 }, Vector { _reserved: 0 }, Vector { _reserved: 0 }, Vector { _reserved: 0 }, Vector { _reserved: 0 }, Vector { _handler: PMC }, Vector { _handler: EFC0 }, Vector { _reserved: 0 }, Vector { _handler: UART }, Vector { _reserved: 0 }, Vector { _handler: PIOA }, Vector { _handler: PIOB }, Vector { _reserved: 0 }, Vector { _handler: USART0 }, Vector { _handler: USART1 }, Vector { _handler: USART2 }, Vector { _reserved: 0 }, Vector { _handler: HSMCI }, Vector { _handler: TWI0 }, Vector { _handler: TWI1 }, Vector { _handler: SPI }, Vector { _handler: SSC }, Vector { _handler: TC0 }, Vector { _handler: TC1 }, Vector { _handler: TC2 }, Vector { _handler: PWM }, Vector { _handler: ADC12B }, Vector { _handler: ADC }, Vector { _handler: DMAC }, Vector { _handler: UDPHS }, ]; #[doc = r"Enumeration of all the interrupts."] #[derive(Copy, Clone, Debug, PartialEq, Eq)] #[repr(u16)] pub enum Interrupt { #[doc = "5 - PMC"] PMC = 5, #[doc = "6 - EFC0"] EFC0 = 6, #[doc = "8 - UART"] UART = 8, #[doc = "10 - PIOA"] PIOA = 10, #[doc = "11 - PIOB"] PIOB = 11, #[doc = "13 - USART0"] USART0 = 13, #[doc = "14 - USART1"] USART1 = 14, #[doc = "15 - USART2"] USART2 = 15, #[doc = "17 - HSMCI"] HSMCI = 17, #[doc = "18 - TWI0"] TWI0 = 18, #[doc = "19 - TWI1"] TWI1 = 19, #[doc = "20 - SPI"] SPI = 20, #[doc = "21 - SSC"] SSC = 21, #[doc = "22 - TC0"] TC0 = 22, #[doc = "23 - TC1"] TC1 = 23, #[doc = "24 - TC2"] TC2 = 24, #[doc = "25 - PWM"] PWM = 25, #[doc = "26 - ADC12B"] ADC12B = 26, #[doc = "27 - ADC"] ADC = 27, #[doc = "28 - DMAC"] DMAC = 28, #[doc = "29 - UDPHS"] UDPHS = 29, } unsafe impl cortex_m::interrupt::InterruptNumber for Interrupt { #[inline(always)] fn number(self) -> u16 { self as u16 } } #[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 } #[doc = r" Steal an instance of this peripheral"] #[doc = r""] #[doc = r" # Safety"] #[doc = r""] #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"] #[doc = r" that may race with any existing instances, for example by only"] #[doc = r" accessing read-only or write-only registers, or by consuming the"] #[doc = r" original peripheral and using critical sections to coordinate"] #[doc = r" access between multiple new instances."] #[doc = r""] #[doc = r" Additionally, other software such as HALs may rely on only one"] #[doc = r" peripheral instance existing to ensure memory safety; ensure"] #[doc = r" no stolen instances are passed to such software."] pub unsafe fn steal() -> Self { Self { _marker: PhantomData, } } } 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 = "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 } #[doc = r" Steal an instance of this peripheral"] #[doc = r""] #[doc = r" # Safety"] #[doc = r""] #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"] #[doc = r" that may race with any existing instances, for example by only"] #[doc = r" accessing read-only or write-only registers, or by consuming the"] #[doc = r" original peripheral and using critical sections to coordinate"] #[doc = r" access between multiple new instances."] #[doc = r""] #[doc = r" Additionally, other software such as HALs may rely on only one"] #[doc = r" peripheral instance existing to ensure memory safety; ensure"] #[doc = r" no stolen instances are passed to such software."] pub unsafe fn steal() -> Self { Self { _marker: PhantomData, } } } 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 = "Serial Peripheral Interface"] pub struct SPI { _marker: PhantomData<*const ()>, } unsafe impl Send for SPI {} impl SPI { #[doc = r"Pointer to the register block"] pub const PTR: *const spi::RegisterBlock = 0x4000_8000 as *const _; #[doc = r"Return the pointer to the register block"] #[inline(always)] pub const fn ptr() -> *const spi::RegisterBlock { Self::PTR } #[doc = r" Steal an instance of this peripheral"] #[doc = r""] #[doc = r" # Safety"] #[doc = r""] #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"] #[doc = r" that may race with any existing instances, for example by only"] #[doc = r" accessing read-only or write-only registers, or by consuming the"] #[doc = r" original peripheral and using critical sections to coordinate"] #[doc = r" access between multiple new instances."] #[doc = r""] #[doc = r" Additionally, other software such as HALs may rely on only one"] #[doc = r" peripheral instance existing to ensure memory safety; ensure"] #[doc = r" no stolen instances are passed to such software."] pub unsafe fn steal() -> Self { Self { _marker: PhantomData, } } } impl Deref for SPI { type Target = spi::RegisterBlock; #[inline(always)] fn deref(&self) -> &Self::Target { unsafe { &*Self::PTR } } } impl core::fmt::Debug for SPI { fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result { f.debug_struct("SPI").finish() } } #[doc = "Serial Peripheral Interface"] pub mod spi; #[doc = "Timer Counter 0"] 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 = 0x4008_0000 as *const _; #[doc = r"Return the pointer to the register block"] #[inline(always)] pub const fn ptr() -> *const tc0::RegisterBlock { Self::PTR } #[doc = r" Steal an instance of this peripheral"] #[doc = r""] #[doc = r" # Safety"] #[doc = r""] #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"] #[doc = r" that may race with any existing instances, for example by only"] #[doc = r" accessing read-only or write-only registers, or by consuming the"] #[doc = r" original peripheral and using critical sections to coordinate"] #[doc = r" access between multiple new instances."] #[doc = r""] #[doc = r" Additionally, other software such as HALs may rely on only one"] #[doc = r" peripheral instance existing to ensure memory safety; ensure"] #[doc = r" no stolen instances are passed to such software."] pub unsafe fn steal() -> Self { Self { _marker: PhantomData, } } } 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 0"] pub mod tc0; #[doc = "Two-wire Interface 0"] pub struct TWI0 { _marker: PhantomData<*const ()>, } unsafe impl Send for TWI0 {} impl TWI0 { #[doc = r"Pointer to the register block"] pub const PTR: *const twi0::RegisterBlock = 0x4008_4000 as *const _; #[doc = r"Return the pointer to the register block"] #[inline(always)] pub const fn ptr() -> *const twi0::RegisterBlock { Self::PTR } #[doc = r" Steal an instance of this peripheral"] #[doc = r""] #[doc = r" # Safety"] #[doc = r""] #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"] #[doc = r" that may race with any existing instances, for example by only"] #[doc = r" accessing read-only or write-only registers, or by consuming the"] #[doc = r" original peripheral and using critical sections to coordinate"] #[doc = r" access between multiple new instances."] #[doc = r""] #[doc = r" Additionally, other software such as HALs may rely on only one"] #[doc = r" peripheral instance existing to ensure memory safety; ensure"] #[doc = r" no stolen instances are passed to such software."] pub unsafe fn steal() -> Self { Self { _marker: PhantomData, } } } impl Deref for TWI0 { type Target = twi0::RegisterBlock; #[inline(always)] fn deref(&self) -> &Self::Target { unsafe { &*Self::PTR } } } impl core::fmt::Debug for TWI0 { fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result { f.debug_struct("TWI0").finish() } } #[doc = "Two-wire Interface 0"] pub mod twi0; #[doc = "Two-wire Interface 1"] pub struct TWI1 { _marker: PhantomData<*const ()>, } unsafe impl Send for TWI1 {} impl TWI1 { #[doc = r"Pointer to the register block"] pub const PTR: *const twi1::RegisterBlock = 0x4008_8000 as *const _; #[doc = r"Return the pointer to the register block"] #[inline(always)] pub const fn ptr() -> *const twi1::RegisterBlock { Self::PTR } #[doc = r" Steal an instance of this peripheral"] #[doc = r""] #[doc = r" # Safety"] #[doc = r""] #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"] #[doc = r" that may race with any existing instances, for example by only"] #[doc = r" accessing read-only or write-only registers, or by consuming the"] #[doc = r" original peripheral and using critical sections to coordinate"] #[doc = r" access between multiple new instances."] #[doc = r""] #[doc = r" Additionally, other software such as HALs may rely on only one"] #[doc = r" peripheral instance existing to ensure memory safety; ensure"] #[doc = r" no stolen instances are passed to such software."] pub unsafe fn steal() -> Self { Self { _marker: PhantomData, } } } impl Deref for TWI1 { type Target = twi1::RegisterBlock; #[inline(always)] fn deref(&self) -> &Self::Target { unsafe { &*Self::PTR } } } impl core::fmt::Debug for TWI1 { fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result { f.debug_struct("TWI1").finish() } } #[doc = "Two-wire Interface 1"] pub mod twi1; #[doc = "Pulse Width Modulation Controller"] pub struct PWM { _marker: PhantomData<*const ()>, } unsafe impl Send for PWM {} impl PWM { #[doc = r"Pointer to the register block"] pub const PTR: *const pwm::RegisterBlock = 0x4008_c000 as *const _; #[doc = r"Return the pointer to the register block"] #[inline(always)] pub const fn ptr() -> *const pwm::RegisterBlock { Self::PTR } #[doc = r" Steal an instance of this peripheral"] #[doc = r""] #[doc = r" # Safety"] #[doc = r""] #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"] #[doc = r" that may race with any existing instances, for example by only"] #[doc = r" accessing read-only or write-only registers, or by consuming the"] #[doc = r" original peripheral and using critical sections to coordinate"] #[doc = r" access between multiple new instances."] #[doc = r""] #[doc = r" Additionally, other software such as HALs may rely on only one"] #[doc = r" peripheral instance existing to ensure memory safety; ensure"] #[doc = r" no stolen instances are passed to such software."] pub unsafe fn steal() -> Self { Self { _marker: PhantomData, } } } impl Deref for PWM { type Target = pwm::RegisterBlock; #[inline(always)] fn deref(&self) -> &Self::Target { unsafe { &*Self::PTR } } } impl core::fmt::Debug for PWM { fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result { f.debug_struct("PWM").finish() } } #[doc = "Pulse Width Modulation Controller"] pub mod pwm; #[doc = "Universal Synchronous Asynchronous Receiver Transmitter 0"] 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 = 0x4009_0000 as *const _; #[doc = r"Return the pointer to the register block"] #[inline(always)] pub const fn ptr() -> *const usart0::RegisterBlock { Self::PTR } #[doc = r" Steal an instance of this peripheral"] #[doc = r""] #[doc = r" # Safety"] #[doc = r""] #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"] #[doc = r" that may race with any existing instances, for example by only"] #[doc = r" accessing read-only or write-only registers, or by consuming the"] #[doc = r" original peripheral and using critical sections to coordinate"] #[doc = r" access between multiple new instances."] #[doc = r""] #[doc = r" Additionally, other software such as HALs may rely on only one"] #[doc = r" peripheral instance existing to ensure memory safety; ensure"] #[doc = r" no stolen instances are passed to such software."] pub unsafe fn steal() -> Self { Self { _marker: PhantomData, } } } 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 0"] pub mod usart0; #[doc = "Universal Synchronous Asynchronous Receiver Transmitter 1"] pub struct USART1 { _marker: PhantomData<*const ()>, } unsafe impl Send for USART1 {} impl USART1 { #[doc = r"Pointer to the register block"] pub const PTR: *const usart1::RegisterBlock = 0x4009_4000 as *const _; #[doc = r"Return the pointer to the register block"] #[inline(always)] pub const fn ptr() -> *const usart1::RegisterBlock { Self::PTR } #[doc = r" Steal an instance of this peripheral"] #[doc = r""] #[doc = r" # Safety"] #[doc = r""] #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"] #[doc = r" that may race with any existing instances, for example by only"] #[doc = r" accessing read-only or write-only registers, or by consuming the"] #[doc = r" original peripheral and using critical sections to coordinate"] #[doc = r" access between multiple new instances."] #[doc = r""] #[doc = r" Additionally, other software such as HALs may rely on only one"] #[doc = r" peripheral instance existing to ensure memory safety; ensure"] #[doc = r" no stolen instances are passed to such software."] pub unsafe fn steal() -> Self { Self { _marker: PhantomData, } } } impl Deref for USART1 { type Target = usart1::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 1"] pub mod usart1; #[doc = "Universal Synchronous Asynchronous Receiver Transmitter 2"] pub struct USART2 { _marker: PhantomData<*const ()>, } unsafe impl Send for USART2 {} impl USART2 { #[doc = r"Pointer to the register block"] pub const PTR: *const usart2::RegisterBlock = 0x4009_8000 as *const _; #[doc = r"Return the pointer to the register block"] #[inline(always)] pub const fn ptr() -> *const usart2::RegisterBlock { Self::PTR } #[doc = r" Steal an instance of this peripheral"] #[doc = r""] #[doc = r" # Safety"] #[doc = r""] #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"] #[doc = r" that may race with any existing instances, for example by only"] #[doc = r" accessing read-only or write-only registers, or by consuming the"] #[doc = r" original peripheral and using critical sections to coordinate"] #[doc = r" access between multiple new instances."] #[doc = r""] #[doc = r" Additionally, other software such as HALs may rely on only one"] #[doc = r" peripheral instance existing to ensure memory safety; ensure"] #[doc = r" no stolen instances are passed to such software."] pub unsafe fn steal() -> Self { Self { _marker: PhantomData, } } } impl Deref for USART2 { type Target = usart2::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 2"] pub mod usart2; #[doc = "USB High Speed Device Port"] pub struct UDPHS { _marker: PhantomData<*const ()>, } unsafe impl Send for UDPHS {} impl UDPHS { #[doc = r"Pointer to the register block"] pub const PTR: *const udphs::RegisterBlock = 0x400a_4000 as *const _; #[doc = r"Return the pointer to the register block"] #[inline(always)] pub const fn ptr() -> *const udphs::RegisterBlock { Self::PTR } #[doc = r" Steal an instance of this peripheral"] #[doc = r""] #[doc = r" # Safety"] #[doc = r""] #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"] #[doc = r" that may race with any existing instances, for example by only"] #[doc = r" accessing read-only or write-only registers, or by consuming the"] #[doc = r" original peripheral and using critical sections to coordinate"] #[doc = r" access between multiple new instances."] #[doc = r""] #[doc = r" Additionally, other software such as HALs may rely on only one"] #[doc = r" peripheral instance existing to ensure memory safety; ensure"] #[doc = r" no stolen instances are passed to such software."] pub unsafe fn steal() -> Self { Self { _marker: PhantomData, } } } impl Deref for UDPHS { type Target = udphs::RegisterBlock; #[inline(always)] fn deref(&self) -> &Self::Target { unsafe { &*Self::PTR } } } impl core::fmt::Debug for UDPHS { fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result { f.debug_struct("UDPHS").finish() } } #[doc = "USB High Speed Device Port"] pub mod udphs; #[doc = "Analog-to-Digital Converter 12bits"] pub struct ADC12B { _marker: PhantomData<*const ()>, } unsafe impl Send for ADC12B {} impl ADC12B { #[doc = r"Pointer to the register block"] pub const PTR: *const adc12b::RegisterBlock = 0x400a_8000 as *const _; #[doc = r"Return the pointer to the register block"] #[inline(always)] pub const fn ptr() -> *const adc12b::RegisterBlock { Self::PTR } #[doc = r" Steal an instance of this peripheral"] #[doc = r""] #[doc = r" # Safety"] #[doc = r""] #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"] #[doc = r" that may race with any existing instances, for example by only"] #[doc = r" accessing read-only or write-only registers, or by consuming the"] #[doc = r" original peripheral and using critical sections to coordinate"] #[doc = r" access between multiple new instances."] #[doc = r""] #[doc = r" Additionally, other software such as HALs may rely on only one"] #[doc = r" peripheral instance existing to ensure memory safety; ensure"] #[doc = r" no stolen instances are passed to such software."] pub unsafe fn steal() -> Self { Self { _marker: PhantomData, } } } impl Deref for ADC12B { type Target = adc12b::RegisterBlock; #[inline(always)] fn deref(&self) -> &Self::Target { unsafe { &*Self::PTR } } } impl core::fmt::Debug for ADC12B { fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result { f.debug_struct("ADC12B").finish() } } #[doc = "Analog-to-Digital Converter 12bits"] pub mod adc12b; #[doc = "Analog-to-Digital Converter"] pub struct ADC { _marker: PhantomData<*const ()>, } unsafe impl Send for ADC {} impl ADC { #[doc = r"Pointer to the register block"] pub const PTR: *const adc::RegisterBlock = 0x400a_c000 as *const _; #[doc = r"Return the pointer to the register block"] #[inline(always)] pub const fn ptr() -> *const adc::RegisterBlock { Self::PTR } #[doc = r" Steal an instance of this peripheral"] #[doc = r""] #[doc = r" # Safety"] #[doc = r""] #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"] #[doc = r" that may race with any existing instances, for example by only"] #[doc = r" accessing read-only or write-only registers, or by consuming the"] #[doc = r" original peripheral and using critical sections to coordinate"] #[doc = r" access between multiple new instances."] #[doc = r""] #[doc = r" Additionally, other software such as HALs may rely on only one"] #[doc = r" peripheral instance existing to ensure memory safety; ensure"] #[doc = r" no stolen instances are passed to such software."] pub unsafe fn steal() -> Self { Self { _marker: PhantomData, } } } impl Deref for ADC { type Target = adc::RegisterBlock; #[inline(always)] fn deref(&self) -> &Self::Target { unsafe { &*Self::PTR } } } impl core::fmt::Debug for ADC { fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result { f.debug_struct("ADC").finish() } } #[doc = "Analog-to-Digital Converter"] pub mod adc; #[doc = "DMA Controller"] pub struct DMAC { _marker: PhantomData<*const ()>, } unsafe impl Send for DMAC {} impl DMAC { #[doc = r"Pointer to the register block"] pub const PTR: *const dmac::RegisterBlock = 0x400b_0000 as *const _; #[doc = r"Return the pointer to the register block"] #[inline(always)] pub const fn ptr() -> *const dmac::RegisterBlock { Self::PTR } #[doc = r" Steal an instance of this peripheral"] #[doc = r""] #[doc = r" # Safety"] #[doc = r""] #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"] #[doc = r" that may race with any existing instances, for example by only"] #[doc = r" accessing read-only or write-only registers, or by consuming the"] #[doc = r" original peripheral and using critical sections to coordinate"] #[doc = r" access between multiple new instances."] #[doc = r""] #[doc = r" Additionally, other software such as HALs may rely on only one"] #[doc = r" peripheral instance existing to ensure memory safety; ensure"] #[doc = r" no stolen instances are passed to such software."] pub unsafe fn steal() -> Self { Self { _marker: PhantomData, } } } impl Deref for DMAC { type Target = dmac::RegisterBlock; #[inline(always)] fn deref(&self) -> &Self::Target { unsafe { &*Self::PTR } } } impl core::fmt::Debug for DMAC { fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result { f.debug_struct("DMAC").finish() } } #[doc = "DMA Controller"] pub mod dmac; #[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 = 0x400e_0000 as *const _; #[doc = r"Return the pointer to the register block"] #[inline(always)] pub const fn ptr() -> *const smc::RegisterBlock { Self::PTR } #[doc = r" Steal an instance of this peripheral"] #[doc = r""] #[doc = r" # Safety"] #[doc = r""] #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"] #[doc = r" that may race with any existing instances, for example by only"] #[doc = r" accessing read-only or write-only registers, or by consuming the"] #[doc = r" original peripheral and using critical sections to coordinate"] #[doc = r" access between multiple new instances."] #[doc = r""] #[doc = r" Additionally, other software such as HALs may rely on only one"] #[doc = r" peripheral instance existing to ensure memory safety; ensure"] #[doc = r" no stolen instances are passed to such software."] pub unsafe fn steal() -> Self { Self { _marker: PhantomData, } } } 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 = "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 = 0x400e_0200 as *const _; #[doc = r"Return the pointer to the register block"] #[inline(always)] pub const fn ptr() -> *const matrix::RegisterBlock { Self::PTR } #[doc = r" Steal an instance of this peripheral"] #[doc = r""] #[doc = r" # Safety"] #[doc = r""] #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"] #[doc = r" that may race with any existing instances, for example by only"] #[doc = r" accessing read-only or write-only registers, or by consuming the"] #[doc = r" original peripheral and using critical sections to coordinate"] #[doc = r" access between multiple new instances."] #[doc = r""] #[doc = r" Additionally, other software such as HALs may rely on only one"] #[doc = r" peripheral instance existing to ensure memory safety; ensure"] #[doc = r" no stolen instances are passed to such software."] pub unsafe fn steal() -> Self { Self { _marker: PhantomData, } } } 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 = "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_0400 as *const _; #[doc = r"Return the pointer to the register block"] #[inline(always)] pub const fn ptr() -> *const pmc::RegisterBlock { Self::PTR } #[doc = r" Steal an instance of this peripheral"] #[doc = r""] #[doc = r" # Safety"] #[doc = r""] #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"] #[doc = r" that may race with any existing instances, for example by only"] #[doc = r" accessing read-only or write-only registers, or by consuming the"] #[doc = r" original peripheral and using critical sections to coordinate"] #[doc = r" access between multiple new instances."] #[doc = r""] #[doc = r" Additionally, other software such as HALs may rely on only one"] #[doc = r" peripheral instance existing to ensure memory safety; ensure"] #[doc = r" no stolen instances are passed to such software."] pub unsafe fn steal() -> Self { Self { _marker: PhantomData, } } } 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 = "Universal Asynchronous Receiver Transmitter"] pub struct UART { _marker: PhantomData<*const ()>, } unsafe impl Send for UART {} impl UART { #[doc = r"Pointer to the register block"] pub const PTR: *const uart::RegisterBlock = 0x400e_0600 as *const _; #[doc = r"Return the pointer to the register block"] #[inline(always)] pub const fn ptr() -> *const uart::RegisterBlock { Self::PTR } #[doc = r" Steal an instance of this peripheral"] #[doc = r""] #[doc = r" # Safety"] #[doc = r""] #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"] #[doc = r" that may race with any existing instances, for example by only"] #[doc = r" accessing read-only or write-only registers, or by consuming the"] #[doc = r" original peripheral and using critical sections to coordinate"] #[doc = r" access between multiple new instances."] #[doc = r""] #[doc = r" Additionally, other software such as HALs may rely on only one"] #[doc = r" peripheral instance existing to ensure memory safety; ensure"] #[doc = r" no stolen instances are passed to such software."] pub unsafe fn steal() -> Self { Self { _marker: PhantomData, } } } impl Deref for UART { type Target = uart::RegisterBlock; #[inline(always)] fn deref(&self) -> &Self::Target { unsafe { &*Self::PTR } } } impl core::fmt::Debug for UART { fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result { f.debug_struct("UART").finish() } } #[doc = "Universal Asynchronous Receiver Transmitter"] pub mod uart; #[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_0740 as *const _; #[doc = r"Return the pointer to the register block"] #[inline(always)] pub const fn ptr() -> *const chipid::RegisterBlock { Self::PTR } #[doc = r" Steal an instance of this peripheral"] #[doc = r""] #[doc = r" # Safety"] #[doc = r""] #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"] #[doc = r" that may race with any existing instances, for example by only"] #[doc = r" accessing read-only or write-only registers, or by consuming the"] #[doc = r" original peripheral and using critical sections to coordinate"] #[doc = r" access between multiple new instances."] #[doc = r""] #[doc = r" Additionally, other software such as HALs may rely on only one"] #[doc = r" peripheral instance existing to ensure memory safety; ensure"] #[doc = r" no stolen instances are passed to such software."] pub unsafe fn steal() -> Self { Self { _marker: PhantomData, } } } 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 = "Embedded Flash Controller 0"] pub struct EFC0 { _marker: PhantomData<*const ()>, } unsafe impl Send for EFC0 {} impl EFC0 { #[doc = r"Pointer to the register block"] pub const PTR: *const efc0::RegisterBlock = 0x400e_0800 as *const _; #[doc = r"Return the pointer to the register block"] #[inline(always)] pub const fn ptr() -> *const efc0::RegisterBlock { Self::PTR } #[doc = r" Steal an instance of this peripheral"] #[doc = r""] #[doc = r" # Safety"] #[doc = r""] #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"] #[doc = r" that may race with any existing instances, for example by only"] #[doc = r" accessing read-only or write-only registers, or by consuming the"] #[doc = r" original peripheral and using critical sections to coordinate"] #[doc = r" access between multiple new instances."] #[doc = r""] #[doc = r" Additionally, other software such as HALs may rely on only one"] #[doc = r" peripheral instance existing to ensure memory safety; ensure"] #[doc = r" no stolen instances are passed to such software."] pub unsafe fn steal() -> Self { Self { _marker: PhantomData, } } } impl Deref for EFC0 { type Target = efc0::RegisterBlock; #[inline(always)] fn deref(&self) -> &Self::Target { unsafe { &*Self::PTR } } } impl core::fmt::Debug for EFC0 { fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result { f.debug_struct("EFC0").finish() } } #[doc = "Embedded Flash Controller 0"] pub mod efc0; #[doc = "Parallel Input/Output Controller A"] 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_0c00 as *const _; #[doc = r"Return the pointer to the register block"] #[inline(always)] pub const fn ptr() -> *const pioa::RegisterBlock { Self::PTR } #[doc = r" Steal an instance of this peripheral"] #[doc = r""] #[doc = r" # Safety"] #[doc = r""] #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"] #[doc = r" that may race with any existing instances, for example by only"] #[doc = r" accessing read-only or write-only registers, or by consuming the"] #[doc = r" original peripheral and using critical sections to coordinate"] #[doc = r" access between multiple new instances."] #[doc = r""] #[doc = r" Additionally, other software such as HALs may rely on only one"] #[doc = r" peripheral instance existing to ensure memory safety; ensure"] #[doc = r" no stolen instances are passed to such software."] pub unsafe fn steal() -> Self { Self { _marker: PhantomData, } } } 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 A"] pub mod pioa; #[doc = "Parallel Input/Output Controller B"] pub struct PIOB { _marker: PhantomData<*const ()>, } unsafe impl Send for PIOB {} impl PIOB { #[doc = r"Pointer to the register block"] pub const PTR: *const piob::RegisterBlock = 0x400e_0e00 as *const _; #[doc = r"Return the pointer to the register block"] #[inline(always)] pub const fn ptr() -> *const piob::RegisterBlock { Self::PTR } #[doc = r" Steal an instance of this peripheral"] #[doc = r""] #[doc = r" # Safety"] #[doc = r""] #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"] #[doc = r" that may race with any existing instances, for example by only"] #[doc = r" accessing read-only or write-only registers, or by consuming the"] #[doc = r" original peripheral and using critical sections to coordinate"] #[doc = r" access between multiple new instances."] #[doc = r""] #[doc = r" Additionally, other software such as HALs may rely on only one"] #[doc = r" peripheral instance existing to ensure memory safety; ensure"] #[doc = r" no stolen instances are passed to such software."] pub unsafe fn steal() -> Self { Self { _marker: PhantomData, } } } impl Deref for PIOB { type Target = piob::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 B"] pub mod piob; #[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_1200 as *const _; #[doc = r"Return the pointer to the register block"] #[inline(always)] pub const fn ptr() -> *const rstc::RegisterBlock { Self::PTR } #[doc = r" Steal an instance of this peripheral"] #[doc = r""] #[doc = r" # Safety"] #[doc = r""] #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"] #[doc = r" that may race with any existing instances, for example by only"] #[doc = r" accessing read-only or write-only registers, or by consuming the"] #[doc = r" original peripheral and using critical sections to coordinate"] #[doc = r" access between multiple new instances."] #[doc = r""] #[doc = r" Additionally, other software such as HALs may rely on only one"] #[doc = r" peripheral instance existing to ensure memory safety; ensure"] #[doc = r" no stolen instances are passed to such software."] pub unsafe fn steal() -> Self { Self { _marker: PhantomData, } } } 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 = "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_1210 as *const _; #[doc = r"Return the pointer to the register block"] #[inline(always)] pub const fn ptr() -> *const supc::RegisterBlock { Self::PTR } #[doc = r" Steal an instance of this peripheral"] #[doc = r""] #[doc = r" # Safety"] #[doc = r""] #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"] #[doc = r" that may race with any existing instances, for example by only"] #[doc = r" accessing read-only or write-only registers, or by consuming the"] #[doc = r" original peripheral and using critical sections to coordinate"] #[doc = r" access between multiple new instances."] #[doc = r""] #[doc = r" Additionally, other software such as HALs may rely on only one"] #[doc = r" peripheral instance existing to ensure memory safety; ensure"] #[doc = r" no stolen instances are passed to such software."] pub unsafe fn steal() -> Self { Self { _marker: PhantomData, } } } 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 = "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_1230 as *const _; #[doc = r"Return the pointer to the register block"] #[inline(always)] pub const fn ptr() -> *const rtt::RegisterBlock { Self::PTR } #[doc = r" Steal an instance of this peripheral"] #[doc = r""] #[doc = r" # Safety"] #[doc = r""] #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"] #[doc = r" that may race with any existing instances, for example by only"] #[doc = r" accessing read-only or write-only registers, or by consuming the"] #[doc = r" original peripheral and using critical sections to coordinate"] #[doc = r" access between multiple new instances."] #[doc = r""] #[doc = r" Additionally, other software such as HALs may rely on only one"] #[doc = r" peripheral instance existing to ensure memory safety; ensure"] #[doc = r" no stolen instances are passed to such software."] pub unsafe fn steal() -> Self { Self { _marker: PhantomData, } } } 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 = "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_1250 as *const _; #[doc = r"Return the pointer to the register block"] #[inline(always)] pub const fn ptr() -> *const wdt::RegisterBlock { Self::PTR } #[doc = r" Steal an instance of this peripheral"] #[doc = r""] #[doc = r" # Safety"] #[doc = r""] #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"] #[doc = r" that may race with any existing instances, for example by only"] #[doc = r" accessing read-only or write-only registers, or by consuming the"] #[doc = r" original peripheral and using critical sections to coordinate"] #[doc = r" access between multiple new instances."] #[doc = r""] #[doc = r" Additionally, other software such as HALs may rely on only one"] #[doc = r" peripheral instance existing to ensure memory safety; ensure"] #[doc = r" no stolen instances are passed to such software."] pub unsafe fn steal() -> Self { Self { _marker: PhantomData, } } } 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 = "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_1260 as *const _; #[doc = r"Return the pointer to the register block"] #[inline(always)] pub const fn ptr() -> *const rtc::RegisterBlock { Self::PTR } #[doc = r" Steal an instance of this peripheral"] #[doc = r""] #[doc = r" # Safety"] #[doc = r""] #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"] #[doc = r" that may race with any existing instances, for example by only"] #[doc = r" accessing read-only or write-only registers, or by consuming the"] #[doc = r" original peripheral and using critical sections to coordinate"] #[doc = r" access between multiple new instances."] #[doc = r""] #[doc = r" Additionally, other software such as HALs may rely on only one"] #[doc = r" peripheral instance existing to ensure memory safety; ensure"] #[doc = r" no stolen instances are passed to such software."] pub unsafe fn steal() -> Self { Self { _marker: PhantomData, } } } 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 = "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_1290 as *const _; #[doc = r"Return the pointer to the register block"] #[inline(always)] pub const fn ptr() -> *const gpbr::RegisterBlock { Self::PTR } #[doc = r" Steal an instance of this peripheral"] #[doc = r""] #[doc = r" # Safety"] #[doc = r""] #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"] #[doc = r" that may race with any existing instances, for example by only"] #[doc = r" accessing read-only or write-only registers, or by consuming the"] #[doc = r" original peripheral and using critical sections to coordinate"] #[doc = r" access between multiple new instances."] #[doc = r""] #[doc = r" Additionally, other software such as HALs may rely on only one"] #[doc = r" peripheral instance existing to ensure memory safety; ensure"] #[doc = r" no stolen instances are passed to such software."] pub unsafe fn steal() -> Self { Self { _marker: PhantomData, } } } 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; #[no_mangle] static mut DEVICE_PERIPHERALS: bool = false; #[doc = r" All the peripherals."] #[allow(non_snake_case)] pub struct Peripherals { #[doc = "HSMCI"] pub HSMCI: HSMCI, #[doc = "SSC"] pub SSC: SSC, #[doc = "SPI"] pub SPI: SPI, #[doc = "TC0"] pub TC0: TC0, #[doc = "TWI0"] pub TWI0: TWI0, #[doc = "TWI1"] pub TWI1: TWI1, #[doc = "PWM"] pub PWM: PWM, #[doc = "USART0"] pub USART0: USART0, #[doc = "USART1"] pub USART1: USART1, #[doc = "USART2"] pub USART2: USART2, #[doc = "UDPHS"] pub UDPHS: UDPHS, #[doc = "ADC12B"] pub ADC12B: ADC12B, #[doc = "ADC"] pub ADC: ADC, #[doc = "DMAC"] pub DMAC: DMAC, #[doc = "SMC"] pub SMC: SMC, #[doc = "MATRIX"] pub MATRIX: MATRIX, #[doc = "PMC"] pub PMC: PMC, #[doc = "UART"] pub UART: UART, #[doc = "CHIPID"] pub CHIPID: CHIPID, #[doc = "EFC0"] pub EFC0: EFC0, #[doc = "PIOA"] pub PIOA: PIOA, #[doc = "PIOB"] pub PIOB: PIOB, #[doc = "RSTC"] pub RSTC: RSTC, #[doc = "SUPC"] pub SUPC: SUPC, #[doc = "RTT"] pub RTT: RTT, #[doc = "WDT"] pub WDT: WDT, #[doc = "RTC"] pub RTC: RTC, #[doc = "GPBR"] pub GPBR: GPBR, } impl Peripherals { #[doc = r" Returns all the peripherals *once*."] #[cfg(feature = "critical-section")] #[inline] pub fn take() -> Option { 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 { HSMCI: HSMCI { _marker: PhantomData, }, SSC: SSC { _marker: PhantomData, }, SPI: SPI { _marker: PhantomData, }, TC0: TC0 { _marker: PhantomData, }, TWI0: TWI0 { _marker: PhantomData, }, TWI1: TWI1 { _marker: PhantomData, }, PWM: PWM { _marker: PhantomData, }, USART0: USART0 { _marker: PhantomData, }, USART1: USART1 { _marker: PhantomData, }, USART2: USART2 { _marker: PhantomData, }, UDPHS: UDPHS { _marker: PhantomData, }, ADC12B: ADC12B { _marker: PhantomData, }, ADC: ADC { _marker: PhantomData, }, DMAC: DMAC { _marker: PhantomData, }, SMC: SMC { _marker: PhantomData, }, MATRIX: MATRIX { _marker: PhantomData, }, PMC: PMC { _marker: PhantomData, }, UART: UART { _marker: PhantomData, }, CHIPID: CHIPID { _marker: PhantomData, }, EFC0: EFC0 { _marker: PhantomData, }, PIOA: PIOA { _marker: PhantomData, }, PIOB: PIOB { _marker: PhantomData, }, RSTC: RSTC { _marker: PhantomData, }, SUPC: SUPC { _marker: PhantomData, }, RTT: RTT { _marker: PhantomData, }, WDT: WDT { _marker: PhantomData, }, RTC: RTC { _marker: PhantomData, }, GPBR: GPBR { _marker: PhantomData, }, } } }