#![doc = "Peripheral access API for XMC1300 microcontrollers (generated using svd2rust v0.13.1)\n\nYou can find an overview of the API [here].\n\n[here]: https://docs.rs/svd2rust/0.13.1/svd2rust/#peripheral-api"]
#![deny(missing_docs)]
#![deny(warnings)]
#![allow(non_camel_case_types)]
#![no_std]
extern crate bare_metal;
extern crate cortex_m;
#[cfg(feature = "rt")]
extern crate cortex_m_rt;
extern crate vcell;
use core::marker::PhantomData;
use core::ops::Deref;
#[doc = r" Number available in the NVIC for configuring priority"]
pub const NVIC_PRIO_BITS: u8 = 2;
#[cfg(feature = "rt")]
extern "C" {
fn SCU_0();
fn SCU_1();
fn SCU_2();
fn ERU0_0();
fn ERU0_1();
fn ERU0_2();
fn ERU0_3();
fn MATH0_0();
fn USIC0_0();
fn USIC0_1();
fn USIC0_2();
fn USIC0_3();
fn USIC0_4();
fn USIC0_5();
fn VADC0_C0_0();
fn VADC0_C0_1();
fn VADC0_G0_0();
fn VADC0_G0_1();
fn VADC0_G1_0();
fn VADC0_G1_1();
fn CCU40_0();
fn CCU40_1();
fn CCU40_2();
fn CCU40_3();
fn CCU80_0();
fn CCU80_1();
fn POSIF0_0();
fn POSIF0_1();
fn BCCU0_0();
}
#[doc(hidden)]
pub union Vector {
_handler: unsafe extern "C" fn(),
_reserved: u32,
}
#[cfg(feature = "rt")]
#[doc(hidden)]
#[link_section = ".vector_table.interrupts"]
#[no_mangle]
pub static __INTERRUPTS: [Vector; 32] = [
Vector { _handler: SCU_0 },
Vector { _handler: SCU_1 },
Vector { _handler: SCU_2 },
Vector { _handler: ERU0_0 },
Vector { _handler: ERU0_1 },
Vector { _handler: ERU0_2 },
Vector { _handler: ERU0_3 },
Vector { _handler: MATH0_0 },
Vector { _reserved: 0 },
Vector { _handler: USIC0_0 },
Vector { _handler: USIC0_1 },
Vector { _handler: USIC0_2 },
Vector { _handler: USIC0_3 },
Vector { _handler: USIC0_4 },
Vector { _handler: USIC0_5 },
Vector {
_handler: VADC0_C0_0,
},
Vector {
_handler: VADC0_C0_1,
},
Vector {
_handler: VADC0_G0_0,
},
Vector {
_handler: VADC0_G0_1,
},
Vector {
_handler: VADC0_G1_0,
},
Vector {
_handler: VADC0_G1_1,
},
Vector { _handler: CCU40_0 },
Vector { _handler: CCU40_1 },
Vector { _handler: CCU40_2 },
Vector { _handler: CCU40_3 },
Vector { _handler: CCU80_0 },
Vector { _handler: CCU80_1 },
Vector { _handler: POSIF0_0 },
Vector { _handler: POSIF0_1 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _handler: BCCU0_0 },
];
#[doc = r" Macro to override a device specific interrupt handler"]
#[doc = r""]
#[doc = r" # Syntax"]
#[doc = r""]
#[doc = r" ``` ignore"]
#[doc = r" interrupt!("]
#[doc = r" // Name of the interrupt"]
#[doc = r" $Name:ident,"]
#[doc = r""]
#[doc = r" // Path to the interrupt handler (a function)"]
#[doc = r" $handler:path,"]
#[doc = r""]
#[doc = r" // Optional, state preserved across invocations of the handler"]
#[doc = r" state: $State:ty = $initial_state:expr,"]
#[doc = r" );"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" Where `$Name` must match the name of one of the variants of the `Interrupt`"]
#[doc = r" enum."]
#[doc = r""]
#[doc = r" The handler must have signature `fn()` is no state was associated to it;"]
#[doc = r" otherwise its signature must be `fn(&mut $State)`."]
#[cfg(feature = "rt")]
#[macro_export]
macro_rules! interrupt {
($Name:ident, $handler:path,state: $State:ty = $initial_state:expr) => {
#[allow(unsafe_code)]
#[deny(private_no_mangle_fns)]
#[no_mangle]
pub unsafe extern "C" fn $Name() {
static mut STATE: $State = $initial_state;
let _ = $crate::Interrupt::$Name;
let f: fn(&mut $State) = $handler;
f(&mut STATE)
}
};
($Name:ident, $handler:path) => {
#[allow(unsafe_code)]
#[deny(private_no_mangle_fns)]
#[no_mangle]
pub unsafe extern "C" fn $Name() {
let _ = $crate::Interrupt::$Name;
let f: fn() = $handler;
f()
}
};
}
#[doc = r" Enumeration of all the interrupts"]
pub enum Interrupt {
#[doc = "0 - System Control"]
SCU_0,
#[doc = "1 - System Control"]
SCU_1,
#[doc = "2 - System Control"]
SCU_2,
#[doc = "3 - External Request Unit 0"]
ERU0_0,
#[doc = "4 - External Request Unit 0"]
ERU0_1,
#[doc = "5 - External Request Unit 0"]
ERU0_2,
#[doc = "6 - External Request Unit 0"]
ERU0_3,
#[doc = "7 - MATH Unit 0"]
MATH0_0,
#[doc = "9 - Universal Serial Interface Channel (Module 0)"]
USIC0_0,
#[doc = "10 - Universal Serial Interface Channel (Module 0)"]
USIC0_1,
#[doc = "11 - Universal Serial Interface Channel (Module 0)"]
USIC0_2,
#[doc = "12 - Universal Serial Interface Channel (Module 0)"]
USIC0_3,
#[doc = "13 - Universal Serial Interface Channel (Module 0)"]
USIC0_4,
#[doc = "14 - Universal Serial Interface Channel (Module 0)"]
USIC0_5,
#[doc = "15 - Analog to Digital Converter Common Block 0"]
VADC0_C0_0,
#[doc = "16 - Analog to Digital Converter Common Block 0"]
VADC0_C0_1,
#[doc = "17 - Analog to Digital Converter Group 0"]
VADC0_G0_0,
#[doc = "18 - Analog to Digital Converter Group 0"]
VADC0_G0_1,
#[doc = "19 - Analog to Digital Converter Group 1"]
VADC0_G1_0,
#[doc = "20 - Analog to Digital Converter Group 1"]
VADC0_G1_1,
#[doc = "21 - Capture Compare Unit 4 (Module 0)"]
CCU40_0,
#[doc = "22 - Capture Compare Unit 4 (Module 0)"]
CCU40_1,
#[doc = "23 - Capture Compare Unit 4 (Module 0)"]
CCU40_2,
#[doc = "24 - Capture Compare Unit 4 (Module 0)"]
CCU40_3,
#[doc = "25 - Capture Compare Unit 8 (Module 0)"]
CCU80_0,
#[doc = "26 - Capture Compare Unit 8 (Module 0)"]
CCU80_1,
#[doc = "27 - Position Interface (Module 0)"]
POSIF0_0,
#[doc = "28 - Position Interface (Module 0)"]
POSIF0_1,
#[doc = "31 - Brightness and Color Control Unit 0"]
BCCU0_0,
}
unsafe impl ::bare_metal::Nr for Interrupt {
#[inline]
fn nr(&self) -> u8 {
match *self {
Interrupt::SCU_0 => 0,
Interrupt::SCU_1 => 1,
Interrupt::SCU_2 => 2,
Interrupt::ERU0_0 => 3,
Interrupt::ERU0_1 => 4,
Interrupt::ERU0_2 => 5,
Interrupt::ERU0_3 => 6,
Interrupt::MATH0_0 => 7,
Interrupt::USIC0_0 => 9,
Interrupt::USIC0_1 => 10,
Interrupt::USIC0_2 => 11,
Interrupt::USIC0_3 => 12,
Interrupt::USIC0_4 => 13,
Interrupt::USIC0_5 => 14,
Interrupt::VADC0_C0_0 => 15,
Interrupt::VADC0_C0_1 => 16,
Interrupt::VADC0_G0_0 => 17,
Interrupt::VADC0_G0_1 => 18,
Interrupt::VADC0_G1_0 => 19,
Interrupt::VADC0_G1_1 => 20,
Interrupt::CCU40_0 => 21,
Interrupt::CCU40_1 => 22,
Interrupt::CCU40_2 => 23,
Interrupt::CCU40_3 => 24,
Interrupt::CCU80_0 => 25,
Interrupt::CCU80_1 => 26,
Interrupt::POSIF0_0 => 27,
Interrupt::POSIF0_1 => 28,
Interrupt::BCCU0_0 => 31,
}
}
}
#[doc(hidden)]
pub mod interrupt;
pub use cortex_m::peripheral::Peripherals as CorePeripherals;
pub use cortex_m::peripheral::{CBP, CPUID, DCB, DWT, FPB, FPU, ITM, MPU, NVIC, SCB, SYST, TPIU};
#[doc = "Cortex-M0 Private Peripheral Block"]
pub struct PPB {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PPB {}
impl PPB {
#[doc = r" Returns a pointer to the register block"]
pub fn ptr() -> *const ppb::RegisterBlock {
3758153728 as *const _
}
}
impl Deref for PPB {
type Target = ppb::RegisterBlock;
fn deref(&self) -> &ppb::RegisterBlock {
unsafe { &*PPB::ptr() }
}
}
#[doc = "Cortex-M0 Private Peripheral Block"]
pub mod ppb;
#[doc = "Event Request Unit 0"]
pub struct ERU0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for ERU0 {}
impl ERU0 {
#[doc = r" Returns a pointer to the register block"]
pub fn ptr() -> *const eru0::RegisterBlock {
1073808896 as *const _
}
}
impl Deref for ERU0 {
type Target = eru0::RegisterBlock;
fn deref(&self) -> &eru0::RegisterBlock {
unsafe { &*ERU0::ptr() }
}
}
#[doc = "Event Request Unit 0"]
pub mod eru0;
#[doc = "MATH Unit"]
pub struct MATH {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for MATH {}
impl MATH {
#[doc = r" Returns a pointer to the register block"]
pub fn ptr() -> *const math::RegisterBlock {
1073938432 as *const _
}
}
impl Deref for MATH {
type Target = math::RegisterBlock;
fn deref(&self) -> &math::RegisterBlock {
unsafe { &*MATH::ptr() }
}
}
#[doc = "MATH Unit"]
pub mod math;
#[doc = "PAU Unit"]
pub struct PAU {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PAU {}
impl PAU {
#[doc = r" Returns a pointer to the register block"]
pub fn ptr() -> *const pau::RegisterBlock {
1073741824 as *const _
}
}
impl Deref for PAU {
type Target = pau::RegisterBlock;
fn deref(&self) -> &pau::RegisterBlock {
unsafe { &*PAU::ptr() }
}
}
#[doc = "PAU Unit"]
pub mod pau;
#[doc = "NVM Unit"]
pub struct NVM {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for NVM {}
impl NVM {
#[doc = r" Returns a pointer to the register block"]
pub fn ptr() -> *const nvm::RegisterBlock {
1074069504 as *const _
}
}
impl Deref for NVM {
type Target = nvm::RegisterBlock;
fn deref(&self) -> &nvm::RegisterBlock {
unsafe { &*NVM::ptr() }
}
}
#[doc = "NVM Unit"]
pub mod nvm;
#[doc = "Watch Dog Timer"]
pub struct WDT {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for WDT {}
impl WDT {
#[doc = r" Returns a pointer to the register block"]
pub fn ptr() -> *const wdt::RegisterBlock {
1073872896 as *const _
}
}
impl Deref for WDT {
type Target = wdt::RegisterBlock;
fn deref(&self) -> &wdt::RegisterBlock {
unsafe { &*WDT::ptr() }
}
}
#[doc = "Watch Dog Timer"]
pub mod wdt;
#[doc = "Real Time Clock"]
pub struct RTC {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for RTC {}
impl RTC {
#[doc = r" Returns a pointer to the register block"]
pub fn ptr() -> *const rtc::RegisterBlock {
1073809920 as *const _
}
}
impl Deref for RTC {
type Target = rtc::RegisterBlock;
fn deref(&self) -> &rtc::RegisterBlock {
unsafe { &*RTC::ptr() }
}
}
#[doc = "Real Time Clock"]
pub mod rtc;
#[doc = "PRNG Unit"]
pub struct PRNG {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PRNG {}
impl PRNG {
#[doc = r" Returns a pointer to the register block"]
pub fn ptr() -> *const prng::RegisterBlock {
1208090624 as *const _
}
}
impl Deref for PRNG {
type Target = prng::RegisterBlock;
fn deref(&self) -> &prng::RegisterBlock {
unsafe { &*PRNG::ptr() }
}
}
#[doc = "PRNG Unit"]
pub mod prng;
#[doc = "Universal Serial Interface Controller 0"]
pub struct USIC0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for USIC0 {}
impl USIC0 {
#[doc = r" Returns a pointer to the register block"]
pub fn ptr() -> *const usic0::RegisterBlock {
1207959560 as *const _
}
}
impl Deref for USIC0 {
type Target = usic0::RegisterBlock;
fn deref(&self) -> &usic0::RegisterBlock {
unsafe { &*USIC0::ptr() }
}
}
#[doc = "Universal Serial Interface Controller 0"]
pub mod usic0;
#[doc = "Universal Serial Interface Controller 0"]
pub struct USIC0_CH0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for USIC0_CH0 {}
impl USIC0_CH0 {
#[doc = r" Returns a pointer to the register block"]
pub fn ptr() -> *const usic0_ch0::RegisterBlock {
1207959552 as *const _
}
}
impl Deref for USIC0_CH0 {
type Target = usic0_ch0::RegisterBlock;
fn deref(&self) -> &usic0_ch0::RegisterBlock {
unsafe { &*USIC0_CH0::ptr() }
}
}
#[doc = "Universal Serial Interface Controller 0"]
pub mod usic0_ch0;
#[doc = "Universal Serial Interface Controller 0"]
pub struct USIC0_CH1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for USIC0_CH1 {}
impl USIC0_CH1 {
#[doc = r" Returns a pointer to the register block"]
pub fn ptr() -> *const usic0_ch0::RegisterBlock {
1207960064 as *const _
}
}
impl Deref for USIC0_CH1 {
type Target = usic0_ch0::RegisterBlock;
fn deref(&self) -> &usic0_ch0::RegisterBlock {
unsafe { &*USIC0_CH1::ptr() }
}
}
#[doc = "System Control Unit"]
pub struct SCU_GENERAL {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SCU_GENERAL {}
impl SCU_GENERAL {
#[doc = r" Returns a pointer to the register block"]
pub fn ptr() -> *const scu_general::RegisterBlock {
1073807360 as *const _
}
}
impl Deref for SCU_GENERAL {
type Target = scu_general::RegisterBlock;
fn deref(&self) -> &scu_general::RegisterBlock {
unsafe { &*SCU_GENERAL::ptr() }
}
}
#[doc = "System Control Unit"]
pub mod scu_general;
#[doc = "System Control Unit"]
pub struct SCU_INTERRUPT {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SCU_INTERRUPT {}
impl SCU_INTERRUPT {
#[doc = r" Returns a pointer to the register block"]
pub fn ptr() -> *const scu_interrupt::RegisterBlock {
1073807416 as *const _
}
}
impl Deref for SCU_INTERRUPT {
type Target = scu_interrupt::RegisterBlock;
fn deref(&self) -> &scu_interrupt::RegisterBlock {
unsafe { &*SCU_INTERRUPT::ptr() }
}
}
#[doc = "System Control Unit"]
pub mod scu_interrupt;
#[doc = "System Control Unit"]
pub struct SCU_POWER {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SCU_POWER {}
impl SCU_POWER {
#[doc = r" Returns a pointer to the register block"]
pub fn ptr() -> *const scu_power::RegisterBlock {
1073807872 as *const _
}
}
impl Deref for SCU_POWER {
type Target = scu_power::RegisterBlock;
fn deref(&self) -> &scu_power::RegisterBlock {
unsafe { &*SCU_POWER::ptr() }
}
}
#[doc = "System Control Unit"]
pub mod scu_power;
#[doc = "System Control Unit"]
pub struct SCU_CLK {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SCU_CLK {}
impl SCU_CLK {
#[doc = r" Returns a pointer to the register block"]
pub fn ptr() -> *const scu_clk::RegisterBlock {
1073808128 as *const _
}
}
impl Deref for SCU_CLK {
type Target = scu_clk::RegisterBlock;
fn deref(&self) -> &scu_clk::RegisterBlock {
unsafe { &*SCU_CLK::ptr() }
}
}
#[doc = "System Control Unit"]
pub mod scu_clk;
#[doc = "System Control Unit"]
pub struct SCU_RESET {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SCU_RESET {}
impl SCU_RESET {
#[doc = r" Returns a pointer to the register block"]
pub fn ptr() -> *const scu_reset::RegisterBlock {
1073808384 as *const _
}
}
impl Deref for SCU_RESET {
type Target = scu_reset::RegisterBlock;
fn deref(&self) -> &scu_reset::RegisterBlock {
unsafe { &*SCU_RESET::ptr() }
}
}
#[doc = "System Control Unit"]
pub mod scu_reset;
#[doc = "System Control Unit"]
pub struct COMPARATOR {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for COMPARATOR {}
impl COMPARATOR {
#[doc = r" Returns a pointer to the register block"]
pub fn ptr() -> *const comparator::RegisterBlock {
1073808640 as *const _
}
}
impl Deref for COMPARATOR {
type Target = comparator::RegisterBlock;
fn deref(&self) -> &comparator::RegisterBlock {
unsafe { &*COMPARATOR::ptr() }
}
}
#[doc = "System Control Unit"]
pub mod comparator;
#[doc = "System Control Unit"]
pub struct SCU_ANALOG {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SCU_ANALOG {}
impl SCU_ANALOG {
#[doc = r" Returns a pointer to the register block"]
pub fn ptr() -> *const scu_analog::RegisterBlock {
1073811456 as *const _
}
}
impl Deref for SCU_ANALOG {
type Target = scu_analog::RegisterBlock;
fn deref(&self) -> &scu_analog::RegisterBlock {
unsafe { &*SCU_ANALOG::ptr() }
}
}
#[doc = "System Control Unit"]
pub mod scu_analog;
#[doc = "Capture Compare Unit 4 - Unit 0"]
pub struct CCU40 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for CCU40 {}
impl CCU40 {
#[doc = r" Returns a pointer to the register block"]
pub fn ptr() -> *const ccu40::RegisterBlock {
1208221696 as *const _
}
}
impl Deref for CCU40 {
type Target = ccu40::RegisterBlock;
fn deref(&self) -> &ccu40::RegisterBlock {
unsafe { &*CCU40::ptr() }
}
}
#[doc = "Capture Compare Unit 4 - Unit 0"]
pub mod ccu40;
#[doc = "Capture Compare Unit 4 - Unit 0"]
pub struct CCU40_CC40 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for CCU40_CC40 {}
impl CCU40_CC40 {
#[doc = r" Returns a pointer to the register block"]
pub fn ptr() -> *const ccu40_cc40::RegisterBlock {
1208221952 as *const _
}
}
impl Deref for CCU40_CC40 {
type Target = ccu40_cc40::RegisterBlock;
fn deref(&self) -> &ccu40_cc40::RegisterBlock {
unsafe { &*CCU40_CC40::ptr() }
}
}
#[doc = "Capture Compare Unit 4 - Unit 0"]
pub mod ccu40_cc40;
#[doc = "Capture Compare Unit 4 - Unit 0"]
pub struct CCU40_CC41 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for CCU40_CC41 {}
impl CCU40_CC41 {
#[doc = r" Returns a pointer to the register block"]
pub fn ptr() -> *const ccu40_cc40::RegisterBlock {
1208222208 as *const _
}
}
impl Deref for CCU40_CC41 {
type Target = ccu40_cc40::RegisterBlock;
fn deref(&self) -> &ccu40_cc40::RegisterBlock {
unsafe { &*CCU40_CC41::ptr() }
}
}
#[doc = "Capture Compare Unit 4 - Unit 0"]
pub struct CCU40_CC42 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for CCU40_CC42 {}
impl CCU40_CC42 {
#[doc = r" Returns a pointer to the register block"]
pub fn ptr() -> *const ccu40_cc40::RegisterBlock {
1208222464 as *const _
}
}
impl Deref for CCU40_CC42 {
type Target = ccu40_cc40::RegisterBlock;
fn deref(&self) -> &ccu40_cc40::RegisterBlock {
unsafe { &*CCU40_CC42::ptr() }
}
}
#[doc = "Capture Compare Unit 4 - Unit 0"]
pub struct CCU40_CC43 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for CCU40_CC43 {}
impl CCU40_CC43 {
#[doc = r" Returns a pointer to the register block"]
pub fn ptr() -> *const ccu40_cc40::RegisterBlock {
1208222720 as *const _
}
}
impl Deref for CCU40_CC43 {
type Target = ccu40_cc40::RegisterBlock;
fn deref(&self) -> &ccu40_cc40::RegisterBlock {
unsafe { &*CCU40_CC43::ptr() }
}
}
#[doc = "Capture Compare Unit 8 - Unit 0"]
pub struct CCU80 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for CCU80 {}
impl CCU80 {
#[doc = r" Returns a pointer to the register block"]
pub fn ptr() -> *const ccu80::RegisterBlock {
1342177280 as *const _
}
}
impl Deref for CCU80 {
type Target = ccu80::RegisterBlock;
fn deref(&self) -> &ccu80::RegisterBlock {
unsafe { &*CCU80::ptr() }
}
}
#[doc = "Capture Compare Unit 8 - Unit 0"]
pub mod ccu80;
#[doc = "Capture Compare Unit 8 - Unit 0"]
pub struct CCU80_CC80 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for CCU80_CC80 {}
impl CCU80_CC80 {
#[doc = r" Returns a pointer to the register block"]
pub fn ptr() -> *const ccu80_cc80::RegisterBlock {
1342177536 as *const _
}
}
impl Deref for CCU80_CC80 {
type Target = ccu80_cc80::RegisterBlock;
fn deref(&self) -> &ccu80_cc80::RegisterBlock {
unsafe { &*CCU80_CC80::ptr() }
}
}
#[doc = "Capture Compare Unit 8 - Unit 0"]
pub mod ccu80_cc80;
#[doc = "Capture Compare Unit 8 - Unit 0"]
pub struct CCU80_CC81 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for CCU80_CC81 {}
impl CCU80_CC81 {
#[doc = r" Returns a pointer to the register block"]
pub fn ptr() -> *const ccu80_cc80::RegisterBlock {
1342177792 as *const _
}
}
impl Deref for CCU80_CC81 {
type Target = ccu80_cc80::RegisterBlock;
fn deref(&self) -> &ccu80_cc80::RegisterBlock {
unsafe { &*CCU80_CC81::ptr() }
}
}
#[doc = "Capture Compare Unit 8 - Unit 0"]
pub struct CCU80_CC82 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for CCU80_CC82 {}
impl CCU80_CC82 {
#[doc = r" Returns a pointer to the register block"]
pub fn ptr() -> *const ccu80_cc80::RegisterBlock {
1342178048 as *const _
}
}
impl Deref for CCU80_CC82 {
type Target = ccu80_cc80::RegisterBlock;
fn deref(&self) -> &ccu80_cc80::RegisterBlock {
unsafe { &*CCU80_CC82::ptr() }
}
}
#[doc = "Capture Compare Unit 8 - Unit 0"]
pub struct CCU80_CC83 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for CCU80_CC83 {}
impl CCU80_CC83 {
#[doc = r" Returns a pointer to the register block"]
pub fn ptr() -> *const ccu80_cc80::RegisterBlock {
1342178304 as *const _
}
}
impl Deref for CCU80_CC83 {
type Target = ccu80_cc80::RegisterBlock;
fn deref(&self) -> &ccu80_cc80::RegisterBlock {
unsafe { &*CCU80_CC83::ptr() }
}
}
#[doc = "Position Interface 0"]
pub struct POSIF0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for POSIF0 {}
impl POSIF0 {
#[doc = r" Returns a pointer to the register block"]
pub fn ptr() -> *const posif0::RegisterBlock {
1342242816 as *const _
}
}
impl Deref for POSIF0 {
type Target = posif0::RegisterBlock;
fn deref(&self) -> &posif0::RegisterBlock {
unsafe { &*POSIF0::ptr() }
}
}
#[doc = "Position Interface 0"]
pub mod posif0;
#[doc = "Analog to Digital Converter"]
pub struct VADC {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for VADC {}
impl VADC {
#[doc = r" Returns a pointer to the register block"]
pub fn ptr() -> *const vadc::RegisterBlock {
1208156160 as *const _
}
}
impl Deref for VADC {
type Target = vadc::RegisterBlock;
fn deref(&self) -> &vadc::RegisterBlock {
unsafe { &*VADC::ptr() }
}
}
#[doc = "Analog to Digital Converter"]
pub mod vadc;
#[doc = "Analog to Digital Converter"]
pub struct VADC_G0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for VADC_G0 {}
impl VADC_G0 {
#[doc = r" Returns a pointer to the register block"]
pub fn ptr() -> *const vadc_g0::RegisterBlock {
1208157184 as *const _
}
}
impl Deref for VADC_G0 {
type Target = vadc_g0::RegisterBlock;
fn deref(&self) -> &vadc_g0::RegisterBlock {
unsafe { &*VADC_G0::ptr() }
}
}
#[doc = "Analog to Digital Converter"]
pub mod vadc_g0;
#[doc = "Analog to Digital Converter"]
pub struct VADC_G1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for VADC_G1 {}
impl VADC_G1 {
#[doc = r" Returns a pointer to the register block"]
pub fn ptr() -> *const vadc_g0::RegisterBlock {
1208158208 as *const _
}
}
impl Deref for VADC_G1 {
type Target = vadc_g0::RegisterBlock;
fn deref(&self) -> &vadc_g0::RegisterBlock {
unsafe { &*VADC_G1::ptr() }
}
}
#[doc = "Sample and Hold ADC Sequencer"]
pub struct SHS0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SHS0 {}
impl SHS0 {
#[doc = r" Returns a pointer to the register block"]
pub fn ptr() -> *const shs0::RegisterBlock {
1208172544 as *const _
}
}
impl Deref for SHS0 {
type Target = shs0::RegisterBlock;
fn deref(&self) -> &shs0::RegisterBlock {
unsafe { &*SHS0::ptr() }
}
}
#[doc = "Sample and Hold ADC Sequencer"]
pub mod shs0;
#[doc = "BCCU Unit 0"]
pub struct BCCU0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for BCCU0 {}
impl BCCU0 {
#[doc = r" Returns a pointer to the register block"]
pub fn ptr() -> *const bccu0::RegisterBlock {
1342373888 as *const _
}
}
impl Deref for BCCU0 {
type Target = bccu0::RegisterBlock;
fn deref(&self) -> &bccu0::RegisterBlock {
unsafe { &*BCCU0::ptr() }
}
}
#[doc = "BCCU Unit 0"]
pub mod bccu0;
#[doc = "BCCU Unit 0"]
pub struct BCCU0_CH0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for BCCU0_CH0 {}
impl BCCU0_CH0 {
#[doc = r" Returns a pointer to the register block"]
pub fn ptr() -> *const bccu0_ch0::RegisterBlock {
1342373948 as *const _
}
}
impl Deref for BCCU0_CH0 {
type Target = bccu0_ch0::RegisterBlock;
fn deref(&self) -> &bccu0_ch0::RegisterBlock {
unsafe { &*BCCU0_CH0::ptr() }
}
}
#[doc = "BCCU Unit 0"]
pub mod bccu0_ch0;
#[doc = "BCCU Unit 0"]
pub struct BCCU0_CH1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for BCCU0_CH1 {}
impl BCCU0_CH1 {
#[doc = r" Returns a pointer to the register block"]
pub fn ptr() -> *const bccu0_ch0::RegisterBlock {
1342373968 as *const _
}
}
impl Deref for BCCU0_CH1 {
type Target = bccu0_ch0::RegisterBlock;
fn deref(&self) -> &bccu0_ch0::RegisterBlock {
unsafe { &*BCCU0_CH1::ptr() }
}
}
#[doc = "BCCU Unit 0"]
pub struct BCCU0_CH2 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for BCCU0_CH2 {}
impl BCCU0_CH2 {
#[doc = r" Returns a pointer to the register block"]
pub fn ptr() -> *const bccu0_ch0::RegisterBlock {
1342373988 as *const _
}
}
impl Deref for BCCU0_CH2 {
type Target = bccu0_ch0::RegisterBlock;
fn deref(&self) -> &bccu0_ch0::RegisterBlock {
unsafe { &*BCCU0_CH2::ptr() }
}
}
#[doc = "BCCU Unit 0"]
pub struct BCCU0_CH3 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for BCCU0_CH3 {}
impl BCCU0_CH3 {
#[doc = r" Returns a pointer to the register block"]
pub fn ptr() -> *const bccu0_ch0::RegisterBlock {
1342374008 as *const _
}
}
impl Deref for BCCU0_CH3 {
type Target = bccu0_ch0::RegisterBlock;
fn deref(&self) -> &bccu0_ch0::RegisterBlock {
unsafe { &*BCCU0_CH3::ptr() }
}
}
#[doc = "BCCU Unit 0"]
pub struct BCCU0_CH4 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for BCCU0_CH4 {}
impl BCCU0_CH4 {
#[doc = r" Returns a pointer to the register block"]
pub fn ptr() -> *const bccu0_ch0::RegisterBlock {
1342374028 as *const _
}
}
impl Deref for BCCU0_CH4 {
type Target = bccu0_ch0::RegisterBlock;
fn deref(&self) -> &bccu0_ch0::RegisterBlock {
unsafe { &*BCCU0_CH4::ptr() }
}
}
#[doc = "BCCU Unit 0"]
pub struct BCCU0_CH5 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for BCCU0_CH5 {}
impl BCCU0_CH5 {
#[doc = r" Returns a pointer to the register block"]
pub fn ptr() -> *const bccu0_ch0::RegisterBlock {
1342374048 as *const _
}
}
impl Deref for BCCU0_CH5 {
type Target = bccu0_ch0::RegisterBlock;
fn deref(&self) -> &bccu0_ch0::RegisterBlock {
unsafe { &*BCCU0_CH5::ptr() }
}
}
#[doc = "BCCU Unit 0"]
pub struct BCCU0_CH6 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for BCCU0_CH6 {}
impl BCCU0_CH6 {
#[doc = r" Returns a pointer to the register block"]
pub fn ptr() -> *const bccu0_ch0::RegisterBlock {
1342374068 as *const _
}
}
impl Deref for BCCU0_CH6 {
type Target = bccu0_ch0::RegisterBlock;
fn deref(&self) -> &bccu0_ch0::RegisterBlock {
unsafe { &*BCCU0_CH6::ptr() }
}
}
#[doc = "BCCU Unit 0"]
pub struct BCCU0_CH7 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for BCCU0_CH7 {}
impl BCCU0_CH7 {
#[doc = r" Returns a pointer to the register block"]
pub fn ptr() -> *const bccu0_ch0::RegisterBlock {
1342374088 as *const _
}
}
impl Deref for BCCU0_CH7 {
type Target = bccu0_ch0::RegisterBlock;
fn deref(&self) -> &bccu0_ch0::RegisterBlock {
unsafe { &*BCCU0_CH7::ptr() }
}
}
#[doc = "BCCU Unit 0"]
pub struct BCCU0_CH8 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for BCCU0_CH8 {}
impl BCCU0_CH8 {
#[doc = r" Returns a pointer to the register block"]
pub fn ptr() -> *const bccu0_ch0::RegisterBlock {
1342374108 as *const _
}
}
impl Deref for BCCU0_CH8 {
type Target = bccu0_ch0::RegisterBlock;
fn deref(&self) -> &bccu0_ch0::RegisterBlock {
unsafe { &*BCCU0_CH8::ptr() }
}
}
#[doc = "BCCU Unit 0"]
pub struct BCCU0_DE0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for BCCU0_DE0 {}
impl BCCU0_DE0 {
#[doc = r" Returns a pointer to the register block"]
pub fn ptr() -> *const bccu0_de0::RegisterBlock {
1342374268 as *const _
}
}
impl Deref for BCCU0_DE0 {
type Target = bccu0_de0::RegisterBlock;
fn deref(&self) -> &bccu0_de0::RegisterBlock {
unsafe { &*BCCU0_DE0::ptr() }
}
}
#[doc = "BCCU Unit 0"]
pub mod bccu0_de0;
#[doc = "BCCU Unit 0"]
pub struct BCCU0_DE1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for BCCU0_DE1 {}
impl BCCU0_DE1 {
#[doc = r" Returns a pointer to the register block"]
pub fn ptr() -> *const bccu0_de0::RegisterBlock {
1342374280 as *const _
}
}
impl Deref for BCCU0_DE1 {
type Target = bccu0_de0::RegisterBlock;
fn deref(&self) -> &bccu0_de0::RegisterBlock {
unsafe { &*BCCU0_DE1::ptr() }
}
}
#[doc = "BCCU Unit 0"]
pub struct BCCU0_DE2 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for BCCU0_DE2 {}
impl BCCU0_DE2 {
#[doc = r" Returns a pointer to the register block"]
pub fn ptr() -> *const bccu0_de0::RegisterBlock {
1342374292 as *const _
}
}
impl Deref for BCCU0_DE2 {
type Target = bccu0_de0::RegisterBlock;
fn deref(&self) -> &bccu0_de0::RegisterBlock {
unsafe { &*BCCU0_DE2::ptr() }
}
}
#[doc = "Port 0"]
pub struct PORT0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PORT0 {}
impl PORT0 {
#[doc = r" Returns a pointer to the register block"]
pub fn ptr() -> *const port0::RegisterBlock {
1074003968 as *const _
}
}
impl Deref for PORT0 {
type Target = port0::RegisterBlock;
fn deref(&self) -> &port0::RegisterBlock {
unsafe { &*PORT0::ptr() }
}
}
#[doc = "Port 0"]
pub mod port0;
#[doc = "Port 1"]
pub struct PORT1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PORT1 {}
impl PORT1 {
#[doc = r" Returns a pointer to the register block"]
pub fn ptr() -> *const port1::RegisterBlock {
1074004224 as *const _
}
}
impl Deref for PORT1 {
type Target = port1::RegisterBlock;
fn deref(&self) -> &port1::RegisterBlock {
unsafe { &*PORT1::ptr() }
}
}
#[doc = "Port 1"]
pub mod port1;
#[doc = "Port 2"]
pub struct PORT2 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PORT2 {}
impl PORT2 {
#[doc = r" Returns a pointer to the register block"]
pub fn ptr() -> *const port2::RegisterBlock {
1074004480 as *const _
}
}
impl Deref for PORT2 {
type Target = port2::RegisterBlock;
fn deref(&self) -> &port2::RegisterBlock {
unsafe { &*PORT2::ptr() }
}
}
#[doc = "Port 2"]
pub mod port2;
#[allow(private_no_mangle_statics)]
#[no_mangle]
static mut DEVICE_PERIPHERALS: bool = false;
#[doc = r" All the peripherals"]
#[allow(non_snake_case)]
pub struct Peripherals {
#[doc = "PPB"]
pub PPB: PPB,
#[doc = "ERU0"]
pub ERU0: ERU0,
#[doc = "MATH"]
pub MATH: MATH,
#[doc = "PAU"]
pub PAU: PAU,
#[doc = "NVM"]
pub NVM: NVM,
#[doc = "WDT"]
pub WDT: WDT,
#[doc = "RTC"]
pub RTC: RTC,
#[doc = "PRNG"]
pub PRNG: PRNG,
#[doc = "USIC0"]
pub USIC0: USIC0,
#[doc = "USIC0_CH0"]
pub USIC0_CH0: USIC0_CH0,
#[doc = "USIC0_CH1"]
pub USIC0_CH1: USIC0_CH1,
#[doc = "SCU_GENERAL"]
pub SCU_GENERAL: SCU_GENERAL,
#[doc = "SCU_INTERRUPT"]
pub SCU_INTERRUPT: SCU_INTERRUPT,
#[doc = "SCU_POWER"]
pub SCU_POWER: SCU_POWER,
#[doc = "SCU_CLK"]
pub SCU_CLK: SCU_CLK,
#[doc = "SCU_RESET"]
pub SCU_RESET: SCU_RESET,
#[doc = "COMPARATOR"]
pub COMPARATOR: COMPARATOR,
#[doc = "SCU_ANALOG"]
pub SCU_ANALOG: SCU_ANALOG,
#[doc = "CCU40"]
pub CCU40: CCU40,
#[doc = "CCU40_CC40"]
pub CCU40_CC40: CCU40_CC40,
#[doc = "CCU40_CC41"]
pub CCU40_CC41: CCU40_CC41,
#[doc = "CCU40_CC42"]
pub CCU40_CC42: CCU40_CC42,
#[doc = "CCU40_CC43"]
pub CCU40_CC43: CCU40_CC43,
#[doc = "CCU80"]
pub CCU80: CCU80,
#[doc = "CCU80_CC80"]
pub CCU80_CC80: CCU80_CC80,
#[doc = "CCU80_CC81"]
pub CCU80_CC81: CCU80_CC81,
#[doc = "CCU80_CC82"]
pub CCU80_CC82: CCU80_CC82,
#[doc = "CCU80_CC83"]
pub CCU80_CC83: CCU80_CC83,
#[doc = "POSIF0"]
pub POSIF0: POSIF0,
#[doc = "VADC"]
pub VADC: VADC,
#[doc = "VADC_G0"]
pub VADC_G0: VADC_G0,
#[doc = "VADC_G1"]
pub VADC_G1: VADC_G1,
#[doc = "SHS0"]
pub SHS0: SHS0,
#[doc = "BCCU0"]
pub BCCU0: BCCU0,
#[doc = "BCCU0_CH0"]
pub BCCU0_CH0: BCCU0_CH0,
#[doc = "BCCU0_CH1"]
pub BCCU0_CH1: BCCU0_CH1,
#[doc = "BCCU0_CH2"]
pub BCCU0_CH2: BCCU0_CH2,
#[doc = "BCCU0_CH3"]
pub BCCU0_CH3: BCCU0_CH3,
#[doc = "BCCU0_CH4"]
pub BCCU0_CH4: BCCU0_CH4,
#[doc = "BCCU0_CH5"]
pub BCCU0_CH5: BCCU0_CH5,
#[doc = "BCCU0_CH6"]
pub BCCU0_CH6: BCCU0_CH6,
#[doc = "BCCU0_CH7"]
pub BCCU0_CH7: BCCU0_CH7,
#[doc = "BCCU0_CH8"]
pub BCCU0_CH8: BCCU0_CH8,
#[doc = "BCCU0_DE0"]
pub BCCU0_DE0: BCCU0_DE0,
#[doc = "BCCU0_DE1"]
pub BCCU0_DE1: BCCU0_DE1,
#[doc = "BCCU0_DE2"]
pub BCCU0_DE2: BCCU0_DE2,
#[doc = "PORT0"]
pub PORT0: PORT0,
#[doc = "PORT1"]
pub PORT1: PORT1,
#[doc = "PORT2"]
pub PORT2: PORT2,
}
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`"]
pub unsafe fn steal() -> Self {
debug_assert!(!DEVICE_PERIPHERALS);
DEVICE_PERIPHERALS = true;
Peripherals {
PPB: PPB {
_marker: PhantomData,
},
ERU0: ERU0 {
_marker: PhantomData,
},
MATH: MATH {
_marker: PhantomData,
},
PAU: PAU {
_marker: PhantomData,
},
NVM: NVM {
_marker: PhantomData,
},
WDT: WDT {
_marker: PhantomData,
},
RTC: RTC {
_marker: PhantomData,
},
PRNG: PRNG {
_marker: PhantomData,
},
USIC0: USIC0 {
_marker: PhantomData,
},
USIC0_CH0: USIC0_CH0 {
_marker: PhantomData,
},
USIC0_CH1: USIC0_CH1 {
_marker: PhantomData,
},
SCU_GENERAL: SCU_GENERAL {
_marker: PhantomData,
},
SCU_INTERRUPT: SCU_INTERRUPT {
_marker: PhantomData,
},
SCU_POWER: SCU_POWER {
_marker: PhantomData,
},
SCU_CLK: SCU_CLK {
_marker: PhantomData,
},
SCU_RESET: SCU_RESET {
_marker: PhantomData,
},
COMPARATOR: COMPARATOR {
_marker: PhantomData,
},
SCU_ANALOG: SCU_ANALOG {
_marker: PhantomData,
},
CCU40: CCU40 {
_marker: PhantomData,
},
CCU40_CC40: CCU40_CC40 {
_marker: PhantomData,
},
CCU40_CC41: CCU40_CC41 {
_marker: PhantomData,
},
CCU40_CC42: CCU40_CC42 {
_marker: PhantomData,
},
CCU40_CC43: CCU40_CC43 {
_marker: PhantomData,
},
CCU80: CCU80 {
_marker: PhantomData,
},
CCU80_CC80: CCU80_CC80 {
_marker: PhantomData,
},
CCU80_CC81: CCU80_CC81 {
_marker: PhantomData,
},
CCU80_CC82: CCU80_CC82 {
_marker: PhantomData,
},
CCU80_CC83: CCU80_CC83 {
_marker: PhantomData,
},
POSIF0: POSIF0 {
_marker: PhantomData,
},
VADC: VADC {
_marker: PhantomData,
},
VADC_G0: VADC_G0 {
_marker: PhantomData,
},
VADC_G1: VADC_G1 {
_marker: PhantomData,
},
SHS0: SHS0 {
_marker: PhantomData,
},
BCCU0: BCCU0 {
_marker: PhantomData,
},
BCCU0_CH0: BCCU0_CH0 {
_marker: PhantomData,
},
BCCU0_CH1: BCCU0_CH1 {
_marker: PhantomData,
},
BCCU0_CH2: BCCU0_CH2 {
_marker: PhantomData,
},
BCCU0_CH3: BCCU0_CH3 {
_marker: PhantomData,
},
BCCU0_CH4: BCCU0_CH4 {
_marker: PhantomData,
},
BCCU0_CH5: BCCU0_CH5 {
_marker: PhantomData,
},
BCCU0_CH6: BCCU0_CH6 {
_marker: PhantomData,
},
BCCU0_CH7: BCCU0_CH7 {
_marker: PhantomData,
},
BCCU0_CH8: BCCU0_CH8 {
_marker: PhantomData,
},
BCCU0_DE0: BCCU0_DE0 {
_marker: PhantomData,
},
BCCU0_DE1: BCCU0_DE1 {
_marker: PhantomData,
},
BCCU0_DE2: BCCU0_DE2 {
_marker: PhantomData,
},
PORT0: PORT0 {
_marker: PhantomData,
},
PORT1: PORT1 {
_marker: PhantomData,
},
PORT2: PORT2 {
_marker: PhantomData,
},
}
}
}