#![doc = "Peripheral access API for SWM341 microcontrollers (generated using svd2rust v0.25.1 ( ))\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.25.1/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, FPU, ITM, MPU, NVIC, SCB, SYST, TPIU};
#[cfg(feature = "rt")]
pub use cortex_m_rt::interrupt;
#[allow(unused_imports)]
use generic::*;
#[doc = r"Common register and bit access and modify traits"]
pub mod generic;
#[cfg(feature = "rt")]
extern "C" {
fn UART0();
fn UART1();
fn TIMR0();
fn TIMR1();
fn DMA();
fn SPI0();
fn PWM_CH0();
fn WDT();
fn UART2();
fn PWM_CH1();
fn SARADC0();
fn BTIMER0();
fn HALL0();
fn PWM_CH2();
fn PWM_HALT();
fn I2C0();
fn CAN0();
fn SPI1();
fn RTC_BASE();
fn PWM_CH3();
fn TIMER2();
fn UART3();
fn TIMER3();
fn SARADC1();
fn BOD();
fn CORDIC();
fn BTIMER1();
fn PWM_CH4();
fn HALL1();
}
#[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; 29] = [
Vector { _handler: UART0 },
Vector { _handler: UART1 },
Vector { _handler: TIMR0 },
Vector { _handler: TIMR1 },
Vector { _handler: DMA },
Vector { _handler: SPI0 },
Vector { _handler: PWM_CH0 },
Vector { _handler: WDT },
Vector { _handler: UART2 },
Vector { _handler: PWM_CH1 },
Vector { _handler: SARADC0 },
Vector { _handler: BTIMER0 },
Vector { _handler: HALL0 },
Vector { _handler: PWM_CH2 },
Vector { _handler: PWM_HALT },
Vector { _handler: I2C0 },
Vector { _handler: CAN0 },
Vector { _handler: SPI1 },
Vector { _handler: RTC_BASE },
Vector { _handler: PWM_CH3 },
Vector { _handler: TIMER2 },
Vector { _handler: UART3 },
Vector { _handler: TIMER3 },
Vector { _handler: SARADC1 },
Vector { _handler: BOD },
Vector { _handler: CORDIC },
Vector { _handler: BTIMER1 },
Vector { _handler: PWM_CH4 },
Vector { _handler: HALL1 },
];
#[doc = r"Enumeration of all the interrupts."]
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
#[repr(u16)]
pub enum Interrupt {
#[doc = "0 - UART0 global interrupt"]
UART0 = 0,
#[doc = "1 - UART1 global interrupt"]
UART1 = 1,
#[doc = "2 - TIMR0 global interrupt"]
TIMR0 = 2,
#[doc = "3 - TIMR1 global interrupt"]
TIMR1 = 3,
#[doc = "4 - DMA global interrupt"]
DMA = 4,
#[doc = "5 - SPI0 global interrupt"]
SPI0 = 5,
#[doc = "6 - PWM_CH0 global interrupt"]
PWM_CH0 = 6,
#[doc = "7 - WDT global interrupt"]
WDT = 7,
#[doc = "8 - UART2 global interrupt"]
UART2 = 8,
#[doc = "9 - PWM_CH1 global interrupt"]
PWM_CH1 = 9,
#[doc = "10 - SARADC0 global interrupt"]
SARADC0 = 10,
#[doc = "11 - BTIMER0 global interrupt"]
BTIMER0 = 11,
#[doc = "12 - HALL0 global interrupt"]
HALL0 = 12,
#[doc = "13 - PWM_CH2 global interrupt"]
PWM_CH2 = 13,
#[doc = "14 - PWM_HALT global interrupt"]
PWM_HALT = 14,
#[doc = "15 - I2C0 global interrupt"]
I2C0 = 15,
#[doc = "16 - CAN0 global interrupt"]
CAN0 = 16,
#[doc = "17 - SPI1 global interrupt"]
SPI1 = 17,
#[doc = "18 - RTC_BASE global interrupt"]
RTC_BASE = 18,
#[doc = "19 - PWM_CH3 global interrupt"]
PWM_CH3 = 19,
#[doc = "20 - TIMER2 global interrupt"]
TIMER2 = 20,
#[doc = "21 - UART3 global interrupt"]
UART3 = 21,
#[doc = "22 - TIMER3 global interrupt"]
TIMER3 = 22,
#[doc = "23 - SARADC1 global interrupt"]
SARADC1 = 23,
#[doc = "24 - BOD global interrupt"]
BOD = 24,
#[doc = "25 - CORDIC global interrupt"]
CORDIC = 25,
#[doc = "26 - BTIMER1 global interrupt"]
BTIMER1 = 26,
#[doc = "27 - PWM_CH4 global interrupt"]
PWM_CH4 = 27,
#[doc = "28 - HALL1 global interrupt"]
HALL1 = 28,
}
unsafe impl cortex_m::interrupt::InterruptNumber for Interrupt {
#[inline(always)]
fn number(self) -> u16 {
self as u16
}
}
#[doc = "Registers group"]
pub struct SYS {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SYS {}
impl SYS {
#[doc = r"Pointer to the register block"]
pub const PTR: *const sys::RegisterBlock = 0x4000_0000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const sys::RegisterBlock {
Self::PTR
}
}
impl Deref for SYS {
type Target = sys::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for SYS {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("SYS").finish()
}
}
#[doc = "Registers group"]
pub mod sys;
#[doc = "Registers group"]
pub struct PORTA {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PORTA {}
impl PORTA {
#[doc = r"Pointer to the register block"]
pub const PTR: *const porta::RegisterBlock = 0x400a_0000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const porta::RegisterBlock {
Self::PTR
}
}
impl Deref for PORTA {
type Target = porta::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for PORTA {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("PORTA").finish()
}
}
#[doc = "Registers group"]
pub mod porta;
#[doc = "Registers group"]
pub struct PORTB {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PORTB {}
impl PORTB {
#[doc = r"Pointer to the register block"]
pub const PTR: *const porta::RegisterBlock = 0x400a_0010 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const porta::RegisterBlock {
Self::PTR
}
}
impl Deref for PORTB {
type Target = porta::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for PORTB {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("PORTB").finish()
}
}
#[doc = "Registers group"]
pub use porta as portb;
#[doc = "Registers group"]
pub struct PORTC {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PORTC {}
impl PORTC {
#[doc = r"Pointer to the register block"]
pub const PTR: *const porta::RegisterBlock = 0x400a_0020 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const porta::RegisterBlock {
Self::PTR
}
}
impl Deref for PORTC {
type Target = porta::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for PORTC {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("PORTC").finish()
}
}
#[doc = "Registers group"]
pub use porta as portc;
#[doc = "Registers group"]
pub struct PORTD {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PORTD {}
impl PORTD {
#[doc = r"Pointer to the register block"]
pub const PTR: *const porta::RegisterBlock = 0x400a_0030 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const porta::RegisterBlock {
Self::PTR
}
}
impl Deref for PORTD {
type Target = porta::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for PORTD {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("PORTD").finish()
}
}
#[doc = "Registers group"]
pub use porta as portd;
#[doc = "Registers group"]
pub struct PORTE {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PORTE {}
impl PORTE {
#[doc = r"Pointer to the register block"]
pub const PTR: *const porta::RegisterBlock = 0x400a_0040 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const porta::RegisterBlock {
Self::PTR
}
}
impl Deref for PORTE {
type Target = porta::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for PORTE {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("PORTE").finish()
}
}
#[doc = "Registers group"]
pub use porta as porte;
#[doc = "Registers group"]
pub struct PORTM {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PORTM {}
impl PORTM {
#[doc = r"Pointer to the register block"]
pub const PTR: *const porta::RegisterBlock = 0x400a_0080 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const porta::RegisterBlock {
Self::PTR
}
}
impl Deref for PORTM {
type Target = porta::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for PORTM {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("PORTM").finish()
}
}
#[doc = "Registers group"]
pub use porta as portm;
#[doc = "Registers group"]
pub struct PORTN {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PORTN {}
impl PORTN {
#[doc = r"Pointer to the register block"]
pub const PTR: *const porta::RegisterBlock = 0x400a_0090 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const porta::RegisterBlock {
Self::PTR
}
}
impl Deref for PORTN {
type Target = porta::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for PORTN {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("PORTN").finish()
}
}
#[doc = "Registers group"]
pub use porta as portn;
#[doc = "Registers group"]
pub struct GPIOA {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for GPIOA {}
impl GPIOA {
#[doc = r"Pointer to the register block"]
pub const PTR: *const gpioa::RegisterBlock = 0x4004_0000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const gpioa::RegisterBlock {
Self::PTR
}
}
impl Deref for GPIOA {
type Target = gpioa::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for GPIOA {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("GPIOA").finish()
}
}
#[doc = "Registers group"]
pub mod gpioa;
#[doc = "Registers group"]
pub struct GPIOB {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for GPIOB {}
impl GPIOB {
#[doc = r"Pointer to the register block"]
pub const PTR: *const gpioa::RegisterBlock = 0x4004_0800 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const gpioa::RegisterBlock {
Self::PTR
}
}
impl Deref for GPIOB {
type Target = gpioa::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for GPIOB {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("GPIOB").finish()
}
}
#[doc = "Registers group"]
pub use gpioa as gpiob;
#[doc = "Registers group"]
pub struct GPIOC {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for GPIOC {}
impl GPIOC {
#[doc = r"Pointer to the register block"]
pub const PTR: *const gpioa::RegisterBlock = 0x4004_1000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const gpioa::RegisterBlock {
Self::PTR
}
}
impl Deref for GPIOC {
type Target = gpioa::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for GPIOC {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("GPIOC").finish()
}
}
#[doc = "Registers group"]
pub use gpioa as gpioc;
#[doc = "Registers group"]
pub struct GPIOD {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for GPIOD {}
impl GPIOD {
#[doc = r"Pointer to the register block"]
pub const PTR: *const gpioa::RegisterBlock = 0x4004_1800 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const gpioa::RegisterBlock {
Self::PTR
}
}
impl Deref for GPIOD {
type Target = gpioa::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for GPIOD {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("GPIOD").finish()
}
}
#[doc = "Registers group"]
pub use gpioa as gpiod;
#[doc = "Registers group"]
pub struct GPIOE {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for GPIOE {}
impl GPIOE {
#[doc = r"Pointer to the register block"]
pub const PTR: *const gpioa::RegisterBlock = 0x400a_1000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const gpioa::RegisterBlock {
Self::PTR
}
}
impl Deref for GPIOE {
type Target = gpioa::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for GPIOE {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("GPIOE").finish()
}
}
#[doc = "Registers group"]
pub use gpioa as gpioe;
#[doc = "Registers group"]
pub struct GPIOM {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for GPIOM {}
impl GPIOM {
#[doc = r"Pointer to the register block"]
pub const PTR: *const gpioa::RegisterBlock = 0x4000_4000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const gpioa::RegisterBlock {
Self::PTR
}
}
impl Deref for GPIOM {
type Target = gpioa::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for GPIOM {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("GPIOM").finish()
}
}
#[doc = "Registers group"]
pub use gpioa as gpiom;
#[doc = "Registers group"]
pub struct GPION {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for GPION {}
impl GPION {
#[doc = r"Pointer to the register block"]
pub const PTR: *const gpioa::RegisterBlock = 0x4000_4800 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const gpioa::RegisterBlock {
Self::PTR
}
}
impl Deref for GPION {
type Target = gpioa::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for GPION {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("GPION").finish()
}
}
#[doc = "Registers group"]
pub use gpioa as gpion;
#[doc = "Registers group"]
pub struct TIMR0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for TIMR0 {}
impl TIMR0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const timr0::RegisterBlock = 0x4004_6800 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const timr0::RegisterBlock {
Self::PTR
}
}
impl Deref for TIMR0 {
type Target = timr0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for TIMR0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("TIMR0").finish()
}
}
#[doc = "Registers group"]
pub mod timr0;
#[doc = "Registers group"]
pub struct TIMR1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for TIMR1 {}
impl TIMR1 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const timr0::RegisterBlock = 0x4004_6840 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const timr0::RegisterBlock {
Self::PTR
}
}
impl Deref for TIMR1 {
type Target = timr0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for TIMR1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("TIMR1").finish()
}
}
#[doc = "Registers group"]
pub use timr0 as timr1;
#[doc = "Registers group"]
pub struct TIMR2 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for TIMR2 {}
impl TIMR2 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const timr0::RegisterBlock = 0x4004_6880 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const timr0::RegisterBlock {
Self::PTR
}
}
impl Deref for TIMR2 {
type Target = timr0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for TIMR2 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("TIMR2").finish()
}
}
#[doc = "Registers group"]
pub use timr0 as timr2;
#[doc = "Registers group"]
pub struct TIMR3 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for TIMR3 {}
impl TIMR3 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const timr0::RegisterBlock = 0x4004_68c0 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const timr0::RegisterBlock {
Self::PTR
}
}
impl Deref for TIMR3 {
type Target = timr0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for TIMR3 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("TIMR3").finish()
}
}
#[doc = "Registers group"]
pub use timr0 as timr3;
#[doc = "Registers group"]
pub struct TIMR4 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for TIMR4 {}
impl TIMR4 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const timr0::RegisterBlock = 0x4004_6900 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const timr0::RegisterBlock {
Self::PTR
}
}
impl Deref for TIMR4 {
type Target = timr0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for TIMR4 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("TIMR4").finish()
}
}
#[doc = "Registers group"]
pub use timr0 as timr4;
#[doc = "Registers group"]
pub struct TIMRG {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for TIMRG {}
impl TIMRG {
#[doc = r"Pointer to the register block"]
pub const PTR: *const timrg::RegisterBlock = 0x4004_6c00 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const timrg::RegisterBlock {
Self::PTR
}
}
impl Deref for TIMRG {
type Target = timrg::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for TIMRG {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("TIMRG").finish()
}
}
#[doc = "Registers group"]
pub mod timrg;
#[doc = "Registers group"]
pub struct BTIMR0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for BTIMR0 {}
impl BTIMR0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const timr0::RegisterBlock = 0x4004_8800 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const timr0::RegisterBlock {
Self::PTR
}
}
impl Deref for BTIMR0 {
type Target = timr0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for BTIMR0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("BTIMR0").finish()
}
}
#[doc = "Registers group"]
pub use timr0 as btimr0;
#[doc = "Registers group"]
pub struct BTIMR1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for BTIMR1 {}
impl BTIMR1 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const timr0::RegisterBlock = 0x4004_8840 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const timr0::RegisterBlock {
Self::PTR
}
}
impl Deref for BTIMR1 {
type Target = timr0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for BTIMR1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("BTIMR1").finish()
}
}
#[doc = "Registers group"]
pub use timr0 as btimr1;
#[doc = "Registers group"]
pub struct BTIMR2 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for BTIMR2 {}
impl BTIMR2 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const timr0::RegisterBlock = 0x4004_8880 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const timr0::RegisterBlock {
Self::PTR
}
}
impl Deref for BTIMR2 {
type Target = timr0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for BTIMR2 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("BTIMR2").finish()
}
}
#[doc = "Registers group"]
pub use timr0 as btimr2;
#[doc = "Registers group"]
pub struct BTIMR3 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for BTIMR3 {}
impl BTIMR3 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const timr0::RegisterBlock = 0x4004_88c0 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const timr0::RegisterBlock {
Self::PTR
}
}
impl Deref for BTIMR3 {
type Target = timr0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for BTIMR3 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("BTIMR3").finish()
}
}
#[doc = "Registers group"]
pub use timr0 as btimr3;
#[doc = "Registers group"]
pub struct BTIMR4 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for BTIMR4 {}
impl BTIMR4 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const timr0::RegisterBlock = 0x4004_8900 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const timr0::RegisterBlock {
Self::PTR
}
}
impl Deref for BTIMR4 {
type Target = timr0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for BTIMR4 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("BTIMR4").finish()
}
}
#[doc = "Registers group"]
pub use timr0 as btimr4;
#[doc = "Registers group"]
pub struct BTIMR5 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for BTIMR5 {}
impl BTIMR5 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const timr0::RegisterBlock = 0x4004_8940 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const timr0::RegisterBlock {
Self::PTR
}
}
impl Deref for BTIMR5 {
type Target = timr0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for BTIMR5 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("BTIMR5").finish()
}
}
#[doc = "Registers group"]
pub use timr0 as btimr5;
#[doc = "Registers group"]
pub struct BTIMR6 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for BTIMR6 {}
impl BTIMR6 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const timr0::RegisterBlock = 0x4004_8980 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const timr0::RegisterBlock {
Self::PTR
}
}
impl Deref for BTIMR6 {
type Target = timr0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for BTIMR6 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("BTIMR6").finish()
}
}
#[doc = "Registers group"]
pub use timr0 as btimr6;
#[doc = "Registers group"]
pub struct BTIMR7 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for BTIMR7 {}
impl BTIMR7 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const timr0::RegisterBlock = 0x4004_89c0 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const timr0::RegisterBlock {
Self::PTR
}
}
impl Deref for BTIMR7 {
type Target = timr0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for BTIMR7 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("BTIMR7").finish()
}
}
#[doc = "Registers group"]
pub use timr0 as btimr7;
#[doc = "Registers group"]
pub struct BTIMR8 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for BTIMR8 {}
impl BTIMR8 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const timr0::RegisterBlock = 0x4004_8a00 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const timr0::RegisterBlock {
Self::PTR
}
}
impl Deref for BTIMR8 {
type Target = timr0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for BTIMR8 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("BTIMR8").finish()
}
}
#[doc = "Registers group"]
pub use timr0 as btimr8;
#[doc = "Registers group"]
pub struct BTIMR9 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for BTIMR9 {}
impl BTIMR9 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const timr0::RegisterBlock = 0x4004_8a40 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const timr0::RegisterBlock {
Self::PTR
}
}
impl Deref for BTIMR9 {
type Target = timr0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for BTIMR9 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("BTIMR9").finish()
}
}
#[doc = "Registers group"]
pub use timr0 as btimr9;
#[doc = "Registers group"]
pub struct BTIMR10 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for BTIMR10 {}
impl BTIMR10 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const timr0::RegisterBlock = 0x4004_8a80 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const timr0::RegisterBlock {
Self::PTR
}
}
impl Deref for BTIMR10 {
type Target = timr0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for BTIMR10 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("BTIMR10").finish()
}
}
#[doc = "Registers group"]
pub use timr0 as btimr10;
#[doc = "Registers group"]
pub struct BTIMR11 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for BTIMR11 {}
impl BTIMR11 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const timr0::RegisterBlock = 0x4004_8ac0 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const timr0::RegisterBlock {
Self::PTR
}
}
impl Deref for BTIMR11 {
type Target = timr0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for BTIMR11 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("BTIMR11").finish()
}
}
#[doc = "Registers group"]
pub use timr0 as btimr11;
#[doc = "Registers group"]
pub struct BTIMRG {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for BTIMRG {}
impl BTIMRG {
#[doc = r"Pointer to the register block"]
pub const PTR: *const timrg::RegisterBlock = 0x4004_8c00 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const timrg::RegisterBlock {
Self::PTR
}
}
impl Deref for BTIMRG {
type Target = timrg::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for BTIMRG {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("BTIMRG").finish()
}
}
#[doc = "Registers group"]
pub use timrg as btimrg;
#[doc = "Registers group"]
pub struct UART0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for UART0 {}
impl UART0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const uart0::RegisterBlock = 0x4004_2000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const uart0::RegisterBlock {
Self::PTR
}
}
impl Deref for UART0 {
type Target = uart0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for UART0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("UART0").finish()
}
}
#[doc = "Registers group"]
pub mod uart0;
#[doc = "Registers group"]
pub struct UART1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for UART1 {}
impl UART1 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const uart0::RegisterBlock = 0x4004_2800 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const uart0::RegisterBlock {
Self::PTR
}
}
impl Deref for UART1 {
type Target = uart0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for UART1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("UART1").finish()
}
}
#[doc = "Registers group"]
pub use uart0 as uart1;
#[doc = "Registers group"]
pub struct UART2 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for UART2 {}
impl UART2 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const uart0::RegisterBlock = 0x4004_3000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const uart0::RegisterBlock {
Self::PTR
}
}
impl Deref for UART2 {
type Target = uart0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for UART2 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("UART2").finish()
}
}
#[doc = "Registers group"]
pub use uart0 as uart2;
#[doc = "Registers group"]
pub struct UART3 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for UART3 {}
impl UART3 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const uart0::RegisterBlock = 0x4004_3800 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const uart0::RegisterBlock {
Self::PTR
}
}
impl Deref for UART3 {
type Target = uart0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for UART3 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("UART3").finish()
}
}
#[doc = "Registers group"]
pub use uart0 as uart3;
#[doc = "Registers group"]
pub struct SPI0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SPI0 {}
impl SPI0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const spi0::RegisterBlock = 0x4004_4000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const spi0::RegisterBlock {
Self::PTR
}
}
impl Deref for SPI0 {
type Target = spi0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for SPI0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("SPI0").finish()
}
}
#[doc = "Registers group"]
pub mod spi0;
#[doc = "Registers group"]
pub struct SPI1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SPI1 {}
impl SPI1 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const spi0::RegisterBlock = 0x4004_4800 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const spi0::RegisterBlock {
Self::PTR
}
}
impl Deref for SPI1 {
type Target = spi0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for SPI1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("SPI1").finish()
}
}
#[doc = "Registers group"]
pub use spi0 as spi1;
#[doc = "Registers group"]
pub struct I2C0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for I2C0 {}
impl I2C0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const i2c0::RegisterBlock = 0x400a_6000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const i2c0::RegisterBlock {
Self::PTR
}
}
impl Deref for I2C0 {
type Target = i2c0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for I2C0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("I2C0").finish()
}
}
#[doc = "Registers group"]
pub mod i2c0;
#[doc = "Registers group"]
pub struct I2C1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for I2C1 {}
impl I2C1 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const i2c0::RegisterBlock = 0x400a_6800 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const i2c0::RegisterBlock {
Self::PTR
}
}
impl Deref for I2C1 {
type Target = i2c0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for I2C1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("I2C1").finish()
}
}
#[doc = "Registers group"]
pub use i2c0 as i2c1;
#[doc = "Registers group"]
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 = 0x4004_9000 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 = "Registers group"]
pub mod adc0;
#[doc = "Registers group"]
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 = 0x4004_9800 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 = "Registers group"]
pub use adc0 as adc1;
#[doc = "Registers group"]
pub struct PWM0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PWM0 {}
impl PWM0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const pwm0::RegisterBlock = 0x4004_6000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const pwm0::RegisterBlock {
Self::PTR
}
}
impl Deref for PWM0 {
type Target = pwm0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for PWM0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("PWM0").finish()
}
}
#[doc = "Registers group"]
pub mod pwm0;
#[doc = "Registers group"]
pub struct PWM1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PWM1 {}
impl PWM1 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const pwm0::RegisterBlock = 0x4004_6080 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const pwm0::RegisterBlock {
Self::PTR
}
}
impl Deref for PWM1 {
type Target = pwm0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for PWM1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("PWM1").finish()
}
}
#[doc = "Registers group"]
pub use pwm0 as pwm1;
#[doc = "Registers group"]
pub struct PWM2 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PWM2 {}
impl PWM2 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const pwm0::RegisterBlock = 0x4004_6100 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const pwm0::RegisterBlock {
Self::PTR
}
}
impl Deref for PWM2 {
type Target = pwm0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for PWM2 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("PWM2").finish()
}
}
#[doc = "Registers group"]
pub use pwm0 as pwm2;
#[doc = "Registers group"]
pub struct PWM3 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PWM3 {}
impl PWM3 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const pwm0::RegisterBlock = 0x4004_6180 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const pwm0::RegisterBlock {
Self::PTR
}
}
impl Deref for PWM3 {
type Target = pwm0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for PWM3 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("PWM3").finish()
}
}
#[doc = "Registers group"]
pub use pwm0 as pwm3;
#[doc = "Registers group"]
pub struct PWM4 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PWM4 {}
impl PWM4 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const pwm0::RegisterBlock = 0x4004_6200 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const pwm0::RegisterBlock {
Self::PTR
}
}
impl Deref for PWM4 {
type Target = pwm0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for PWM4 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("PWM4").finish()
}
}
#[doc = "Registers group"]
pub use pwm0 as pwm4;
#[doc = "Registers group"]
pub struct PWMG {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PWMG {}
impl PWMG {
#[doc = r"Pointer to the register block"]
pub const PTR: *const pwmg::RegisterBlock = 0x4004_6400 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const pwmg::RegisterBlock {
Self::PTR
}
}
impl Deref for PWMG {
type Target = pwmg::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for PWMG {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("PWMG").finish()
}
}
#[doc = "Registers group"]
pub mod pwmg;
#[doc = "Registers group"]
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 = 0x400a_8000 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 = "Registers group"]
pub mod can0;
#[doc = "Registers group"]
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 = 0x400a_8800 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 = "Registers group"]
pub use can0 as can1;
#[doc = "Registers group"]
pub struct USBD {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for USBD {}
impl USBD {
#[doc = r"Pointer to the register block"]
pub const PTR: *const usbd::RegisterBlock = 0x4000_5000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const usbd::RegisterBlock {
Self::PTR
}
}
impl Deref for USBD {
type Target = usbd::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for USBD {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("USBD").finish()
}
}
#[doc = "Registers group"]
pub mod usbd;
#[doc = "Registers group"]
pub struct USBH {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for USBH {}
impl USBH {
#[doc = r"Pointer to the register block"]
pub const PTR: *const usbh::RegisterBlock = 0x4000_5000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const usbh::RegisterBlock {
Self::PTR
}
}
impl Deref for USBH {
type Target = usbh::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for USBH {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("USBH").finish()
}
}
#[doc = "Registers group"]
pub mod usbh;
#[doc = "Registers group"]
pub struct SDIO {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SDIO {}
impl SDIO {
#[doc = r"Pointer to the register block"]
pub const PTR: *const sdio::RegisterBlock = 0x4000_1800 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const sdio::RegisterBlock {
Self::PTR
}
}
impl Deref for SDIO {
type Target = sdio::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for SDIO {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("SDIO").finish()
}
}
#[doc = "Registers group"]
pub mod sdio;
#[doc = "Registers group"]
pub struct SDRAMC {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SDRAMC {}
impl SDRAMC {
#[doc = r"Pointer to the register block"]
pub const PTR: *const sdramc::RegisterBlock = 0x8800_0000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const sdramc::RegisterBlock {
Self::PTR
}
}
impl Deref for SDRAMC {
type Target = sdramc::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for SDRAMC {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("SDRAMC").finish()
}
}
#[doc = "Registers group"]
pub mod sdramc;
#[doc = "Registers group"]
pub struct DMA {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for DMA {}
impl DMA {
#[doc = r"Pointer to the register block"]
pub const PTR: *const dma::RegisterBlock = 0x4000_0800 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const dma::RegisterBlock {
Self::PTR
}
}
impl Deref for DMA {
type Target = dma::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for DMA {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("DMA").finish()
}
}
#[doc = "Registers group"]
pub mod dma;
#[doc = "Registers group"]
pub struct LCD {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for LCD {}
impl LCD {
#[doc = r"Pointer to the register block"]
pub const PTR: *const lcd::RegisterBlock = 0x4000_2000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const lcd::RegisterBlock {
Self::PTR
}
}
impl Deref for LCD {
type Target = lcd::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for LCD {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("LCD").finish()
}
}
#[doc = "Registers group"]
pub mod lcd;
#[doc = "Registers group"]
pub struct DMA2D {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for DMA2D {}
impl DMA2D {
#[doc = r"Pointer to the register block"]
pub const PTR: *const dma2d::RegisterBlock = 0x4000_c000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const dma2d::RegisterBlock {
Self::PTR
}
}
impl Deref for DMA2D {
type Target = dma2d::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for DMA2D {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("DMA2D").finish()
}
}
#[doc = "Registers group"]
pub mod dma2d;
#[doc = "Registers group"]
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 = 0x4004_c000 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 = "Registers group"]
pub mod dac;
#[doc = "Registers group"]
pub struct CRC {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for CRC {}
impl CRC {
#[doc = r"Pointer to the register block"]
pub const PTR: *const crc::RegisterBlock = 0x4000_2800 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const crc::RegisterBlock {
Self::PTR
}
}
impl Deref for CRC {
type Target = crc::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for CRC {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("CRC").finish()
}
}
#[doc = "Registers group"]
pub mod crc;
#[doc = "Registers group"]
pub struct CORDIC {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for CORDIC {}
impl CORDIC {
#[doc = r"Pointer to the register block"]
pub const PTR: *const cordic::RegisterBlock = 0x4000_3000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const cordic::RegisterBlock {
Self::PTR
}
}
impl Deref for CORDIC {
type Target = cordic::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for CORDIC {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("CORDIC").finish()
}
}
#[doc = "Registers group"]
pub mod cordic;
#[doc = "Registers group"]
pub struct DIV {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for DIV {}
impl DIV {
#[doc = r"Pointer to the register block"]
pub const PTR: *const div::RegisterBlock = 0x4000_3800 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const div::RegisterBlock {
Self::PTR
}
}
impl Deref for DIV {
type Target = div::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for DIV {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("DIV").finish()
}
}
#[doc = "Registers group"]
pub mod div;
#[doc = "Registers group"]
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 = 0x4004_b800 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 = "Registers group"]
pub mod rtc;
#[doc = "Registers group"]
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 = 0x400a_0800 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 = "Registers group"]
pub mod wdt;
#[doc = "Registers group"]
pub struct QEI {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for QEI {}
impl QEI {
#[doc = r"Pointer to the register block"]
pub const PTR: *const qei::RegisterBlock = 0x4004_c800 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const qei::RegisterBlock {
Self::PTR
}
}
impl Deref for QEI {
type Target = qei::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for QEI {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("QEI").finish()
}
}
#[doc = "Registers group"]
pub mod qei;
#[doc = "Registers group"]
pub struct FMC {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for FMC {}
impl FMC {
#[doc = r"Pointer to the register block"]
pub const PTR: *const fmc::RegisterBlock = 0x4004_a000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const fmc::RegisterBlock {
Self::PTR
}
}
impl Deref for FMC {
type Target = fmc::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for FMC {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("FMC").finish()
}
}
#[doc = "Registers group"]
pub mod fmc;
#[doc = "Registers group"]
pub struct SFC {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SFC {}
impl SFC {
#[doc = r"Pointer to the register block"]
pub const PTR: *const sfc::RegisterBlock = 0x4004_a800 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const sfc::RegisterBlock {
Self::PTR
}
}
impl Deref for SFC {
type Target = sfc::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for SFC {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("SFC").finish()
}
}
#[doc = "Registers group"]
pub mod sfc;
#[doc = "Registers group"]
pub struct JPEG {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for JPEG {}
impl JPEG {
#[doc = r"Pointer to the register block"]
pub const PTR: *const jpeg::RegisterBlock = 0x4000_b000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const jpeg::RegisterBlock {
Self::PTR
}
}
impl Deref for JPEG {
type Target = jpeg::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for JPEG {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("JPEG").finish()
}
}
#[doc = "Registers group"]
pub mod jpeg;
#[no_mangle]
static mut DEVICE_PERIPHERALS: bool = false;
#[doc = r"All the peripherals"]
#[allow(non_snake_case)]
pub struct Peripherals {
#[doc = "SYS"]
pub SYS: SYS,
#[doc = "PORTA"]
pub PORTA: PORTA,
#[doc = "PORTB"]
pub PORTB: PORTB,
#[doc = "PORTC"]
pub PORTC: PORTC,
#[doc = "PORTD"]
pub PORTD: PORTD,
#[doc = "PORTE"]
pub PORTE: PORTE,
#[doc = "PORTM"]
pub PORTM: PORTM,
#[doc = "PORTN"]
pub PORTN: PORTN,
#[doc = "GPIOA"]
pub GPIOA: GPIOA,
#[doc = "GPIOB"]
pub GPIOB: GPIOB,
#[doc = "GPIOC"]
pub GPIOC: GPIOC,
#[doc = "GPIOD"]
pub GPIOD: GPIOD,
#[doc = "GPIOE"]
pub GPIOE: GPIOE,
#[doc = "GPIOM"]
pub GPIOM: GPIOM,
#[doc = "GPION"]
pub GPION: GPION,
#[doc = "TIMR0"]
pub TIMR0: TIMR0,
#[doc = "TIMR1"]
pub TIMR1: TIMR1,
#[doc = "TIMR2"]
pub TIMR2: TIMR2,
#[doc = "TIMR3"]
pub TIMR3: TIMR3,
#[doc = "TIMR4"]
pub TIMR4: TIMR4,
#[doc = "TIMRG"]
pub TIMRG: TIMRG,
#[doc = "BTIMR0"]
pub BTIMR0: BTIMR0,
#[doc = "BTIMR1"]
pub BTIMR1: BTIMR1,
#[doc = "BTIMR2"]
pub BTIMR2: BTIMR2,
#[doc = "BTIMR3"]
pub BTIMR3: BTIMR3,
#[doc = "BTIMR4"]
pub BTIMR4: BTIMR4,
#[doc = "BTIMR5"]
pub BTIMR5: BTIMR5,
#[doc = "BTIMR6"]
pub BTIMR6: BTIMR6,
#[doc = "BTIMR7"]
pub BTIMR7: BTIMR7,
#[doc = "BTIMR8"]
pub BTIMR8: BTIMR8,
#[doc = "BTIMR9"]
pub BTIMR9: BTIMR9,
#[doc = "BTIMR10"]
pub BTIMR10: BTIMR10,
#[doc = "BTIMR11"]
pub BTIMR11: BTIMR11,
#[doc = "BTIMRG"]
pub BTIMRG: BTIMRG,
#[doc = "UART0"]
pub UART0: UART0,
#[doc = "UART1"]
pub UART1: UART1,
#[doc = "UART2"]
pub UART2: UART2,
#[doc = "UART3"]
pub UART3: UART3,
#[doc = "SPI0"]
pub SPI0: SPI0,
#[doc = "SPI1"]
pub SPI1: SPI1,
#[doc = "I2C0"]
pub I2C0: I2C0,
#[doc = "I2C1"]
pub I2C1: I2C1,
#[doc = "ADC0"]
pub ADC0: ADC0,
#[doc = "ADC1"]
pub ADC1: ADC1,
#[doc = "PWM0"]
pub PWM0: PWM0,
#[doc = "PWM1"]
pub PWM1: PWM1,
#[doc = "PWM2"]
pub PWM2: PWM2,
#[doc = "PWM3"]
pub PWM3: PWM3,
#[doc = "PWM4"]
pub PWM4: PWM4,
#[doc = "PWMG"]
pub PWMG: PWMG,
#[doc = "CAN0"]
pub CAN0: CAN0,
#[doc = "CAN1"]
pub CAN1: CAN1,
#[doc = "USBD"]
pub USBD: USBD,
#[doc = "USBH"]
pub USBH: USBH,
#[doc = "SDIO"]
pub SDIO: SDIO,
#[doc = "SDRAMC"]
pub SDRAMC: SDRAMC,
#[doc = "DMA"]
pub DMA: DMA,
#[doc = "LCD"]
pub LCD: LCD,
#[doc = "DMA2D"]
pub DMA2D: DMA2D,
#[doc = "DAC"]
pub DAC: DAC,
#[doc = "CRC"]
pub CRC: CRC,
#[doc = "CORDIC"]
pub CORDIC: CORDIC,
#[doc = "DIV"]
pub DIV: DIV,
#[doc = "RTC"]
pub RTC: RTC,
#[doc = "WDT"]
pub WDT: WDT,
#[doc = "QEI"]
pub QEI: QEI,
#[doc = "FMC"]
pub FMC: FMC,
#[doc = "SFC"]
pub SFC: SFC,
#[doc = "JPEG"]
pub JPEG: JPEG,
}
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 {
SYS: SYS {
_marker: PhantomData,
},
PORTA: PORTA {
_marker: PhantomData,
},
PORTB: PORTB {
_marker: PhantomData,
},
PORTC: PORTC {
_marker: PhantomData,
},
PORTD: PORTD {
_marker: PhantomData,
},
PORTE: PORTE {
_marker: PhantomData,
},
PORTM: PORTM {
_marker: PhantomData,
},
PORTN: PORTN {
_marker: PhantomData,
},
GPIOA: GPIOA {
_marker: PhantomData,
},
GPIOB: GPIOB {
_marker: PhantomData,
},
GPIOC: GPIOC {
_marker: PhantomData,
},
GPIOD: GPIOD {
_marker: PhantomData,
},
GPIOE: GPIOE {
_marker: PhantomData,
},
GPIOM: GPIOM {
_marker: PhantomData,
},
GPION: GPION {
_marker: PhantomData,
},
TIMR0: TIMR0 {
_marker: PhantomData,
},
TIMR1: TIMR1 {
_marker: PhantomData,
},
TIMR2: TIMR2 {
_marker: PhantomData,
},
TIMR3: TIMR3 {
_marker: PhantomData,
},
TIMR4: TIMR4 {
_marker: PhantomData,
},
TIMRG: TIMRG {
_marker: PhantomData,
},
BTIMR0: BTIMR0 {
_marker: PhantomData,
},
BTIMR1: BTIMR1 {
_marker: PhantomData,
},
BTIMR2: BTIMR2 {
_marker: PhantomData,
},
BTIMR3: BTIMR3 {
_marker: PhantomData,
},
BTIMR4: BTIMR4 {
_marker: PhantomData,
},
BTIMR5: BTIMR5 {
_marker: PhantomData,
},
BTIMR6: BTIMR6 {
_marker: PhantomData,
},
BTIMR7: BTIMR7 {
_marker: PhantomData,
},
BTIMR8: BTIMR8 {
_marker: PhantomData,
},
BTIMR9: BTIMR9 {
_marker: PhantomData,
},
BTIMR10: BTIMR10 {
_marker: PhantomData,
},
BTIMR11: BTIMR11 {
_marker: PhantomData,
},
BTIMRG: BTIMRG {
_marker: PhantomData,
},
UART0: UART0 {
_marker: PhantomData,
},
UART1: UART1 {
_marker: PhantomData,
},
UART2: UART2 {
_marker: PhantomData,
},
UART3: UART3 {
_marker: PhantomData,
},
SPI0: SPI0 {
_marker: PhantomData,
},
SPI1: SPI1 {
_marker: PhantomData,
},
I2C0: I2C0 {
_marker: PhantomData,
},
I2C1: I2C1 {
_marker: PhantomData,
},
ADC0: ADC0 {
_marker: PhantomData,
},
ADC1: ADC1 {
_marker: PhantomData,
},
PWM0: PWM0 {
_marker: PhantomData,
},
PWM1: PWM1 {
_marker: PhantomData,
},
PWM2: PWM2 {
_marker: PhantomData,
},
PWM3: PWM3 {
_marker: PhantomData,
},
PWM4: PWM4 {
_marker: PhantomData,
},
PWMG: PWMG {
_marker: PhantomData,
},
CAN0: CAN0 {
_marker: PhantomData,
},
CAN1: CAN1 {
_marker: PhantomData,
},
USBD: USBD {
_marker: PhantomData,
},
USBH: USBH {
_marker: PhantomData,
},
SDIO: SDIO {
_marker: PhantomData,
},
SDRAMC: SDRAMC {
_marker: PhantomData,
},
DMA: DMA {
_marker: PhantomData,
},
LCD: LCD {
_marker: PhantomData,
},
DMA2D: DMA2D {
_marker: PhantomData,
},
DAC: DAC {
_marker: PhantomData,
},
CRC: CRC {
_marker: PhantomData,
},
CORDIC: CORDIC {
_marker: PhantomData,
},
DIV: DIV {
_marker: PhantomData,
},
RTC: RTC {
_marker: PhantomData,
},
WDT: WDT {
_marker: PhantomData,
},
QEI: QEI {
_marker: PhantomData,
},
FMC: FMC {
_marker: PhantomData,
},
SFC: SFC {
_marker: PhantomData,
},
JPEG: JPEG {
_marker: PhantomData,
},
}
}
}