summaryrefslogtreecommitdiff
path: root/src/lib.rs
diff options
context:
space:
mode:
Diffstat (limited to 'src/lib.rs')
-rw-r--r--src/lib.rs1836
1 files changed, 1836 insertions, 0 deletions
diff --git a/src/lib.rs b/src/lib.rs
new file mode 100644
index 0000000..dc48ca2
--- /dev/null
+++ b/src/lib.rs
@@ -0,0 +1,1836 @@
+#![doc = "Peripheral access API for ATSAMC21N18A microcontrollers (generated using svd2rust v0.19.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.19.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 = 2;
+#[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, 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 WDT();
+ fn RTC();
+ fn EIC();
+ fn FREQM();
+ fn TSENS();
+ fn NVMCTRL();
+ fn DMAC();
+ fn EVSYS();
+ fn SERCOM2();
+ fn SERCOM3();
+ fn SERCOM4();
+ fn SERCOM5();
+ fn CAN0();
+ fn CAN1();
+ fn TCC0();
+ fn TCC1();
+ fn TCC2();
+ fn TC3();
+ fn TC4();
+ fn ADC0();
+ fn ADC1();
+ fn AC();
+ fn DAC();
+ fn SDADC();
+ fn PTC();
+}
+#[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; 31] = [
+ Vector { _reserved: 0 },
+ Vector { _handler: WDT },
+ Vector { _handler: RTC },
+ Vector { _handler: EIC },
+ Vector { _handler: FREQM },
+ Vector { _handler: TSENS },
+ Vector { _handler: NVMCTRL },
+ Vector { _handler: DMAC },
+ Vector { _handler: EVSYS },
+ Vector { _reserved: 0 },
+ Vector { _reserved: 0 },
+ Vector { _handler: SERCOM2 },
+ Vector { _handler: SERCOM3 },
+ Vector { _handler: SERCOM4 },
+ Vector { _handler: SERCOM5 },
+ Vector { _handler: CAN0 },
+ Vector { _handler: CAN1 },
+ Vector { _handler: TCC0 },
+ Vector { _handler: TCC1 },
+ Vector { _handler: TCC2 },
+ Vector { _reserved: 0 },
+ Vector { _reserved: 0 },
+ Vector { _reserved: 0 },
+ Vector { _handler: TC3 },
+ Vector { _handler: TC4 },
+ Vector { _handler: ADC0 },
+ Vector { _handler: ADC1 },
+ Vector { _handler: AC },
+ Vector { _handler: DAC },
+ Vector { _handler: SDADC },
+ Vector { _handler: PTC },
+];
+#[doc = r"Enumeration of all the interrupts."]
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+#[repr(u16)]
+pub enum Interrupt {
+ #[doc = "1 - WDT"]
+ WDT = 1,
+ #[doc = "2 - RTC"]
+ RTC = 2,
+ #[doc = "3 - EIC"]
+ EIC = 3,
+ #[doc = "4 - FREQM"]
+ FREQM = 4,
+ #[doc = "5 - TSENS"]
+ TSENS = 5,
+ #[doc = "6 - NVMCTRL"]
+ NVMCTRL = 6,
+ #[doc = "7 - DMAC"]
+ DMAC = 7,
+ #[doc = "8 - EVSYS"]
+ EVSYS = 8,
+ #[doc = "11 - SERCOM2"]
+ SERCOM2 = 11,
+ #[doc = "12 - SERCOM3"]
+ SERCOM3 = 12,
+ #[doc = "13 - SERCOM4"]
+ SERCOM4 = 13,
+ #[doc = "14 - SERCOM5"]
+ SERCOM5 = 14,
+ #[doc = "15 - CAN0"]
+ CAN0 = 15,
+ #[doc = "16 - CAN1"]
+ CAN1 = 16,
+ #[doc = "17 - TCC0"]
+ TCC0 = 17,
+ #[doc = "18 - TCC1"]
+ TCC1 = 18,
+ #[doc = "19 - TCC2"]
+ TCC2 = 19,
+ #[doc = "23 - TC3"]
+ TC3 = 23,
+ #[doc = "24 - TC4"]
+ TC4 = 24,
+ #[doc = "25 - ADC0"]
+ ADC0 = 25,
+ #[doc = "26 - ADC1"]
+ ADC1 = 26,
+ #[doc = "27 - AC"]
+ AC = 27,
+ #[doc = "28 - DAC"]
+ DAC = 28,
+ #[doc = "29 - SDADC"]
+ SDADC = 29,
+ #[doc = "30 - PTC"]
+ PTC = 30,
+}
+unsafe impl cortex_m::interrupt::InterruptNumber for Interrupt {
+ #[inline(always)]
+ fn number(self) -> u16 {
+ self as u16
+ }
+}
+#[doc = "Analog Comparators"]
+pub struct AC {
+ _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for AC {}
+impl AC {
+ #[doc = r"Pointer to the register block"]
+ pub const PTR: *const ac::RegisterBlock = 0x4200_5000 as *const _;
+ #[doc = r"Return the pointer to the register block"]
+ #[inline(always)]
+ pub const fn ptr() -> *const ac::RegisterBlock {
+ Self::PTR
+ }
+}
+impl Deref for AC {
+ type Target = ac::RegisterBlock;
+ #[inline(always)]
+ fn deref(&self) -> &Self::Target {
+ unsafe { &*Self::PTR }
+ }
+}
+impl core::fmt::Debug for AC {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ f.debug_struct("AC").finish()
+ }
+}
+#[doc = "Analog Comparators"]
+pub mod ac;
+#[doc = "Analog Digital Converter"]
+pub struct ADC0 {
+ _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for ADC0 {}
+impl ADC0 {
+ #[doc = r"Pointer to the register block"]
+ pub const PTR: *const adc0::RegisterBlock = 0x4200_4400 as *const _;
+ #[doc = r"Return the pointer to the register block"]
+ #[inline(always)]
+ pub const fn ptr() -> *const adc0::RegisterBlock {
+ Self::PTR
+ }
+}
+impl Deref for ADC0 {
+ type Target = adc0::RegisterBlock;
+ #[inline(always)]
+ fn deref(&self) -> &Self::Target {
+ unsafe { &*Self::PTR }
+ }
+}
+impl core::fmt::Debug for ADC0 {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ f.debug_struct("ADC0").finish()
+ }
+}
+#[doc = "Analog Digital Converter"]
+pub mod adc0;
+#[doc = "Analog Digital Converter"]
+pub struct ADC1 {
+ _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for ADC1 {}
+impl ADC1 {
+ #[doc = r"Pointer to the register block"]
+ pub const PTR: *const adc0::RegisterBlock = 0x4200_4800 as *const _;
+ #[doc = r"Return the pointer to the register block"]
+ #[inline(always)]
+ pub const fn ptr() -> *const adc0::RegisterBlock {
+ Self::PTR
+ }
+}
+impl Deref for ADC1 {
+ type Target = adc0::RegisterBlock;
+ #[inline(always)]
+ fn deref(&self) -> &Self::Target {
+ unsafe { &*Self::PTR }
+ }
+}
+impl core::fmt::Debug for ADC1 {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ f.debug_struct("ADC1").finish()
+ }
+}
+#[doc = "Control Area Network"]
+pub struct CAN0 {
+ _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for CAN0 {}
+impl CAN0 {
+ #[doc = r"Pointer to the register block"]
+ pub const PTR: *const can0::RegisterBlock = 0x4200_1c00 as *const _;
+ #[doc = r"Return the pointer to the register block"]
+ #[inline(always)]
+ pub const fn ptr() -> *const can0::RegisterBlock {
+ Self::PTR
+ }
+}
+impl Deref for CAN0 {
+ type Target = can0::RegisterBlock;
+ #[inline(always)]
+ fn deref(&self) -> &Self::Target {
+ unsafe { &*Self::PTR }
+ }
+}
+impl core::fmt::Debug for CAN0 {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ f.debug_struct("CAN0").finish()
+ }
+}
+#[doc = "Control Area Network"]
+pub mod can0;
+#[doc = "Control Area Network"]
+pub struct CAN1 {
+ _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for CAN1 {}
+impl CAN1 {
+ #[doc = r"Pointer to the register block"]
+ pub const PTR: *const can0::RegisterBlock = 0x4200_2000 as *const _;
+ #[doc = r"Return the pointer to the register block"]
+ #[inline(always)]
+ pub const fn ptr() -> *const can0::RegisterBlock {
+ Self::PTR
+ }
+}
+impl Deref for CAN1 {
+ type Target = can0::RegisterBlock;
+ #[inline(always)]
+ fn deref(&self) -> &Self::Target {
+ unsafe { &*Self::PTR }
+ }
+}
+impl core::fmt::Debug for CAN1 {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ f.debug_struct("CAN1").finish()
+ }
+}
+#[doc = "Configurable Custom Logic"]
+pub struct CCL {
+ _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for CCL {}
+impl CCL {
+ #[doc = r"Pointer to the register block"]
+ pub const PTR: *const ccl::RegisterBlock = 0x4200_5c00 as *const _;
+ #[doc = r"Return the pointer to the register block"]
+ #[inline(always)]
+ pub const fn ptr() -> *const ccl::RegisterBlock {
+ Self::PTR
+ }
+}
+impl Deref for CCL {
+ type Target = ccl::RegisterBlock;
+ #[inline(always)]
+ fn deref(&self) -> &Self::Target {
+ unsafe { &*Self::PTR }
+ }
+}
+impl core::fmt::Debug for CCL {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ f.debug_struct("CCL").finish()
+ }
+}
+#[doc = "Configurable Custom Logic"]
+pub mod ccl;
+#[doc = "Digital Analog Converter"]
+pub struct DAC {
+ _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for DAC {}
+impl DAC {
+ #[doc = r"Pointer to the register block"]
+ pub const PTR: *const dac::RegisterBlock = 0x4200_5400 as *const _;
+ #[doc = r"Return the pointer to the register block"]
+ #[inline(always)]
+ pub const fn ptr() -> *const dac::RegisterBlock {
+ Self::PTR
+ }
+}
+impl Deref for DAC {
+ type Target = dac::RegisterBlock;
+ #[inline(always)]
+ fn deref(&self) -> &Self::Target {
+ unsafe { &*Self::PTR }
+ }
+}
+impl core::fmt::Debug for DAC {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ f.debug_struct("DAC").finish()
+ }
+}
+#[doc = "Digital Analog Converter"]
+pub mod dac;
+#[doc = "Divide and Square Root Accelerator"]
+pub struct DIVAS {
+ _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for DIVAS {}
+impl DIVAS {
+ #[doc = r"Pointer to the register block"]
+ pub const PTR: *const divas::RegisterBlock = 0x4800_0000 as *const _;
+ #[doc = r"Return the pointer to the register block"]
+ #[inline(always)]
+ pub const fn ptr() -> *const divas::RegisterBlock {
+ Self::PTR
+ }
+}
+impl Deref for DIVAS {
+ type Target = divas::RegisterBlock;
+ #[inline(always)]
+ fn deref(&self) -> &Self::Target {
+ unsafe { &*Self::PTR }
+ }
+}
+impl core::fmt::Debug for DIVAS {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ f.debug_struct("DIVAS").finish()
+ }
+}
+#[doc = "Divide and Square Root Accelerator"]
+pub mod divas;
+#[doc = "Direct Memory Access 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 = 0x4100_6000 as *const _;
+ #[doc = r"Return the pointer to the register block"]
+ #[inline(always)]
+ pub const fn ptr() -> *const dmac::RegisterBlock {
+ Self::PTR
+ }
+}
+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 = "Direct Memory Access Controller"]
+pub mod dmac;
+#[doc = "Device Service Unit"]
+pub struct DSU {
+ _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for DSU {}
+impl DSU {
+ #[doc = r"Pointer to the register block"]
+ pub const PTR: *const dsu::RegisterBlock = 0x4100_2000 as *const _;
+ #[doc = r"Return the pointer to the register block"]
+ #[inline(always)]
+ pub const fn ptr() -> *const dsu::RegisterBlock {
+ Self::PTR
+ }
+}
+impl Deref for DSU {
+ type Target = dsu::RegisterBlock;
+ #[inline(always)]
+ fn deref(&self) -> &Self::Target {
+ unsafe { &*Self::PTR }
+ }
+}
+impl core::fmt::Debug for DSU {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ f.debug_struct("DSU").finish()
+ }
+}
+#[doc = "Device Service Unit"]
+pub mod dsu;
+#[doc = "External Interrupt Controller"]
+pub struct EIC {
+ _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for EIC {}
+impl EIC {
+ #[doc = r"Pointer to the register block"]
+ pub const PTR: *const eic::RegisterBlock = 0x4000_2800 as *const _;
+ #[doc = r"Return the pointer to the register block"]
+ #[inline(always)]
+ pub const fn ptr() -> *const eic::RegisterBlock {
+ Self::PTR
+ }
+}
+impl Deref for EIC {
+ type Target = eic::RegisterBlock;
+ #[inline(always)]
+ fn deref(&self) -> &Self::Target {
+ unsafe { &*Self::PTR }
+ }
+}
+impl core::fmt::Debug for EIC {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ f.debug_struct("EIC").finish()
+ }
+}
+#[doc = "External Interrupt Controller"]
+pub mod eic;
+#[doc = "Event System Interface"]
+pub struct EVSYS {
+ _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for EVSYS {}
+impl EVSYS {
+ #[doc = r"Pointer to the register block"]
+ pub const PTR: *const evsys::RegisterBlock = 0x4200_0000 as *const _;
+ #[doc = r"Return the pointer to the register block"]
+ #[inline(always)]
+ pub const fn ptr() -> *const evsys::RegisterBlock {
+ Self::PTR
+ }
+}
+impl Deref for EVSYS {
+ type Target = evsys::RegisterBlock;
+ #[inline(always)]
+ fn deref(&self) -> &Self::Target {
+ unsafe { &*Self::PTR }
+ }
+}
+impl core::fmt::Debug for EVSYS {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ f.debug_struct("EVSYS").finish()
+ }
+}
+#[doc = "Event System Interface"]
+pub mod evsys;
+#[doc = "Frequency Meter"]
+pub struct FREQM {
+ _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for FREQM {}
+impl FREQM {
+ #[doc = r"Pointer to the register block"]
+ pub const PTR: *const freqm::RegisterBlock = 0x4000_2c00 as *const _;
+ #[doc = r"Return the pointer to the register block"]
+ #[inline(always)]
+ pub const fn ptr() -> *const freqm::RegisterBlock {
+ Self::PTR
+ }
+}
+impl Deref for FREQM {
+ type Target = freqm::RegisterBlock;
+ #[inline(always)]
+ fn deref(&self) -> &Self::Target {
+ unsafe { &*Self::PTR }
+ }
+}
+impl core::fmt::Debug for FREQM {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ f.debug_struct("FREQM").finish()
+ }
+}
+#[doc = "Frequency Meter"]
+pub mod freqm;
+#[doc = "Generic Clock Generator"]
+pub struct GCLK {
+ _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for GCLK {}
+impl GCLK {
+ #[doc = r"Pointer to the register block"]
+ pub const PTR: *const gclk::RegisterBlock = 0x4000_1c00 as *const _;
+ #[doc = r"Return the pointer to the register block"]
+ #[inline(always)]
+ pub const fn ptr() -> *const gclk::RegisterBlock {
+ Self::PTR
+ }
+}
+impl Deref for GCLK {
+ type Target = gclk::RegisterBlock;
+ #[inline(always)]
+ fn deref(&self) -> &Self::Target {
+ unsafe { &*Self::PTR }
+ }
+}
+impl core::fmt::Debug for GCLK {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ f.debug_struct("GCLK").finish()
+ }
+}
+#[doc = "Generic Clock Generator"]
+pub mod gclk;
+#[doc = "HSB Matrix"]
+pub struct HMATRIXHS {
+ _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for HMATRIXHS {}
+impl HMATRIXHS {
+ #[doc = r"Pointer to the register block"]
+ pub const PTR: *const hmatrixhs::RegisterBlock = 0x4100_a000 as *const _;
+ #[doc = r"Return the pointer to the register block"]
+ #[inline(always)]
+ pub const fn ptr() -> *const hmatrixhs::RegisterBlock {
+ Self::PTR
+ }
+}
+impl Deref for HMATRIXHS {
+ type Target = hmatrixhs::RegisterBlock;
+ #[inline(always)]
+ fn deref(&self) -> &Self::Target {
+ unsafe { &*Self::PTR }
+ }
+}
+impl core::fmt::Debug for HMATRIXHS {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ f.debug_struct("HMATRIXHS").finish()
+ }
+}
+#[doc = "HSB Matrix"]
+pub mod hmatrixhs;
+#[doc = "Main Clock"]
+pub struct MCLK {
+ _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for MCLK {}
+impl MCLK {
+ #[doc = r"Pointer to the register block"]
+ pub const PTR: *const mclk::RegisterBlock = 0x4000_0800 as *const _;
+ #[doc = r"Return the pointer to the register block"]
+ #[inline(always)]
+ pub const fn ptr() -> *const mclk::RegisterBlock {
+ Self::PTR
+ }
+}
+impl Deref for MCLK {
+ type Target = mclk::RegisterBlock;
+ #[inline(always)]
+ fn deref(&self) -> &Self::Target {
+ unsafe { &*Self::PTR }
+ }
+}
+impl core::fmt::Debug for MCLK {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ f.debug_struct("MCLK").finish()
+ }
+}
+#[doc = "Main Clock"]
+pub mod mclk;
+#[doc = "Cortex-M0+ Micro-Trace Buffer"]
+pub struct MTB {
+ _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for MTB {}
+impl MTB {
+ #[doc = r"Pointer to the register block"]
+ pub const PTR: *const mtb::RegisterBlock = 0x4100_8000 as *const _;
+ #[doc = r"Return the pointer to the register block"]
+ #[inline(always)]
+ pub const fn ptr() -> *const mtb::RegisterBlock {
+ Self::PTR
+ }
+}
+impl Deref for MTB {
+ type Target = mtb::RegisterBlock;
+ #[inline(always)]
+ fn deref(&self) -> &Self::Target {
+ unsafe { &*Self::PTR }
+ }
+}
+impl core::fmt::Debug for MTB {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ f.debug_struct("MTB").finish()
+ }
+}
+#[doc = "Cortex-M0+ Micro-Trace Buffer"]
+pub mod mtb;
+#[doc = "Non-Volatile Memory Controller"]
+pub struct NVMCTRL {
+ _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for NVMCTRL {}
+impl NVMCTRL {
+ #[doc = r"Pointer to the register block"]
+ pub const PTR: *const nvmctrl::RegisterBlock = 0x4100_4000 as *const _;
+ #[doc = r"Return the pointer to the register block"]
+ #[inline(always)]
+ pub const fn ptr() -> *const nvmctrl::RegisterBlock {
+ Self::PTR
+ }
+}
+impl Deref for NVMCTRL {
+ type Target = nvmctrl::RegisterBlock;
+ #[inline(always)]
+ fn deref(&self) -> &Self::Target {
+ unsafe { &*Self::PTR }
+ }
+}
+impl core::fmt::Debug for NVMCTRL {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ f.debug_struct("NVMCTRL").finish()
+ }
+}
+#[doc = "Non-Volatile Memory Controller"]
+pub mod nvmctrl;
+#[doc = "Oscillators Control"]
+pub struct OSCCTRL {
+ _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for OSCCTRL {}
+impl OSCCTRL {
+ #[doc = r"Pointer to the register block"]
+ pub const PTR: *const oscctrl::RegisterBlock = 0x4000_1000 as *const _;
+ #[doc = r"Return the pointer to the register block"]
+ #[inline(always)]
+ pub const fn ptr() -> *const oscctrl::RegisterBlock {
+ Self::PTR
+ }
+}
+impl Deref for OSCCTRL {
+ type Target = oscctrl::RegisterBlock;
+ #[inline(always)]
+ fn deref(&self) -> &Self::Target {
+ unsafe { &*Self::PTR }
+ }
+}
+impl core::fmt::Debug for OSCCTRL {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ f.debug_struct("OSCCTRL").finish()
+ }
+}
+#[doc = "Oscillators Control"]
+pub mod oscctrl;
+#[doc = "32k Oscillators Control"]
+pub struct OSC32KCTRL {
+ _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for OSC32KCTRL {}
+impl OSC32KCTRL {
+ #[doc = r"Pointer to the register block"]
+ pub const PTR: *const osc32kctrl::RegisterBlock = 0x4000_1400 as *const _;
+ #[doc = r"Return the pointer to the register block"]
+ #[inline(always)]
+ pub const fn ptr() -> *const osc32kctrl::RegisterBlock {
+ Self::PTR
+ }
+}
+impl Deref for OSC32KCTRL {
+ type Target = osc32kctrl::RegisterBlock;
+ #[inline(always)]
+ fn deref(&self) -> &Self::Target {
+ unsafe { &*Self::PTR }
+ }
+}
+impl core::fmt::Debug for OSC32KCTRL {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ f.debug_struct("OSC32KCTRL").finish()
+ }
+}
+#[doc = "32k Oscillators Control"]
+pub mod osc32kctrl;
+#[doc = "Peripheral Access Controller"]
+pub struct PAC {
+ _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for PAC {}
+impl PAC {
+ #[doc = r"Pointer to the register block"]
+ pub const PTR: *const pac::RegisterBlock = 0x4000_0000 as *const _;
+ #[doc = r"Return the pointer to the register block"]
+ #[inline(always)]
+ pub const fn ptr() -> *const pac::RegisterBlock {
+ Self::PTR
+ }
+}
+impl Deref for PAC {
+ type Target = pac::RegisterBlock;
+ #[inline(always)]
+ fn deref(&self) -> &Self::Target {
+ unsafe { &*Self::PTR }
+ }
+}
+impl core::fmt::Debug for PAC {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ f.debug_struct("PAC").finish()
+ }
+}
+#[doc = "Peripheral Access Controller"]
+pub mod pac;
+#[doc = "Power Manager"]
+pub struct PM {
+ _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for PM {}
+impl PM {
+ #[doc = r"Pointer to the register block"]
+ pub const PTR: *const pm::RegisterBlock = 0x4000_0400 as *const _;
+ #[doc = r"Return the pointer to the register block"]
+ #[inline(always)]
+ pub const fn ptr() -> *const pm::RegisterBlock {
+ Self::PTR
+ }
+}
+impl Deref for PM {
+ type Target = pm::RegisterBlock;
+ #[inline(always)]
+ fn deref(&self) -> &Self::Target {
+ unsafe { &*Self::PTR }
+ }
+}
+impl core::fmt::Debug for PM {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ f.debug_struct("PM").finish()
+ }
+}
+#[doc = "Power Manager"]
+pub mod pm;
+#[doc = "Port Module"]
+pub struct PORT {
+ _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for PORT {}
+impl PORT {
+ #[doc = r"Pointer to the register block"]
+ pub const PTR: *const port::RegisterBlock = 0x4100_0000 as *const _;
+ #[doc = r"Return the pointer to the register block"]
+ #[inline(always)]
+ pub const fn ptr() -> *const port::RegisterBlock {
+ Self::PTR
+ }
+}
+impl Deref for PORT {
+ type Target = port::RegisterBlock;
+ #[inline(always)]
+ fn deref(&self) -> &Self::Target {
+ unsafe { &*Self::PTR }
+ }
+}
+impl core::fmt::Debug for PORT {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ f.debug_struct("PORT").finish()
+ }
+}
+#[doc = "Port Module"]
+pub mod port;
+#[doc = "Port Module"]
+pub struct PORT_IOBUS {
+ _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for PORT_IOBUS {}
+impl PORT_IOBUS {
+ #[doc = r"Pointer to the register block"]
+ pub const PTR: *const port::RegisterBlock = 0x6000_0000 as *const _;
+ #[doc = r"Return the pointer to the register block"]
+ #[inline(always)]
+ pub const fn ptr() -> *const port::RegisterBlock {
+ Self::PTR
+ }
+}
+impl Deref for PORT_IOBUS {
+ type Target = port::RegisterBlock;
+ #[inline(always)]
+ fn deref(&self) -> &Self::Target {
+ unsafe { &*Self::PTR }
+ }
+}
+impl core::fmt::Debug for PORT_IOBUS {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ f.debug_struct("PORT_IOBUS").finish()
+ }
+}
+#[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 = 0x4000_0c00 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 = "Real-Time Counter"]
+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 = 0x4000_2400 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 Counter"]
+pub mod rtc;
+#[doc = "Sigma-Delta Analog Digital Converter"]
+pub struct SDADC {
+ _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for SDADC {}
+impl SDADC {
+ #[doc = r"Pointer to the register block"]
+ pub const PTR: *const sdadc::RegisterBlock = 0x4200_4c00 as *const _;
+ #[doc = r"Return the pointer to the register block"]
+ #[inline(always)]
+ pub const fn ptr() -> *const sdadc::RegisterBlock {
+ Self::PTR
+ }
+}
+impl Deref for SDADC {
+ type Target = sdadc::RegisterBlock;
+ #[inline(always)]
+ fn deref(&self) -> &Self::Target {
+ unsafe { &*Self::PTR }
+ }
+}
+impl core::fmt::Debug for SDADC {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ f.debug_struct("SDADC").finish()
+ }
+}
+#[doc = "Sigma-Delta Analog Digital Converter"]
+pub mod sdadc;
+#[doc = "Serial Communication Interface"]
+pub struct SERCOM0 {
+ _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for SERCOM0 {}
+impl SERCOM0 {
+ #[doc = r"Pointer to the register block"]
+ pub const PTR: *const sercom0::RegisterBlock = 0x4200_0400 as *const _;
+ #[doc = r"Return the pointer to the register block"]
+ #[inline(always)]
+ pub const fn ptr() -> *const sercom0::RegisterBlock {
+ Self::PTR
+ }
+}
+impl Deref for SERCOM0 {
+ type Target = sercom0::RegisterBlock;
+ #[inline(always)]
+ fn deref(&self) -> &Self::Target {
+ unsafe { &*Self::PTR }
+ }
+}
+impl core::fmt::Debug for SERCOM0 {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ f.debug_struct("SERCOM0").finish()
+ }
+}
+#[doc = "Serial Communication Interface"]
+pub mod sercom0;
+#[doc = "Serial Communication Interface"]
+pub struct SERCOM1 {
+ _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for SERCOM1 {}
+impl SERCOM1 {
+ #[doc = r"Pointer to the register block"]
+ pub const PTR: *const sercom0::RegisterBlock = 0x4200_0800 as *const _;
+ #[doc = r"Return the pointer to the register block"]
+ #[inline(always)]
+ pub const fn ptr() -> *const sercom0::RegisterBlock {
+ Self::PTR
+ }
+}
+impl Deref for SERCOM1 {
+ type Target = sercom0::RegisterBlock;
+ #[inline(always)]
+ fn deref(&self) -> &Self::Target {
+ unsafe { &*Self::PTR }
+ }
+}
+impl core::fmt::Debug for SERCOM1 {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ f.debug_struct("SERCOM1").finish()
+ }
+}
+#[doc = "Serial Communication Interface"]
+pub struct SERCOM2 {
+ _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for SERCOM2 {}
+impl SERCOM2 {
+ #[doc = r"Pointer to the register block"]
+ pub const PTR: *const sercom0::RegisterBlock = 0x4200_0c00 as *const _;
+ #[doc = r"Return the pointer to the register block"]
+ #[inline(always)]
+ pub const fn ptr() -> *const sercom0::RegisterBlock {
+ Self::PTR
+ }
+}
+impl Deref for SERCOM2 {
+ type Target = sercom0::RegisterBlock;
+ #[inline(always)]
+ fn deref(&self) -> &Self::Target {
+ unsafe { &*Self::PTR }
+ }
+}
+impl core::fmt::Debug for SERCOM2 {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ f.debug_struct("SERCOM2").finish()
+ }
+}
+#[doc = "Serial Communication Interface"]
+pub struct SERCOM3 {
+ _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for SERCOM3 {}
+impl SERCOM3 {
+ #[doc = r"Pointer to the register block"]
+ pub const PTR: *const sercom0::RegisterBlock = 0x4200_1000 as *const _;
+ #[doc = r"Return the pointer to the register block"]
+ #[inline(always)]
+ pub const fn ptr() -> *const sercom0::RegisterBlock {
+ Self::PTR
+ }
+}
+impl Deref for SERCOM3 {
+ type Target = sercom0::RegisterBlock;
+ #[inline(always)]
+ fn deref(&self) -> &Self::Target {
+ unsafe { &*Self::PTR }
+ }
+}
+impl core::fmt::Debug for SERCOM3 {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ f.debug_struct("SERCOM3").finish()
+ }
+}
+#[doc = "Serial Communication Interface"]
+pub struct SERCOM4 {
+ _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for SERCOM4 {}
+impl SERCOM4 {
+ #[doc = r"Pointer to the register block"]
+ pub const PTR: *const sercom0::RegisterBlock = 0x4200_1400 as *const _;
+ #[doc = r"Return the pointer to the register block"]
+ #[inline(always)]
+ pub const fn ptr() -> *const sercom0::RegisterBlock {
+ Self::PTR
+ }
+}
+impl Deref for SERCOM4 {
+ type Target = sercom0::RegisterBlock;
+ #[inline(always)]
+ fn deref(&self) -> &Self::Target {
+ unsafe { &*Self::PTR }
+ }
+}
+impl core::fmt::Debug for SERCOM4 {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ f.debug_struct("SERCOM4").finish()
+ }
+}
+#[doc = "Serial Communication Interface"]
+pub struct SERCOM5 {
+ _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for SERCOM5 {}
+impl SERCOM5 {
+ #[doc = r"Pointer to the register block"]
+ pub const PTR: *const sercom0::RegisterBlock = 0x4200_1800 as *const _;
+ #[doc = r"Return the pointer to the register block"]
+ #[inline(always)]
+ pub const fn ptr() -> *const sercom0::RegisterBlock {
+ Self::PTR
+ }
+}
+impl Deref for SERCOM5 {
+ type Target = sercom0::RegisterBlock;
+ #[inline(always)]
+ fn deref(&self) -> &Self::Target {
+ unsafe { &*Self::PTR }
+ }
+}
+impl core::fmt::Debug for SERCOM5 {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ f.debug_struct("SERCOM5").finish()
+ }
+}
+#[doc = "Serial Communication Interface"]
+pub struct SERCOM6 {
+ _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for SERCOM6 {}
+impl SERCOM6 {
+ #[doc = r"Pointer to the register block"]
+ pub const PTR: *const sercom0::RegisterBlock = 0x4300_0000 as *const _;
+ #[doc = r"Return the pointer to the register block"]
+ #[inline(always)]
+ pub const fn ptr() -> *const sercom0::RegisterBlock {
+ Self::PTR
+ }
+}
+impl Deref for SERCOM6 {
+ type Target = sercom0::RegisterBlock;
+ #[inline(always)]
+ fn deref(&self) -> &Self::Target {
+ unsafe { &*Self::PTR }
+ }
+}
+impl core::fmt::Debug for SERCOM6 {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ f.debug_struct("SERCOM6").finish()
+ }
+}
+#[doc = "Serial Communication Interface"]
+pub struct SERCOM7 {
+ _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for SERCOM7 {}
+impl SERCOM7 {
+ #[doc = r"Pointer to the register block"]
+ pub const PTR: *const sercom0::RegisterBlock = 0x4300_0400 as *const _;
+ #[doc = r"Return the pointer to the register block"]
+ #[inline(always)]
+ pub const fn ptr() -> *const sercom0::RegisterBlock {
+ Self::PTR
+ }
+}
+impl Deref for SERCOM7 {
+ type Target = sercom0::RegisterBlock;
+ #[inline(always)]
+ fn deref(&self) -> &Self::Target {
+ unsafe { &*Self::PTR }
+ }
+}
+impl core::fmt::Debug for SERCOM7 {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ f.debug_struct("SERCOM7").finish()
+ }
+}
+#[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 = 0x4000_1800 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 = "Basic 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 = 0x4200_3000 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 = "Basic Timer Counter"]
+pub mod tc0;
+#[doc = "Basic 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 = 0x4200_3400 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 = "Basic 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 = 0x4200_3800 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 = "Basic 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 = 0x4200_3c00 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 = "Basic Timer Counter"]
+pub struct TC4 {
+ _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for TC4 {}
+impl TC4 {
+ #[doc = r"Pointer to the register block"]
+ pub const PTR: *const tc0::RegisterBlock = 0x4200_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 TC4 {
+ type Target = tc0::RegisterBlock;
+ #[inline(always)]
+ fn deref(&self) -> &Self::Target {
+ unsafe { &*Self::PTR }
+ }
+}
+impl core::fmt::Debug for TC4 {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ f.debug_struct("TC4").finish()
+ }
+}
+#[doc = "Basic Timer Counter"]
+pub struct TC5 {
+ _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for TC5 {}
+impl TC5 {
+ #[doc = r"Pointer to the register block"]
+ pub const PTR: *const tc0::RegisterBlock = 0x4300_0800 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 TC5 {
+ type Target = tc0::RegisterBlock;
+ #[inline(always)]
+ fn deref(&self) -> &Self::Target {
+ unsafe { &*Self::PTR }
+ }
+}
+impl core::fmt::Debug for TC5 {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ f.debug_struct("TC5").finish()
+ }
+}
+#[doc = "Basic Timer Counter"]
+pub struct TC6 {
+ _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for TC6 {}
+impl TC6 {
+ #[doc = r"Pointer to the register block"]
+ pub const PTR: *const tc0::RegisterBlock = 0x4300_0c00 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 TC6 {
+ type Target = tc0::RegisterBlock;
+ #[inline(always)]
+ fn deref(&self) -> &Self::Target {
+ unsafe { &*Self::PTR }
+ }
+}
+impl core::fmt::Debug for TC6 {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ f.debug_struct("TC6").finish()
+ }
+}
+#[doc = "Basic Timer Counter"]
+pub struct TC7 {
+ _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for TC7 {}
+impl TC7 {
+ #[doc = r"Pointer to the register block"]
+ pub const PTR: *const tc0::RegisterBlock = 0x4300_1000 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 TC7 {
+ type Target = tc0::RegisterBlock;
+ #[inline(always)]
+ fn deref(&self) -> &Self::Target {
+ unsafe { &*Self::PTR }
+ }
+}
+impl core::fmt::Debug for TC7 {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ f.debug_struct("TC7").finish()
+ }
+}
+#[doc = "Timer Counter Control"]
+pub struct TCC0 {
+ _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for TCC0 {}
+impl TCC0 {
+ #[doc = r"Pointer to the register block"]
+ pub const PTR: *const tcc0::RegisterBlock = 0x4200_2400 as *const _;
+ #[doc = r"Return the pointer to the register block"]
+ #[inline(always)]
+ pub const fn ptr() -> *const tcc0::RegisterBlock {
+ Self::PTR
+ }
+}
+impl Deref for TCC0 {
+ type Target = tcc0::RegisterBlock;
+ #[inline(always)]
+ fn deref(&self) -> &Self::Target {
+ unsafe { &*Self::PTR }
+ }
+}
+impl core::fmt::Debug for TCC0 {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ f.debug_struct("TCC0").finish()
+ }
+}
+#[doc = "Timer Counter Control"]
+pub mod tcc0;
+#[doc = "Timer Counter Control"]
+pub struct TCC1 {
+ _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for TCC1 {}
+impl TCC1 {
+ #[doc = r"Pointer to the register block"]
+ pub const PTR: *const tcc0::RegisterBlock = 0x4200_2800 as *const _;
+ #[doc = r"Return the pointer to the register block"]
+ #[inline(always)]
+ pub const fn ptr() -> *const tcc0::RegisterBlock {
+ Self::PTR
+ }
+}
+impl Deref for TCC1 {
+ type Target = tcc0::RegisterBlock;
+ #[inline(always)]
+ fn deref(&self) -> &Self::Target {
+ unsafe { &*Self::PTR }
+ }
+}
+impl core::fmt::Debug for TCC1 {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ f.debug_struct("TCC1").finish()
+ }
+}
+#[doc = "Timer Counter Control"]
+pub struct TCC2 {
+ _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for TCC2 {}
+impl TCC2 {
+ #[doc = r"Pointer to the register block"]
+ pub const PTR: *const tcc0::RegisterBlock = 0x4200_2c00 as *const _;
+ #[doc = r"Return the pointer to the register block"]
+ #[inline(always)]
+ pub const fn ptr() -> *const tcc0::RegisterBlock {
+ Self::PTR
+ }
+}
+impl Deref for TCC2 {
+ type Target = tcc0::RegisterBlock;
+ #[inline(always)]
+ fn deref(&self) -> &Self::Target {
+ unsafe { &*Self::PTR }
+ }
+}
+impl core::fmt::Debug for TCC2 {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ f.debug_struct("TCC2").finish()
+ }
+}
+#[doc = "Temperature Sensor"]
+pub struct TSENS {
+ _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for TSENS {}
+impl TSENS {
+ #[doc = r"Pointer to the register block"]
+ pub const PTR: *const tsens::RegisterBlock = 0x4000_3000 as *const _;
+ #[doc = r"Return the pointer to the register block"]
+ #[inline(always)]
+ pub const fn ptr() -> *const tsens::RegisterBlock {
+ Self::PTR
+ }
+}
+impl Deref for TSENS {
+ type Target = tsens::RegisterBlock;
+ #[inline(always)]
+ fn deref(&self) -> &Self::Target {
+ unsafe { &*Self::PTR }
+ }
+}
+impl core::fmt::Debug for TSENS {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ f.debug_struct("TSENS").finish()
+ }
+}
+#[doc = "Temperature Sensor"]
+pub mod tsens;
+#[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 = 0x4000_2000 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 = "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;
+#[doc = "System Control Registers"]
+pub struct SYSTEMCONTROL {
+ _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for SYSTEMCONTROL {}
+impl SYSTEMCONTROL {
+ #[doc = r"Pointer to the register block"]
+ pub const PTR: *const system_control::RegisterBlock = 0xe000_e000 as *const _;
+ #[doc = r"Return the pointer to the register block"]
+ #[inline(always)]
+ pub const fn ptr() -> *const system_control::RegisterBlock {
+ Self::PTR
+ }
+}
+impl Deref for SYSTEMCONTROL {
+ type Target = system_control::RegisterBlock;
+ #[inline(always)]
+ fn deref(&self) -> &Self::Target {
+ unsafe { &*Self::PTR }
+ }
+}
+impl core::fmt::Debug for SYSTEMCONTROL {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ f.debug_struct("SYSTEMCONTROL").finish()
+ }
+}
+#[doc = "System Control Registers"]
+pub mod system_control;
+#[no_mangle]
+static mut DEVICE_PERIPHERALS: bool = false;
+#[doc = r"All the peripherals"]
+#[allow(non_snake_case)]
+pub struct Peripherals {
+ #[doc = "AC"]
+ pub AC: AC,
+ #[doc = "ADC0"]
+ pub ADC0: ADC0,
+ #[doc = "ADC1"]
+ pub ADC1: ADC1,
+ #[doc = "CAN0"]
+ pub CAN0: CAN0,
+ #[doc = "CAN1"]
+ pub CAN1: CAN1,
+ #[doc = "CCL"]
+ pub CCL: CCL,
+ #[doc = "DAC"]
+ pub DAC: DAC,
+ #[doc = "DIVAS"]
+ pub DIVAS: DIVAS,
+ #[doc = "DMAC"]
+ pub DMAC: DMAC,
+ #[doc = "DSU"]
+ pub DSU: DSU,
+ #[doc = "EIC"]
+ pub EIC: EIC,
+ #[doc = "EVSYS"]
+ pub EVSYS: EVSYS,
+ #[doc = "FREQM"]
+ pub FREQM: FREQM,
+ #[doc = "GCLK"]
+ pub GCLK: GCLK,
+ #[doc = "HMATRIXHS"]
+ pub HMATRIXHS: HMATRIXHS,
+ #[doc = "MCLK"]
+ pub MCLK: MCLK,
+ #[doc = "MTB"]
+ pub MTB: MTB,
+ #[doc = "NVMCTRL"]
+ pub NVMCTRL: NVMCTRL,
+ #[doc = "OSCCTRL"]
+ pub OSCCTRL: OSCCTRL,
+ #[doc = "OSC32KCTRL"]
+ pub OSC32KCTRL: OSC32KCTRL,
+ #[doc = "PAC"]
+ pub PAC: PAC,
+ #[doc = "PM"]
+ pub PM: PM,
+ #[doc = "PORT"]
+ pub PORT: PORT,
+ #[doc = "PORT_IOBUS"]
+ pub PORT_IOBUS: PORT_IOBUS,
+ #[doc = "RSTC"]
+ pub RSTC: RSTC,
+ #[doc = "RTC"]
+ pub RTC: RTC,
+ #[doc = "SDADC"]
+ pub SDADC: SDADC,
+ #[doc = "SERCOM0"]
+ pub SERCOM0: SERCOM0,
+ #[doc = "SERCOM1"]
+ pub SERCOM1: SERCOM1,
+ #[doc = "SERCOM2"]
+ pub SERCOM2: SERCOM2,
+ #[doc = "SERCOM3"]
+ pub SERCOM3: SERCOM3,
+ #[doc = "SERCOM4"]
+ pub SERCOM4: SERCOM4,
+ #[doc = "SERCOM5"]
+ pub SERCOM5: SERCOM5,
+ #[doc = "SERCOM6"]
+ pub SERCOM6: SERCOM6,
+ #[doc = "SERCOM7"]
+ pub SERCOM7: SERCOM7,
+ #[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 = "TC4"]
+ pub TC4: TC4,
+ #[doc = "TC5"]
+ pub TC5: TC5,
+ #[doc = "TC6"]
+ pub TC6: TC6,
+ #[doc = "TC7"]
+ pub TC7: TC7,
+ #[doc = "TCC0"]
+ pub TCC0: TCC0,
+ #[doc = "TCC1"]
+ pub TCC1: TCC1,
+ #[doc = "TCC2"]
+ pub TCC2: TCC2,
+ #[doc = "TSENS"]
+ pub TSENS: TSENS,
+ #[doc = "WDT"]
+ pub WDT: WDT,
+ #[doc = "SYSTICK"]
+ pub SYSTICK: SYSTICK,
+ #[doc = "SYSTEMCONTROL"]
+ pub SYSTEMCONTROL: SYSTEMCONTROL,
+}
+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 {
+ AC: AC {
+ _marker: PhantomData,
+ },
+ ADC0: ADC0 {
+ _marker: PhantomData,
+ },
+ ADC1: ADC1 {
+ _marker: PhantomData,
+ },
+ CAN0: CAN0 {
+ _marker: PhantomData,
+ },
+ CAN1: CAN1 {
+ _marker: PhantomData,
+ },
+ CCL: CCL {
+ _marker: PhantomData,
+ },
+ DAC: DAC {
+ _marker: PhantomData,
+ },
+ DIVAS: DIVAS {
+ _marker: PhantomData,
+ },
+ DMAC: DMAC {
+ _marker: PhantomData,
+ },
+ DSU: DSU {
+ _marker: PhantomData,
+ },
+ EIC: EIC {
+ _marker: PhantomData,
+ },
+ EVSYS: EVSYS {
+ _marker: PhantomData,
+ },
+ FREQM: FREQM {
+ _marker: PhantomData,
+ },
+ GCLK: GCLK {
+ _marker: PhantomData,
+ },
+ HMATRIXHS: HMATRIXHS {
+ _marker: PhantomData,
+ },
+ MCLK: MCLK {
+ _marker: PhantomData,
+ },
+ MTB: MTB {
+ _marker: PhantomData,
+ },
+ NVMCTRL: NVMCTRL {
+ _marker: PhantomData,
+ },
+ OSCCTRL: OSCCTRL {
+ _marker: PhantomData,
+ },
+ OSC32KCTRL: OSC32KCTRL {
+ _marker: PhantomData,
+ },
+ PAC: PAC {
+ _marker: PhantomData,
+ },
+ PM: PM {
+ _marker: PhantomData,
+ },
+ PORT: PORT {
+ _marker: PhantomData,
+ },
+ PORT_IOBUS: PORT_IOBUS {
+ _marker: PhantomData,
+ },
+ RSTC: RSTC {
+ _marker: PhantomData,
+ },
+ RTC: RTC {
+ _marker: PhantomData,
+ },
+ SDADC: SDADC {
+ _marker: PhantomData,
+ },
+ SERCOM0: SERCOM0 {
+ _marker: PhantomData,
+ },
+ SERCOM1: SERCOM1 {
+ _marker: PhantomData,
+ },
+ SERCOM2: SERCOM2 {
+ _marker: PhantomData,
+ },
+ SERCOM3: SERCOM3 {
+ _marker: PhantomData,
+ },
+ SERCOM4: SERCOM4 {
+ _marker: PhantomData,
+ },
+ SERCOM5: SERCOM5 {
+ _marker: PhantomData,
+ },
+ SERCOM6: SERCOM6 {
+ _marker: PhantomData,
+ },
+ SERCOM7: SERCOM7 {
+ _marker: PhantomData,
+ },
+ SUPC: SUPC {
+ _marker: PhantomData,
+ },
+ TC0: TC0 {
+ _marker: PhantomData,
+ },
+ TC1: TC1 {
+ _marker: PhantomData,
+ },
+ TC2: TC2 {
+ _marker: PhantomData,
+ },
+ TC3: TC3 {
+ _marker: PhantomData,
+ },
+ TC4: TC4 {
+ _marker: PhantomData,
+ },
+ TC5: TC5 {
+ _marker: PhantomData,
+ },
+ TC6: TC6 {
+ _marker: PhantomData,
+ },
+ TC7: TC7 {
+ _marker: PhantomData,
+ },
+ TCC0: TCC0 {
+ _marker: PhantomData,
+ },
+ TCC1: TCC1 {
+ _marker: PhantomData,
+ },
+ TCC2: TCC2 {
+ _marker: PhantomData,
+ },
+ TSENS: TSENS {
+ _marker: PhantomData,
+ },
+ WDT: WDT {
+ _marker: PhantomData,
+ },
+ SYSTICK: SYSTICK {
+ _marker: PhantomData,
+ },
+ SYSTEMCONTROL: SYSTEMCONTROL {
+ _marker: PhantomData,
+ },
+ }
+ }
+}
generated by cgit v1.2.3-70-g09d2 (git 2.51.1) at 2025-12-06 05:57:50 +0000