Robin Mueller
337401a2ac
All checks were successful
Rust/va416xx-rs/pipeline/head This commit looks good
3758 lines
117 KiB
Rust
3758 lines
117 KiB
Rust
#![doc = "Peripheral access API for VA416XX microcontrollers (generated using svd2rust v0.33.3 ( ))\n\nYou can find an overview of the generated API [here].\n\nAPI features to be included in the [next]
|
|
svd2rust release can be generated by cloning the svd2rust [repository], checking out the above commit, and running `cargo doc --open`.\n\n[here]: https://docs.rs/svd2rust/0.33.3/svd2rust/#peripheral-api\n[next]: https://github.com/rust-embedded/svd2rust/blob/master/CHANGELOG.md#unreleased\n[repository]: https://github.com/rust-embedded/svd2rust"]
|
|
#![allow(non_camel_case_types)]
|
|
#![allow(non_snake_case)]
|
|
#![no_std]
|
|
// Manually inserted.
|
|
#![cfg_attr(docsrs, feature(doc_auto_cfg))]
|
|
use core::marker::PhantomData;
|
|
use core::ops::Deref;
|
|
#[doc = r"Number available in the NVIC for configuring priority"]
|
|
pub const NVIC_PRIO_BITS: u8 = 4;
|
|
#[cfg(feature = "rt")]
|
|
pub use self::Interrupt as interrupt;
|
|
#[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 U0();
|
|
fn U1();
|
|
fn U2();
|
|
fn U3();
|
|
fn U4();
|
|
fn U5();
|
|
fn U6();
|
|
fn U7();
|
|
fn U8();
|
|
fn U9();
|
|
fn U10();
|
|
fn U11();
|
|
fn U12();
|
|
fn U13();
|
|
fn U14();
|
|
fn U15();
|
|
fn SPI0_TX();
|
|
fn SPI0_RX();
|
|
fn SPI1_TX();
|
|
fn SPI1_RX();
|
|
fn SPI2_TX();
|
|
fn SPI2_RX();
|
|
fn SPI3_TX();
|
|
fn SPI3_RX();
|
|
fn UART0_TX();
|
|
fn UART0_RX();
|
|
fn UART1_TX();
|
|
fn UART1_RX();
|
|
fn UART2_TX();
|
|
fn UART2_RX();
|
|
fn I2C0_MS();
|
|
fn I2C0_SL();
|
|
fn I2C1_MS();
|
|
fn I2C1_SL();
|
|
fn I2C2_MS();
|
|
fn I2C2_SL();
|
|
fn Ethernet();
|
|
fn U37();
|
|
fn SpW();
|
|
fn U39();
|
|
fn DAC0();
|
|
fn DAC1();
|
|
fn TRNG();
|
|
fn DMA_ERROR();
|
|
fn ADC();
|
|
fn LoCLK();
|
|
fn LVD();
|
|
fn WATCHDOG();
|
|
fn TIM0();
|
|
fn TIM1();
|
|
fn TIM2();
|
|
fn TIM3();
|
|
fn TIM4();
|
|
fn TIM5();
|
|
fn TIM6();
|
|
fn TIM7();
|
|
fn TIM8();
|
|
fn TIM9();
|
|
fn TIM10();
|
|
fn TIM11();
|
|
fn TIM12();
|
|
fn TIM13();
|
|
fn TIM14();
|
|
fn TIM15();
|
|
fn TIM16();
|
|
fn TIM17();
|
|
fn TIM18();
|
|
fn TIM19();
|
|
fn TIM20();
|
|
fn TIM21();
|
|
fn TIM22();
|
|
fn TIM23();
|
|
fn CAN0();
|
|
fn U73();
|
|
fn CAN1();
|
|
fn U75();
|
|
fn EDAC_MBE();
|
|
fn EDAC_SBE();
|
|
fn PORTA0();
|
|
fn PORTA1();
|
|
fn PORTA2();
|
|
fn PORTA3();
|
|
fn PORTA4();
|
|
fn PORTA5();
|
|
fn PORTA6();
|
|
fn PORTA7();
|
|
fn PORTA8();
|
|
fn PORTA9();
|
|
fn PORTA10();
|
|
fn PORTA11();
|
|
fn PORTA12();
|
|
fn PORTA13();
|
|
fn PORTA14();
|
|
fn PORTA15();
|
|
fn PORTB0();
|
|
fn PORTB1();
|
|
fn PORTB2();
|
|
fn PORTB3();
|
|
fn PORTB4();
|
|
fn PORTB5();
|
|
fn PORTB6();
|
|
fn PORTB7();
|
|
fn PORTB8();
|
|
fn PORTB9();
|
|
fn PORTB10();
|
|
fn PORTB11();
|
|
fn PORTB12();
|
|
fn PORTB13();
|
|
fn PORTB14();
|
|
fn PORTB15();
|
|
fn PORTC0();
|
|
fn PORTC1();
|
|
fn PORTC2();
|
|
fn PORTC3();
|
|
fn PORTC4();
|
|
fn PORTC5();
|
|
fn PORTC6();
|
|
fn PORTC7();
|
|
fn PORTC8();
|
|
fn PORTC9();
|
|
fn PORTC10();
|
|
fn PORTC11();
|
|
fn PORTC12();
|
|
fn PORTC13();
|
|
fn PORTC14();
|
|
fn PORTC15();
|
|
fn PORTD0();
|
|
fn PORTD1();
|
|
fn PORTD2();
|
|
fn PORTD3();
|
|
fn PORTD4();
|
|
fn PORTD5();
|
|
fn PORTD6();
|
|
fn PORTD7();
|
|
fn PORTD8();
|
|
fn PORTD9();
|
|
fn PORTD10();
|
|
fn PORTD11();
|
|
fn PORTD12();
|
|
fn PORTD13();
|
|
fn PORTD14();
|
|
fn PORTD15();
|
|
fn PORTE0();
|
|
fn PORTE1();
|
|
fn PORTE2();
|
|
fn PORTE3();
|
|
fn PORTE4();
|
|
fn PORTE5();
|
|
fn PORTE6();
|
|
fn PORTE7();
|
|
fn PORTE8();
|
|
fn PORTE9();
|
|
fn PORTE10();
|
|
fn PORTE11();
|
|
fn PORTE12();
|
|
fn PORTE13();
|
|
fn PORTE14();
|
|
fn PORTE15();
|
|
fn PORTF0();
|
|
fn PORTF1();
|
|
fn PORTF2();
|
|
fn PORTF3();
|
|
fn PORTF4();
|
|
fn PORTF5();
|
|
fn PORTF6();
|
|
fn PORTF7();
|
|
fn PORTF8();
|
|
fn PORTF9();
|
|
fn PORTF10();
|
|
fn PORTF11();
|
|
fn PORTF12();
|
|
fn PORTF13();
|
|
fn PORTF14();
|
|
fn PORTF15();
|
|
fn DMA_ACTIVE0();
|
|
fn DMA_ACTIVE1();
|
|
fn DMA_ACTIVE2();
|
|
fn DMA_ACTIVE3();
|
|
fn DMA_DONE0();
|
|
fn DMA_DONE1();
|
|
fn DMA_DONE2();
|
|
fn DMA_DONE3();
|
|
fn I2C0_MS_RX();
|
|
fn I2C0_MS_TX();
|
|
fn I2C0_SL_RX();
|
|
fn I2C0_SL_TX();
|
|
fn I2C1_MS_RX();
|
|
fn I2C1_MS_TX();
|
|
fn I2C1_SL_RX();
|
|
fn I2C1_SL_TX();
|
|
fn I2C2_MS_RX();
|
|
fn I2C2_MS_TX();
|
|
fn I2C2_SL_RX();
|
|
fn I2C2_SL_TX();
|
|
fn FPU();
|
|
fn TXEV();
|
|
}
|
|
#[doc(hidden)]
|
|
#[repr(C)]
|
|
pub union Vector {
|
|
_handler: unsafe extern "C" fn(),
|
|
_reserved: u32,
|
|
}
|
|
#[cfg(feature = "rt")]
|
|
#[doc(hidden)]
|
|
#[link_section = ".vector_table.interrupts"]
|
|
#[no_mangle]
|
|
pub static __INTERRUPTS: [Vector; 196] = [
|
|
Vector { _handler: U0 },
|
|
Vector { _handler: U1 },
|
|
Vector { _handler: U2 },
|
|
Vector { _handler: U3 },
|
|
Vector { _handler: U4 },
|
|
Vector { _handler: U5 },
|
|
Vector { _handler: U6 },
|
|
Vector { _handler: U7 },
|
|
Vector { _handler: U8 },
|
|
Vector { _handler: U9 },
|
|
Vector { _handler: U10 },
|
|
Vector { _handler: U11 },
|
|
Vector { _handler: U12 },
|
|
Vector { _handler: U13 },
|
|
Vector { _handler: U14 },
|
|
Vector { _handler: U15 },
|
|
Vector { _handler: SPI0_TX },
|
|
Vector { _handler: SPI0_RX },
|
|
Vector { _handler: SPI1_TX },
|
|
Vector { _handler: SPI1_RX },
|
|
Vector { _handler: SPI2_TX },
|
|
Vector { _handler: SPI2_RX },
|
|
Vector { _handler: SPI3_TX },
|
|
Vector { _handler: SPI3_RX },
|
|
Vector { _handler: UART0_TX },
|
|
Vector { _handler: UART0_RX },
|
|
Vector { _handler: UART1_TX },
|
|
Vector { _handler: UART1_RX },
|
|
Vector { _handler: UART2_TX },
|
|
Vector { _handler: UART2_RX },
|
|
Vector { _handler: I2C0_MS },
|
|
Vector { _handler: I2C0_SL },
|
|
Vector { _handler: I2C1_MS },
|
|
Vector { _handler: I2C1_SL },
|
|
Vector { _handler: I2C2_MS },
|
|
Vector { _handler: I2C2_SL },
|
|
Vector { _handler: Ethernet },
|
|
Vector { _handler: U37 },
|
|
Vector { _handler: SpW },
|
|
Vector { _handler: U39 },
|
|
Vector { _handler: DAC0 },
|
|
Vector { _handler: DAC1 },
|
|
Vector { _handler: TRNG },
|
|
Vector {
|
|
_handler: DMA_ERROR,
|
|
},
|
|
Vector { _handler: ADC },
|
|
Vector { _handler: LoCLK },
|
|
Vector { _handler: LVD },
|
|
Vector { _handler: WATCHDOG },
|
|
Vector { _handler: TIM0 },
|
|
Vector { _handler: TIM1 },
|
|
Vector { _handler: TIM2 },
|
|
Vector { _handler: TIM3 },
|
|
Vector { _handler: TIM4 },
|
|
Vector { _handler: TIM5 },
|
|
Vector { _handler: TIM6 },
|
|
Vector { _handler: TIM7 },
|
|
Vector { _handler: TIM8 },
|
|
Vector { _handler: TIM9 },
|
|
Vector { _handler: TIM10 },
|
|
Vector { _handler: TIM11 },
|
|
Vector { _handler: TIM12 },
|
|
Vector { _handler: TIM13 },
|
|
Vector { _handler: TIM14 },
|
|
Vector { _handler: TIM15 },
|
|
Vector { _handler: TIM16 },
|
|
Vector { _handler: TIM17 },
|
|
Vector { _handler: TIM18 },
|
|
Vector { _handler: TIM19 },
|
|
Vector { _handler: TIM20 },
|
|
Vector { _handler: TIM21 },
|
|
Vector { _handler: TIM22 },
|
|
Vector { _handler: TIM23 },
|
|
Vector { _handler: CAN0 },
|
|
Vector { _handler: U73 },
|
|
Vector { _handler: CAN1 },
|
|
Vector { _handler: U75 },
|
|
Vector { _handler: EDAC_MBE },
|
|
Vector { _handler: EDAC_SBE },
|
|
Vector { _handler: PORTA0 },
|
|
Vector { _handler: PORTA1 },
|
|
Vector { _handler: PORTA2 },
|
|
Vector { _handler: PORTA3 },
|
|
Vector { _handler: PORTA4 },
|
|
Vector { _handler: PORTA5 },
|
|
Vector { _handler: PORTA6 },
|
|
Vector { _handler: PORTA7 },
|
|
Vector { _handler: PORTA8 },
|
|
Vector { _handler: PORTA9 },
|
|
Vector { _handler: PORTA10 },
|
|
Vector { _handler: PORTA11 },
|
|
Vector { _handler: PORTA12 },
|
|
Vector { _handler: PORTA13 },
|
|
Vector { _handler: PORTA14 },
|
|
Vector { _handler: PORTA15 },
|
|
Vector { _handler: PORTB0 },
|
|
Vector { _handler: PORTB1 },
|
|
Vector { _handler: PORTB2 },
|
|
Vector { _handler: PORTB3 },
|
|
Vector { _handler: PORTB4 },
|
|
Vector { _handler: PORTB5 },
|
|
Vector { _handler: PORTB6 },
|
|
Vector { _handler: PORTB7 },
|
|
Vector { _handler: PORTB8 },
|
|
Vector { _handler: PORTB9 },
|
|
Vector { _handler: PORTB10 },
|
|
Vector { _handler: PORTB11 },
|
|
Vector { _handler: PORTB12 },
|
|
Vector { _handler: PORTB13 },
|
|
Vector { _handler: PORTB14 },
|
|
Vector { _handler: PORTB15 },
|
|
Vector { _handler: PORTC0 },
|
|
Vector { _handler: PORTC1 },
|
|
Vector { _handler: PORTC2 },
|
|
Vector { _handler: PORTC3 },
|
|
Vector { _handler: PORTC4 },
|
|
Vector { _handler: PORTC5 },
|
|
Vector { _handler: PORTC6 },
|
|
Vector { _handler: PORTC7 },
|
|
Vector { _handler: PORTC8 },
|
|
Vector { _handler: PORTC9 },
|
|
Vector { _handler: PORTC10 },
|
|
Vector { _handler: PORTC11 },
|
|
Vector { _handler: PORTC12 },
|
|
Vector { _handler: PORTC13 },
|
|
Vector { _handler: PORTC14 },
|
|
Vector { _handler: PORTC15 },
|
|
Vector { _handler: PORTD0 },
|
|
Vector { _handler: PORTD1 },
|
|
Vector { _handler: PORTD2 },
|
|
Vector { _handler: PORTD3 },
|
|
Vector { _handler: PORTD4 },
|
|
Vector { _handler: PORTD5 },
|
|
Vector { _handler: PORTD6 },
|
|
Vector { _handler: PORTD7 },
|
|
Vector { _handler: PORTD8 },
|
|
Vector { _handler: PORTD9 },
|
|
Vector { _handler: PORTD10 },
|
|
Vector { _handler: PORTD11 },
|
|
Vector { _handler: PORTD12 },
|
|
Vector { _handler: PORTD13 },
|
|
Vector { _handler: PORTD14 },
|
|
Vector { _handler: PORTD15 },
|
|
Vector { _handler: PORTE0 },
|
|
Vector { _handler: PORTE1 },
|
|
Vector { _handler: PORTE2 },
|
|
Vector { _handler: PORTE3 },
|
|
Vector { _handler: PORTE4 },
|
|
Vector { _handler: PORTE5 },
|
|
Vector { _handler: PORTE6 },
|
|
Vector { _handler: PORTE7 },
|
|
Vector { _handler: PORTE8 },
|
|
Vector { _handler: PORTE9 },
|
|
Vector { _handler: PORTE10 },
|
|
Vector { _handler: PORTE11 },
|
|
Vector { _handler: PORTE12 },
|
|
Vector { _handler: PORTE13 },
|
|
Vector { _handler: PORTE14 },
|
|
Vector { _handler: PORTE15 },
|
|
Vector { _handler: PORTF0 },
|
|
Vector { _handler: PORTF1 },
|
|
Vector { _handler: PORTF2 },
|
|
Vector { _handler: PORTF3 },
|
|
Vector { _handler: PORTF4 },
|
|
Vector { _handler: PORTF5 },
|
|
Vector { _handler: PORTF6 },
|
|
Vector { _handler: PORTF7 },
|
|
Vector { _handler: PORTF8 },
|
|
Vector { _handler: PORTF9 },
|
|
Vector { _handler: PORTF10 },
|
|
Vector { _handler: PORTF11 },
|
|
Vector { _handler: PORTF12 },
|
|
Vector { _handler: PORTF13 },
|
|
Vector { _handler: PORTF14 },
|
|
Vector { _handler: PORTF15 },
|
|
Vector {
|
|
_handler: DMA_ACTIVE0,
|
|
},
|
|
Vector {
|
|
_handler: DMA_ACTIVE1,
|
|
},
|
|
Vector {
|
|
_handler: DMA_ACTIVE2,
|
|
},
|
|
Vector {
|
|
_handler: DMA_ACTIVE3,
|
|
},
|
|
Vector {
|
|
_handler: DMA_DONE0,
|
|
},
|
|
Vector {
|
|
_handler: DMA_DONE1,
|
|
},
|
|
Vector {
|
|
_handler: DMA_DONE2,
|
|
},
|
|
Vector {
|
|
_handler: DMA_DONE3,
|
|
},
|
|
Vector {
|
|
_handler: I2C0_MS_RX,
|
|
},
|
|
Vector {
|
|
_handler: I2C0_MS_TX,
|
|
},
|
|
Vector {
|
|
_handler: I2C0_SL_RX,
|
|
},
|
|
Vector {
|
|
_handler: I2C0_SL_TX,
|
|
},
|
|
Vector {
|
|
_handler: I2C1_MS_RX,
|
|
},
|
|
Vector {
|
|
_handler: I2C1_MS_TX,
|
|
},
|
|
Vector {
|
|
_handler: I2C1_SL_RX,
|
|
},
|
|
Vector {
|
|
_handler: I2C1_SL_TX,
|
|
},
|
|
Vector {
|
|
_handler: I2C2_MS_RX,
|
|
},
|
|
Vector {
|
|
_handler: I2C2_MS_TX,
|
|
},
|
|
Vector {
|
|
_handler: I2C2_SL_RX,
|
|
},
|
|
Vector {
|
|
_handler: I2C2_SL_TX,
|
|
},
|
|
Vector { _handler: FPU },
|
|
Vector { _handler: TXEV },
|
|
];
|
|
#[doc = r"Enumeration of all the interrupts."]
|
|
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
|
|
#[repr(u16)]
|
|
pub enum Interrupt {
|
|
#[doc = "0 - U0"]
|
|
U0 = 0,
|
|
#[doc = "1 - U1"]
|
|
U1 = 1,
|
|
#[doc = "2 - U2"]
|
|
U2 = 2,
|
|
#[doc = "3 - U3"]
|
|
U3 = 3,
|
|
#[doc = "4 - U4"]
|
|
U4 = 4,
|
|
#[doc = "5 - U5"]
|
|
U5 = 5,
|
|
#[doc = "6 - U6"]
|
|
U6 = 6,
|
|
#[doc = "7 - U7"]
|
|
U7 = 7,
|
|
#[doc = "8 - U8"]
|
|
U8 = 8,
|
|
#[doc = "9 - U9"]
|
|
U9 = 9,
|
|
#[doc = "10 - U10"]
|
|
U10 = 10,
|
|
#[doc = "11 - U11"]
|
|
U11 = 11,
|
|
#[doc = "12 - U12"]
|
|
U12 = 12,
|
|
#[doc = "13 - U13"]
|
|
U13 = 13,
|
|
#[doc = "14 - U14"]
|
|
U14 = 14,
|
|
#[doc = "15 - U15"]
|
|
U15 = 15,
|
|
#[doc = "16 - SPI0_TX"]
|
|
SPI0_TX = 16,
|
|
#[doc = "17 - SPI0_RX"]
|
|
SPI0_RX = 17,
|
|
#[doc = "18 - SPI1_TX"]
|
|
SPI1_TX = 18,
|
|
#[doc = "19 - SPI1_RX"]
|
|
SPI1_RX = 19,
|
|
#[doc = "20 - SPI2_TX"]
|
|
SPI2_TX = 20,
|
|
#[doc = "21 - SPI2_RX"]
|
|
SPI2_RX = 21,
|
|
#[doc = "22 - SPI3_TX"]
|
|
SPI3_TX = 22,
|
|
#[doc = "23 - SPI3_RX"]
|
|
SPI3_RX = 23,
|
|
#[doc = "24 - UART0_TX"]
|
|
UART0_TX = 24,
|
|
#[doc = "25 - UART0_RX"]
|
|
UART0_RX = 25,
|
|
#[doc = "26 - UART1_TX"]
|
|
UART1_TX = 26,
|
|
#[doc = "27 - UART1_RX"]
|
|
UART1_RX = 27,
|
|
#[doc = "28 - UART2_TX"]
|
|
UART2_TX = 28,
|
|
#[doc = "29 - UART2_RX"]
|
|
UART2_RX = 29,
|
|
#[doc = "30 - I2C0_MS"]
|
|
I2C0_MS = 30,
|
|
#[doc = "31 - I2C0_SL"]
|
|
I2C0_SL = 31,
|
|
#[doc = "32 - I2C1_MS"]
|
|
I2C1_MS = 32,
|
|
#[doc = "33 - I2C1_SL"]
|
|
I2C1_SL = 33,
|
|
#[doc = "34 - I2C2_MS"]
|
|
I2C2_MS = 34,
|
|
#[doc = "35 - I2C2_SL"]
|
|
I2C2_SL = 35,
|
|
#[doc = "36 - Ethernet"]
|
|
Ethernet = 36,
|
|
#[doc = "37 - U37"]
|
|
U37 = 37,
|
|
#[doc = "38 - SpW"]
|
|
SpW = 38,
|
|
#[doc = "39 - U39"]
|
|
U39 = 39,
|
|
#[doc = "40 - DAC0"]
|
|
DAC0 = 40,
|
|
#[doc = "41 - DAC1"]
|
|
DAC1 = 41,
|
|
#[doc = "42 - TRNG"]
|
|
TRNG = 42,
|
|
#[doc = "43 - DMA_ERROR"]
|
|
DMA_ERROR = 43,
|
|
#[doc = "44 - ADC"]
|
|
ADC = 44,
|
|
#[doc = "45 - LoCLK"]
|
|
LoCLK = 45,
|
|
#[doc = "46 - LVD"]
|
|
LVD = 46,
|
|
#[doc = "47 - WATCHDOG"]
|
|
WATCHDOG = 47,
|
|
#[doc = "48 - TIM0"]
|
|
TIM0 = 48,
|
|
#[doc = "49 - TIM1"]
|
|
TIM1 = 49,
|
|
#[doc = "50 - TIM2"]
|
|
TIM2 = 50,
|
|
#[doc = "51 - TIM3"]
|
|
TIM3 = 51,
|
|
#[doc = "52 - TIM4"]
|
|
TIM4 = 52,
|
|
#[doc = "53 - TIM5"]
|
|
TIM5 = 53,
|
|
#[doc = "54 - TIM6"]
|
|
TIM6 = 54,
|
|
#[doc = "55 - TIM7"]
|
|
TIM7 = 55,
|
|
#[doc = "56 - TIM8"]
|
|
TIM8 = 56,
|
|
#[doc = "57 - TIM9"]
|
|
TIM9 = 57,
|
|
#[doc = "58 - TIM10"]
|
|
TIM10 = 58,
|
|
#[doc = "59 - TIM11"]
|
|
TIM11 = 59,
|
|
#[doc = "60 - TIM12"]
|
|
TIM12 = 60,
|
|
#[doc = "61 - TIM13"]
|
|
TIM13 = 61,
|
|
#[doc = "62 - TIM14"]
|
|
TIM14 = 62,
|
|
#[doc = "63 - TIM15"]
|
|
TIM15 = 63,
|
|
#[doc = "64 - TIM16"]
|
|
TIM16 = 64,
|
|
#[doc = "65 - TIM17"]
|
|
TIM17 = 65,
|
|
#[doc = "66 - TIM18"]
|
|
TIM18 = 66,
|
|
#[doc = "67 - TIM19"]
|
|
TIM19 = 67,
|
|
#[doc = "68 - TIM20"]
|
|
TIM20 = 68,
|
|
#[doc = "69 - TIM21"]
|
|
TIM21 = 69,
|
|
#[doc = "70 - TIM22"]
|
|
TIM22 = 70,
|
|
#[doc = "71 - TIM23"]
|
|
TIM23 = 71,
|
|
#[doc = "72 - CAN0"]
|
|
CAN0 = 72,
|
|
#[doc = "73 - U73"]
|
|
U73 = 73,
|
|
#[doc = "74 - CAN1"]
|
|
CAN1 = 74,
|
|
#[doc = "75 - U75"]
|
|
U75 = 75,
|
|
#[doc = "76 - EDAC_MBE"]
|
|
EDAC_MBE = 76,
|
|
#[doc = "77 - EDAC_SBE"]
|
|
EDAC_SBE = 77,
|
|
#[doc = "78 - PORTA0"]
|
|
PORTA0 = 78,
|
|
#[doc = "79 - PORTA1"]
|
|
PORTA1 = 79,
|
|
#[doc = "80 - PORTA2"]
|
|
PORTA2 = 80,
|
|
#[doc = "81 - PORTA3"]
|
|
PORTA3 = 81,
|
|
#[doc = "82 - PORTA4"]
|
|
PORTA4 = 82,
|
|
#[doc = "83 - PORTA5"]
|
|
PORTA5 = 83,
|
|
#[doc = "84 - PORTA6"]
|
|
PORTA6 = 84,
|
|
#[doc = "85 - PORTA7"]
|
|
PORTA7 = 85,
|
|
#[doc = "86 - PORTA8"]
|
|
PORTA8 = 86,
|
|
#[doc = "87 - PORTA9"]
|
|
PORTA9 = 87,
|
|
#[doc = "88 - PORTA10"]
|
|
PORTA10 = 88,
|
|
#[doc = "89 - PORTA11"]
|
|
PORTA11 = 89,
|
|
#[doc = "90 - PORTA12"]
|
|
PORTA12 = 90,
|
|
#[doc = "91 - PORTA13"]
|
|
PORTA13 = 91,
|
|
#[doc = "92 - PORTA14"]
|
|
PORTA14 = 92,
|
|
#[doc = "93 - PORTA15"]
|
|
PORTA15 = 93,
|
|
#[doc = "94 - PORTB0"]
|
|
PORTB0 = 94,
|
|
#[doc = "95 - PORTB1"]
|
|
PORTB1 = 95,
|
|
#[doc = "96 - PORTB2"]
|
|
PORTB2 = 96,
|
|
#[doc = "97 - PORTB3"]
|
|
PORTB3 = 97,
|
|
#[doc = "98 - PORTB4"]
|
|
PORTB4 = 98,
|
|
#[doc = "99 - PORTB5"]
|
|
PORTB5 = 99,
|
|
#[doc = "100 - PORTB6"]
|
|
PORTB6 = 100,
|
|
#[doc = "101 - PORTB7"]
|
|
PORTB7 = 101,
|
|
#[doc = "102 - PORTB8"]
|
|
PORTB8 = 102,
|
|
#[doc = "103 - PORTB9"]
|
|
PORTB9 = 103,
|
|
#[doc = "104 - PORTB10"]
|
|
PORTB10 = 104,
|
|
#[doc = "105 - PORTB11"]
|
|
PORTB11 = 105,
|
|
#[doc = "106 - PORTB12"]
|
|
PORTB12 = 106,
|
|
#[doc = "107 - PORTB13"]
|
|
PORTB13 = 107,
|
|
#[doc = "108 - PORTB14"]
|
|
PORTB14 = 108,
|
|
#[doc = "109 - PORTB15"]
|
|
PORTB15 = 109,
|
|
#[doc = "110 - PORTC0"]
|
|
PORTC0 = 110,
|
|
#[doc = "111 - PORTC1"]
|
|
PORTC1 = 111,
|
|
#[doc = "112 - PORTC2"]
|
|
PORTC2 = 112,
|
|
#[doc = "113 - PORTC3"]
|
|
PORTC3 = 113,
|
|
#[doc = "114 - PORTC4"]
|
|
PORTC4 = 114,
|
|
#[doc = "115 - PORTC5"]
|
|
PORTC5 = 115,
|
|
#[doc = "116 - PORTC6"]
|
|
PORTC6 = 116,
|
|
#[doc = "117 - PORTC7"]
|
|
PORTC7 = 117,
|
|
#[doc = "118 - PORTC8"]
|
|
PORTC8 = 118,
|
|
#[doc = "119 - PORTC9"]
|
|
PORTC9 = 119,
|
|
#[doc = "120 - PORTC10"]
|
|
PORTC10 = 120,
|
|
#[doc = "121 - PORTC11"]
|
|
PORTC11 = 121,
|
|
#[doc = "122 - PORTC12"]
|
|
PORTC12 = 122,
|
|
#[doc = "123 - PORTC13"]
|
|
PORTC13 = 123,
|
|
#[doc = "124 - PORTC14"]
|
|
PORTC14 = 124,
|
|
#[doc = "125 - PORTC15"]
|
|
PORTC15 = 125,
|
|
#[doc = "126 - PORTD0"]
|
|
PORTD0 = 126,
|
|
#[doc = "127 - PORTD1"]
|
|
PORTD1 = 127,
|
|
#[doc = "128 - PORTD2"]
|
|
PORTD2 = 128,
|
|
#[doc = "129 - PORTD3"]
|
|
PORTD3 = 129,
|
|
#[doc = "130 - PORTD4"]
|
|
PORTD4 = 130,
|
|
#[doc = "131 - PORTD5"]
|
|
PORTD5 = 131,
|
|
#[doc = "132 - PORTD6"]
|
|
PORTD6 = 132,
|
|
#[doc = "133 - PORTD7"]
|
|
PORTD7 = 133,
|
|
#[doc = "134 - PORTD8"]
|
|
PORTD8 = 134,
|
|
#[doc = "135 - PORTD9"]
|
|
PORTD9 = 135,
|
|
#[doc = "136 - PORTD10"]
|
|
PORTD10 = 136,
|
|
#[doc = "137 - PORTD11"]
|
|
PORTD11 = 137,
|
|
#[doc = "138 - PORTD12"]
|
|
PORTD12 = 138,
|
|
#[doc = "139 - PORTD13"]
|
|
PORTD13 = 139,
|
|
#[doc = "140 - PORTD14"]
|
|
PORTD14 = 140,
|
|
#[doc = "141 - PORTD15"]
|
|
PORTD15 = 141,
|
|
#[doc = "142 - PORTE0"]
|
|
PORTE0 = 142,
|
|
#[doc = "143 - PORTE1"]
|
|
PORTE1 = 143,
|
|
#[doc = "144 - PORTE2"]
|
|
PORTE2 = 144,
|
|
#[doc = "145 - PORTE3"]
|
|
PORTE3 = 145,
|
|
#[doc = "146 - PORTE4"]
|
|
PORTE4 = 146,
|
|
#[doc = "147 - PORTE5"]
|
|
PORTE5 = 147,
|
|
#[doc = "148 - PORTE6"]
|
|
PORTE6 = 148,
|
|
#[doc = "149 - PORTE7"]
|
|
PORTE7 = 149,
|
|
#[doc = "150 - PORTE8"]
|
|
PORTE8 = 150,
|
|
#[doc = "151 - PORTE9"]
|
|
PORTE9 = 151,
|
|
#[doc = "152 - PORTE10"]
|
|
PORTE10 = 152,
|
|
#[doc = "153 - PORTE11"]
|
|
PORTE11 = 153,
|
|
#[doc = "154 - PORTE12"]
|
|
PORTE12 = 154,
|
|
#[doc = "155 - PORTE13"]
|
|
PORTE13 = 155,
|
|
#[doc = "156 - PORTE14"]
|
|
PORTE14 = 156,
|
|
#[doc = "157 - PORTE15"]
|
|
PORTE15 = 157,
|
|
#[doc = "158 - PORTF0"]
|
|
PORTF0 = 158,
|
|
#[doc = "159 - PORTF1"]
|
|
PORTF1 = 159,
|
|
#[doc = "160 - PORTF2"]
|
|
PORTF2 = 160,
|
|
#[doc = "161 - PORTF3"]
|
|
PORTF3 = 161,
|
|
#[doc = "162 - PORTF4"]
|
|
PORTF4 = 162,
|
|
#[doc = "163 - PORTF5"]
|
|
PORTF5 = 163,
|
|
#[doc = "164 - PORTF6"]
|
|
PORTF6 = 164,
|
|
#[doc = "165 - PORTF7"]
|
|
PORTF7 = 165,
|
|
#[doc = "166 - PORTF8"]
|
|
PORTF8 = 166,
|
|
#[doc = "167 - PORTF9"]
|
|
PORTF9 = 167,
|
|
#[doc = "168 - PORTF10"]
|
|
PORTF10 = 168,
|
|
#[doc = "169 - PORTF11"]
|
|
PORTF11 = 169,
|
|
#[doc = "170 - PORTF12"]
|
|
PORTF12 = 170,
|
|
#[doc = "171 - PORTF13"]
|
|
PORTF13 = 171,
|
|
#[doc = "172 - PORTF14"]
|
|
PORTF14 = 172,
|
|
#[doc = "173 - PORTF15"]
|
|
PORTF15 = 173,
|
|
#[doc = "174 - DMA_ACTIVE0"]
|
|
DMA_ACTIVE0 = 174,
|
|
#[doc = "175 - DMA_ACTIVE1"]
|
|
DMA_ACTIVE1 = 175,
|
|
#[doc = "176 - DMA_ACTIVE2"]
|
|
DMA_ACTIVE2 = 176,
|
|
#[doc = "177 - DMA_ACTIVE3"]
|
|
DMA_ACTIVE3 = 177,
|
|
#[doc = "178 - DMA_DONE0"]
|
|
DMA_DONE0 = 178,
|
|
#[doc = "179 - DMA_DONE1"]
|
|
DMA_DONE1 = 179,
|
|
#[doc = "180 - DMA_DONE2"]
|
|
DMA_DONE2 = 180,
|
|
#[doc = "181 - DMA_DONE3"]
|
|
DMA_DONE3 = 181,
|
|
#[doc = "182 - I2C0_MS_RX"]
|
|
I2C0_MS_RX = 182,
|
|
#[doc = "183 - I2C0_MS_TX"]
|
|
I2C0_MS_TX = 183,
|
|
#[doc = "184 - I2C0_SL_RX"]
|
|
I2C0_SL_RX = 184,
|
|
#[doc = "185 - I2C0_SL_TX"]
|
|
I2C0_SL_TX = 185,
|
|
#[doc = "186 - I2C1_MS_RX"]
|
|
I2C1_MS_RX = 186,
|
|
#[doc = "187 - I2C1_MS_TX"]
|
|
I2C1_MS_TX = 187,
|
|
#[doc = "188 - I2C1_SL_RX"]
|
|
I2C1_SL_RX = 188,
|
|
#[doc = "189 - I2C1_SL_TX"]
|
|
I2C1_SL_TX = 189,
|
|
#[doc = "190 - I2C2_MS_RX"]
|
|
I2C2_MS_RX = 190,
|
|
#[doc = "191 - I2C2_MS_TX"]
|
|
I2C2_MS_TX = 191,
|
|
#[doc = "192 - I2C2_SL_RX"]
|
|
I2C2_SL_RX = 192,
|
|
#[doc = "193 - I2C2_SL_TX"]
|
|
I2C2_SL_TX = 193,
|
|
#[doc = "194 - FPU"]
|
|
FPU = 194,
|
|
#[doc = "195 - TXEV"]
|
|
TXEV = 195,
|
|
}
|
|
unsafe impl cortex_m::interrupt::InterruptNumber for Interrupt {
|
|
#[inline(always)]
|
|
fn number(self) -> u16 {
|
|
self as u16
|
|
}
|
|
}
|
|
#[doc = "Clock Generation Peripheral"]
|
|
pub struct Clkgen {
|
|
_marker: PhantomData<*const ()>,
|
|
}
|
|
unsafe impl Send for Clkgen {}
|
|
impl Clkgen {
|
|
#[doc = r"Pointer to the register block"]
|
|
pub const PTR: *const clkgen::RegisterBlock = 0x4000_6000 as *const _;
|
|
#[doc = r"Return the pointer to the register block"]
|
|
#[inline(always)]
|
|
pub const fn ptr() -> *const clkgen::RegisterBlock {
|
|
Self::PTR
|
|
}
|
|
#[doc = r" Steal an instance of this peripheral"]
|
|
#[doc = r""]
|
|
#[doc = r" # Safety"]
|
|
#[doc = r""]
|
|
#[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
|
|
#[doc = r" that may race with any existing instances, for example by only"]
|
|
#[doc = r" accessing read-only or write-only registers, or by consuming the"]
|
|
#[doc = r" original peripheral and using critical sections to coordinate"]
|
|
#[doc = r" access between multiple new instances."]
|
|
#[doc = r""]
|
|
#[doc = r" Additionally, other software such as HALs may rely on only one"]
|
|
#[doc = r" peripheral instance existing to ensure memory safety; ensure"]
|
|
#[doc = r" no stolen instances are passed to such software."]
|
|
pub unsafe fn steal() -> Self {
|
|
Self {
|
|
_marker: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
impl Deref for Clkgen {
|
|
type Target = clkgen::RegisterBlock;
|
|
#[inline(always)]
|
|
fn deref(&self) -> &Self::Target {
|
|
unsafe { &*Self::PTR }
|
|
}
|
|
}
|
|
impl core::fmt::Debug for Clkgen {
|
|
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
|
|
f.debug_struct("Clkgen").finish()
|
|
}
|
|
}
|
|
#[doc = "Clock Generation Peripheral"]
|
|
pub mod clkgen;
|
|
#[doc = "System Configuration Peripheral"]
|
|
pub struct Sysconfig {
|
|
_marker: PhantomData<*const ()>,
|
|
}
|
|
unsafe impl Send for Sysconfig {}
|
|
impl Sysconfig {
|
|
#[doc = r"Pointer to the register block"]
|
|
pub const PTR: *const sysconfig::RegisterBlock = 0x4001_0000 as *const _;
|
|
#[doc = r"Return the pointer to the register block"]
|
|
#[inline(always)]
|
|
pub const fn ptr() -> *const sysconfig::RegisterBlock {
|
|
Self::PTR
|
|
}
|
|
#[doc = r" Steal an instance of this peripheral"]
|
|
#[doc = r""]
|
|
#[doc = r" # Safety"]
|
|
#[doc = r""]
|
|
#[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
|
|
#[doc = r" that may race with any existing instances, for example by only"]
|
|
#[doc = r" accessing read-only or write-only registers, or by consuming the"]
|
|
#[doc = r" original peripheral and using critical sections to coordinate"]
|
|
#[doc = r" access between multiple new instances."]
|
|
#[doc = r""]
|
|
#[doc = r" Additionally, other software such as HALs may rely on only one"]
|
|
#[doc = r" peripheral instance existing to ensure memory safety; ensure"]
|
|
#[doc = r" no stolen instances are passed to such software."]
|
|
pub unsafe fn steal() -> Self {
|
|
Self {
|
|
_marker: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
impl Deref for Sysconfig {
|
|
type Target = sysconfig::RegisterBlock;
|
|
#[inline(always)]
|
|
fn deref(&self) -> &Self::Target {
|
|
unsafe { &*Self::PTR }
|
|
}
|
|
}
|
|
impl core::fmt::Debug for Sysconfig {
|
|
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
|
|
f.debug_struct("Sysconfig").finish()
|
|
}
|
|
}
|
|
#[doc = "System Configuration Peripheral"]
|
|
pub mod sysconfig;
|
|
#[doc = "DMA Controller Block"]
|
|
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_1000 as *const _;
|
|
#[doc = r"Return the pointer to the register block"]
|
|
#[inline(always)]
|
|
pub const fn ptr() -> *const dma::RegisterBlock {
|
|
Self::PTR
|
|
}
|
|
#[doc = r" Steal an instance of this peripheral"]
|
|
#[doc = r""]
|
|
#[doc = r" # Safety"]
|
|
#[doc = r""]
|
|
#[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
|
|
#[doc = r" that may race with any existing instances, for example by only"]
|
|
#[doc = r" accessing read-only or write-only registers, or by consuming the"]
|
|
#[doc = r" original peripheral and using critical sections to coordinate"]
|
|
#[doc = r" access between multiple new instances."]
|
|
#[doc = r""]
|
|
#[doc = r" Additionally, other software such as HALs may rely on only one"]
|
|
#[doc = r" peripheral instance existing to ensure memory safety; ensure"]
|
|
#[doc = r" no stolen instances are passed to such software."]
|
|
pub unsafe fn steal() -> Self {
|
|
Self {
|
|
_marker: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
impl Deref for 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 = "DMA Controller Block"]
|
|
pub mod dma;
|
|
#[doc = "IO Pin Configuration Peripheral"]
|
|
pub struct Ioconfig {
|
|
_marker: PhantomData<*const ()>,
|
|
}
|
|
unsafe impl Send for Ioconfig {}
|
|
impl Ioconfig {
|
|
#[doc = r"Pointer to the register block"]
|
|
pub const PTR: *const ioconfig::RegisterBlock = 0x4001_1000 as *const _;
|
|
#[doc = r"Return the pointer to the register block"]
|
|
#[inline(always)]
|
|
pub const fn ptr() -> *const ioconfig::RegisterBlock {
|
|
Self::PTR
|
|
}
|
|
#[doc = r" Steal an instance of this peripheral"]
|
|
#[doc = r""]
|
|
#[doc = r" # Safety"]
|
|
#[doc = r""]
|
|
#[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
|
|
#[doc = r" that may race with any existing instances, for example by only"]
|
|
#[doc = r" accessing read-only or write-only registers, or by consuming the"]
|
|
#[doc = r" original peripheral and using critical sections to coordinate"]
|
|
#[doc = r" access between multiple new instances."]
|
|
#[doc = r""]
|
|
#[doc = r" Additionally, other software such as HALs may rely on only one"]
|
|
#[doc = r" peripheral instance existing to ensure memory safety; ensure"]
|
|
#[doc = r" no stolen instances are passed to such software."]
|
|
pub unsafe fn steal() -> Self {
|
|
Self {
|
|
_marker: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
impl Deref for Ioconfig {
|
|
type Target = ioconfig::RegisterBlock;
|
|
#[inline(always)]
|
|
fn deref(&self) -> &Self::Target {
|
|
unsafe { &*Self::PTR }
|
|
}
|
|
}
|
|
impl core::fmt::Debug for Ioconfig {
|
|
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
|
|
f.debug_struct("Ioconfig").finish()
|
|
}
|
|
}
|
|
#[doc = "IO Pin Configuration Peripheral"]
|
|
pub mod ioconfig;
|
|
#[doc = "Utility Peripheral"]
|
|
pub struct Utility {
|
|
_marker: PhantomData<*const ()>,
|
|
}
|
|
unsafe impl Send for Utility {}
|
|
impl Utility {
|
|
#[doc = r"Pointer to the register block"]
|
|
pub const PTR: *const utility::RegisterBlock = 0x4002_0000 as *const _;
|
|
#[doc = r"Return the pointer to the register block"]
|
|
#[inline(always)]
|
|
pub const fn ptr() -> *const utility::RegisterBlock {
|
|
Self::PTR
|
|
}
|
|
#[doc = r" Steal an instance of this peripheral"]
|
|
#[doc = r""]
|
|
#[doc = r" # Safety"]
|
|
#[doc = r""]
|
|
#[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
|
|
#[doc = r" that may race with any existing instances, for example by only"]
|
|
#[doc = r" accessing read-only or write-only registers, or by consuming the"]
|
|
#[doc = r" original peripheral and using critical sections to coordinate"]
|
|
#[doc = r" access between multiple new instances."]
|
|
#[doc = r""]
|
|
#[doc = r" Additionally, other software such as HALs may rely on only one"]
|
|
#[doc = r" peripheral instance existing to ensure memory safety; ensure"]
|
|
#[doc = r" no stolen instances are passed to such software."]
|
|
pub unsafe fn steal() -> Self {
|
|
Self {
|
|
_marker: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
impl Deref for Utility {
|
|
type Target = utility::RegisterBlock;
|
|
#[inline(always)]
|
|
fn deref(&self) -> &Self::Target {
|
|
unsafe { &*Self::PTR }
|
|
}
|
|
}
|
|
impl core::fmt::Debug for Utility {
|
|
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
|
|
f.debug_struct("Utility").finish()
|
|
}
|
|
}
|
|
#[doc = "Utility Peripheral"]
|
|
pub mod utility;
|
|
#[doc = "GPIO Peripheral"]
|
|
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 = 0x4001_2000 as *const _;
|
|
#[doc = r"Return the pointer to the register block"]
|
|
#[inline(always)]
|
|
pub const fn ptr() -> *const porta::RegisterBlock {
|
|
Self::PTR
|
|
}
|
|
#[doc = r" Steal an instance of this peripheral"]
|
|
#[doc = r""]
|
|
#[doc = r" # Safety"]
|
|
#[doc = r""]
|
|
#[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
|
|
#[doc = r" that may race with any existing instances, for example by only"]
|
|
#[doc = r" accessing read-only or write-only registers, or by consuming the"]
|
|
#[doc = r" original peripheral and using critical sections to coordinate"]
|
|
#[doc = r" access between multiple new instances."]
|
|
#[doc = r""]
|
|
#[doc = r" Additionally, other software such as HALs may rely on only one"]
|
|
#[doc = r" peripheral instance existing to ensure memory safety; ensure"]
|
|
#[doc = r" no stolen instances are passed to such software."]
|
|
pub unsafe fn steal() -> Self {
|
|
Self {
|
|
_marker: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
impl Deref for 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 = "GPIO Peripheral"]
|
|
pub mod porta;
|
|
#[doc = "GPIO Peripheral"]
|
|
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 = 0x4001_2400 as *const _;
|
|
#[doc = r"Return the pointer to the register block"]
|
|
#[inline(always)]
|
|
pub const fn ptr() -> *const porta::RegisterBlock {
|
|
Self::PTR
|
|
}
|
|
#[doc = r" Steal an instance of this peripheral"]
|
|
#[doc = r""]
|
|
#[doc = r" # Safety"]
|
|
#[doc = r""]
|
|
#[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
|
|
#[doc = r" that may race with any existing instances, for example by only"]
|
|
#[doc = r" accessing read-only or write-only registers, or by consuming the"]
|
|
#[doc = r" original peripheral and using critical sections to coordinate"]
|
|
#[doc = r" access between multiple new instances."]
|
|
#[doc = r""]
|
|
#[doc = r" Additionally, other software such as HALs may rely on only one"]
|
|
#[doc = r" peripheral instance existing to ensure memory safety; ensure"]
|
|
#[doc = r" no stolen instances are passed to such software."]
|
|
pub unsafe fn steal() -> Self {
|
|
Self {
|
|
_marker: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
impl Deref for 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 = "GPIO Peripheral"]
|
|
pub use self::porta as portb;
|
|
#[doc = "GPIO Peripheral"]
|
|
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 = 0x4001_2800 as *const _;
|
|
#[doc = r"Return the pointer to the register block"]
|
|
#[inline(always)]
|
|
pub const fn ptr() -> *const porta::RegisterBlock {
|
|
Self::PTR
|
|
}
|
|
#[doc = r" Steal an instance of this peripheral"]
|
|
#[doc = r""]
|
|
#[doc = r" # Safety"]
|
|
#[doc = r""]
|
|
#[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
|
|
#[doc = r" that may race with any existing instances, for example by only"]
|
|
#[doc = r" accessing read-only or write-only registers, or by consuming the"]
|
|
#[doc = r" original peripheral and using critical sections to coordinate"]
|
|
#[doc = r" access between multiple new instances."]
|
|
#[doc = r""]
|
|
#[doc = r" Additionally, other software such as HALs may rely on only one"]
|
|
#[doc = r" peripheral instance existing to ensure memory safety; ensure"]
|
|
#[doc = r" no stolen instances are passed to such software."]
|
|
pub unsafe fn steal() -> Self {
|
|
Self {
|
|
_marker: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
impl Deref for 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 = "GPIO Peripheral"]
|
|
pub use self::porta as portc;
|
|
#[doc = "GPIO Peripheral"]
|
|
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 = 0x4001_2c00 as *const _;
|
|
#[doc = r"Return the pointer to the register block"]
|
|
#[inline(always)]
|
|
pub const fn ptr() -> *const porta::RegisterBlock {
|
|
Self::PTR
|
|
}
|
|
#[doc = r" Steal an instance of this peripheral"]
|
|
#[doc = r""]
|
|
#[doc = r" # Safety"]
|
|
#[doc = r""]
|
|
#[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
|
|
#[doc = r" that may race with any existing instances, for example by only"]
|
|
#[doc = r" accessing read-only or write-only registers, or by consuming the"]
|
|
#[doc = r" original peripheral and using critical sections to coordinate"]
|
|
#[doc = r" access between multiple new instances."]
|
|
#[doc = r""]
|
|
#[doc = r" Additionally, other software such as HALs may rely on only one"]
|
|
#[doc = r" peripheral instance existing to ensure memory safety; ensure"]
|
|
#[doc = r" no stolen instances are passed to such software."]
|
|
pub unsafe fn steal() -> Self {
|
|
Self {
|
|
_marker: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
impl Deref for 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 = "GPIO Peripheral"]
|
|
pub use self::porta as portd;
|
|
#[doc = "GPIO Peripheral"]
|
|
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 = 0x4001_3000 as *const _;
|
|
#[doc = r"Return the pointer to the register block"]
|
|
#[inline(always)]
|
|
pub const fn ptr() -> *const porta::RegisterBlock {
|
|
Self::PTR
|
|
}
|
|
#[doc = r" Steal an instance of this peripheral"]
|
|
#[doc = r""]
|
|
#[doc = r" # Safety"]
|
|
#[doc = r""]
|
|
#[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
|
|
#[doc = r" that may race with any existing instances, for example by only"]
|
|
#[doc = r" accessing read-only or write-only registers, or by consuming the"]
|
|
#[doc = r" original peripheral and using critical sections to coordinate"]
|
|
#[doc = r" access between multiple new instances."]
|
|
#[doc = r""]
|
|
#[doc = r" Additionally, other software such as HALs may rely on only one"]
|
|
#[doc = r" peripheral instance existing to ensure memory safety; ensure"]
|
|
#[doc = r" no stolen instances are passed to such software."]
|
|
pub unsafe fn steal() -> Self {
|
|
Self {
|
|
_marker: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
impl Deref for 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 = "GPIO Peripheral"]
|
|
pub use self::porta as porte;
|
|
#[doc = "GPIO Peripheral"]
|
|
pub struct Portf {
|
|
_marker: PhantomData<*const ()>,
|
|
}
|
|
unsafe impl Send for Portf {}
|
|
impl Portf {
|
|
#[doc = r"Pointer to the register block"]
|
|
pub const PTR: *const porta::RegisterBlock = 0x4001_3400 as *const _;
|
|
#[doc = r"Return the pointer to the register block"]
|
|
#[inline(always)]
|
|
pub const fn ptr() -> *const porta::RegisterBlock {
|
|
Self::PTR
|
|
}
|
|
#[doc = r" Steal an instance of this peripheral"]
|
|
#[doc = r""]
|
|
#[doc = r" # Safety"]
|
|
#[doc = r""]
|
|
#[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
|
|
#[doc = r" that may race with any existing instances, for example by only"]
|
|
#[doc = r" accessing read-only or write-only registers, or by consuming the"]
|
|
#[doc = r" original peripheral and using critical sections to coordinate"]
|
|
#[doc = r" access between multiple new instances."]
|
|
#[doc = r""]
|
|
#[doc = r" Additionally, other software such as HALs may rely on only one"]
|
|
#[doc = r" peripheral instance existing to ensure memory safety; ensure"]
|
|
#[doc = r" no stolen instances are passed to such software."]
|
|
pub unsafe fn steal() -> Self {
|
|
Self {
|
|
_marker: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
impl Deref for Portf {
|
|
type Target = porta::RegisterBlock;
|
|
#[inline(always)]
|
|
fn deref(&self) -> &Self::Target {
|
|
unsafe { &*Self::PTR }
|
|
}
|
|
}
|
|
impl core::fmt::Debug for Portf {
|
|
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
|
|
f.debug_struct("Portf").finish()
|
|
}
|
|
}
|
|
#[doc = "GPIO Peripheral"]
|
|
pub use self::porta as portf;
|
|
#[doc = "GPIO Peripheral"]
|
|
pub struct Portg {
|
|
_marker: PhantomData<*const ()>,
|
|
}
|
|
unsafe impl Send for Portg {}
|
|
impl Portg {
|
|
#[doc = r"Pointer to the register block"]
|
|
pub const PTR: *const porta::RegisterBlock = 0x4001_3800 as *const _;
|
|
#[doc = r"Return the pointer to the register block"]
|
|
#[inline(always)]
|
|
pub const fn ptr() -> *const porta::RegisterBlock {
|
|
Self::PTR
|
|
}
|
|
#[doc = r" Steal an instance of this peripheral"]
|
|
#[doc = r""]
|
|
#[doc = r" # Safety"]
|
|
#[doc = r""]
|
|
#[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
|
|
#[doc = r" that may race with any existing instances, for example by only"]
|
|
#[doc = r" accessing read-only or write-only registers, or by consuming the"]
|
|
#[doc = r" original peripheral and using critical sections to coordinate"]
|
|
#[doc = r" access between multiple new instances."]
|
|
#[doc = r""]
|
|
#[doc = r" Additionally, other software such as HALs may rely on only one"]
|
|
#[doc = r" peripheral instance existing to ensure memory safety; ensure"]
|
|
#[doc = r" no stolen instances are passed to such software."]
|
|
pub unsafe fn steal() -> Self {
|
|
Self {
|
|
_marker: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
impl Deref for Portg {
|
|
type Target = porta::RegisterBlock;
|
|
#[inline(always)]
|
|
fn deref(&self) -> &Self::Target {
|
|
unsafe { &*Self::PTR }
|
|
}
|
|
}
|
|
impl core::fmt::Debug for Portg {
|
|
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
|
|
f.debug_struct("Portg").finish()
|
|
}
|
|
}
|
|
#[doc = "GPIO Peripheral"]
|
|
pub use self::porta as portg;
|
|
#[doc = "Timer/Counter Peripheral"]
|
|
pub struct Tim0 {
|
|
_marker: PhantomData<*const ()>,
|
|
}
|
|
unsafe impl Send for Tim0 {}
|
|
impl Tim0 {
|
|
#[doc = r"Pointer to the register block"]
|
|
pub const PTR: *const tim0::RegisterBlock = 0x4001_8000 as *const _;
|
|
#[doc = r"Return the pointer to the register block"]
|
|
#[inline(always)]
|
|
pub const fn ptr() -> *const tim0::RegisterBlock {
|
|
Self::PTR
|
|
}
|
|
#[doc = r" Steal an instance of this peripheral"]
|
|
#[doc = r""]
|
|
#[doc = r" # Safety"]
|
|
#[doc = r""]
|
|
#[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
|
|
#[doc = r" that may race with any existing instances, for example by only"]
|
|
#[doc = r" accessing read-only or write-only registers, or by consuming the"]
|
|
#[doc = r" original peripheral and using critical sections to coordinate"]
|
|
#[doc = r" access between multiple new instances."]
|
|
#[doc = r""]
|
|
#[doc = r" Additionally, other software such as HALs may rely on only one"]
|
|
#[doc = r" peripheral instance existing to ensure memory safety; ensure"]
|
|
#[doc = r" no stolen instances are passed to such software."]
|
|
pub unsafe fn steal() -> Self {
|
|
Self {
|
|
_marker: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
impl Deref for Tim0 {
|
|
type Target = tim0::RegisterBlock;
|
|
#[inline(always)]
|
|
fn deref(&self) -> &Self::Target {
|
|
unsafe { &*Self::PTR }
|
|
}
|
|
}
|
|
impl core::fmt::Debug for Tim0 {
|
|
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
|
|
f.debug_struct("Tim0").finish()
|
|
}
|
|
}
|
|
#[doc = "Timer/Counter Peripheral"]
|
|
pub mod tim0;
|
|
#[doc = "Timer/Counter Peripheral"]
|
|
pub struct Tim1 {
|
|
_marker: PhantomData<*const ()>,
|
|
}
|
|
unsafe impl Send for Tim1 {}
|
|
impl Tim1 {
|
|
#[doc = r"Pointer to the register block"]
|
|
pub const PTR: *const tim0::RegisterBlock = 0x4001_8400 as *const _;
|
|
#[doc = r"Return the pointer to the register block"]
|
|
#[inline(always)]
|
|
pub const fn ptr() -> *const tim0::RegisterBlock {
|
|
Self::PTR
|
|
}
|
|
#[doc = r" Steal an instance of this peripheral"]
|
|
#[doc = r""]
|
|
#[doc = r" # Safety"]
|
|
#[doc = r""]
|
|
#[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
|
|
#[doc = r" that may race with any existing instances, for example by only"]
|
|
#[doc = r" accessing read-only or write-only registers, or by consuming the"]
|
|
#[doc = r" original peripheral and using critical sections to coordinate"]
|
|
#[doc = r" access between multiple new instances."]
|
|
#[doc = r""]
|
|
#[doc = r" Additionally, other software such as HALs may rely on only one"]
|
|
#[doc = r" peripheral instance existing to ensure memory safety; ensure"]
|
|
#[doc = r" no stolen instances are passed to such software."]
|
|
pub unsafe fn steal() -> Self {
|
|
Self {
|
|
_marker: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
impl Deref for Tim1 {
|
|
type Target = tim0::RegisterBlock;
|
|
#[inline(always)]
|
|
fn deref(&self) -> &Self::Target {
|
|
unsafe { &*Self::PTR }
|
|
}
|
|
}
|
|
impl core::fmt::Debug for Tim1 {
|
|
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
|
|
f.debug_struct("Tim1").finish()
|
|
}
|
|
}
|
|
#[doc = "Timer/Counter Peripheral"]
|
|
pub use self::tim0 as tim1;
|
|
#[doc = "Timer/Counter Peripheral"]
|
|
pub struct Tim2 {
|
|
_marker: PhantomData<*const ()>,
|
|
}
|
|
unsafe impl Send for Tim2 {}
|
|
impl Tim2 {
|
|
#[doc = r"Pointer to the register block"]
|
|
pub const PTR: *const tim0::RegisterBlock = 0x4001_8800 as *const _;
|
|
#[doc = r"Return the pointer to the register block"]
|
|
#[inline(always)]
|
|
pub const fn ptr() -> *const tim0::RegisterBlock {
|
|
Self::PTR
|
|
}
|
|
#[doc = r" Steal an instance of this peripheral"]
|
|
#[doc = r""]
|
|
#[doc = r" # Safety"]
|
|
#[doc = r""]
|
|
#[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
|
|
#[doc = r" that may race with any existing instances, for example by only"]
|
|
#[doc = r" accessing read-only or write-only registers, or by consuming the"]
|
|
#[doc = r" original peripheral and using critical sections to coordinate"]
|
|
#[doc = r" access between multiple new instances."]
|
|
#[doc = r""]
|
|
#[doc = r" Additionally, other software such as HALs may rely on only one"]
|
|
#[doc = r" peripheral instance existing to ensure memory safety; ensure"]
|
|
#[doc = r" no stolen instances are passed to such software."]
|
|
pub unsafe fn steal() -> Self {
|
|
Self {
|
|
_marker: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
impl Deref for Tim2 {
|
|
type Target = tim0::RegisterBlock;
|
|
#[inline(always)]
|
|
fn deref(&self) -> &Self::Target {
|
|
unsafe { &*Self::PTR }
|
|
}
|
|
}
|
|
impl core::fmt::Debug for Tim2 {
|
|
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
|
|
f.debug_struct("Tim2").finish()
|
|
}
|
|
}
|
|
#[doc = "Timer/Counter Peripheral"]
|
|
pub use self::tim0 as tim2;
|
|
#[doc = "Timer/Counter Peripheral"]
|
|
pub struct Tim3 {
|
|
_marker: PhantomData<*const ()>,
|
|
}
|
|
unsafe impl Send for Tim3 {}
|
|
impl Tim3 {
|
|
#[doc = r"Pointer to the register block"]
|
|
pub const PTR: *const tim0::RegisterBlock = 0x4001_8c00 as *const _;
|
|
#[doc = r"Return the pointer to the register block"]
|
|
#[inline(always)]
|
|
pub const fn ptr() -> *const tim0::RegisterBlock {
|
|
Self::PTR
|
|
}
|
|
#[doc = r" Steal an instance of this peripheral"]
|
|
#[doc = r""]
|
|
#[doc = r" # Safety"]
|
|
#[doc = r""]
|
|
#[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
|
|
#[doc = r" that may race with any existing instances, for example by only"]
|
|
#[doc = r" accessing read-only or write-only registers, or by consuming the"]
|
|
#[doc = r" original peripheral and using critical sections to coordinate"]
|
|
#[doc = r" access between multiple new instances."]
|
|
#[doc = r""]
|
|
#[doc = r" Additionally, other software such as HALs may rely on only one"]
|
|
#[doc = r" peripheral instance existing to ensure memory safety; ensure"]
|
|
#[doc = r" no stolen instances are passed to such software."]
|
|
pub unsafe fn steal() -> Self {
|
|
Self {
|
|
_marker: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
impl Deref for Tim3 {
|
|
type Target = tim0::RegisterBlock;
|
|
#[inline(always)]
|
|
fn deref(&self) -> &Self::Target {
|
|
unsafe { &*Self::PTR }
|
|
}
|
|
}
|
|
impl core::fmt::Debug for Tim3 {
|
|
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
|
|
f.debug_struct("Tim3").finish()
|
|
}
|
|
}
|
|
#[doc = "Timer/Counter Peripheral"]
|
|
pub use self::tim0 as tim3;
|
|
#[doc = "Timer/Counter Peripheral"]
|
|
pub struct Tim4 {
|
|
_marker: PhantomData<*const ()>,
|
|
}
|
|
unsafe impl Send for Tim4 {}
|
|
impl Tim4 {
|
|
#[doc = r"Pointer to the register block"]
|
|
pub const PTR: *const tim0::RegisterBlock = 0x4001_9000 as *const _;
|
|
#[doc = r"Return the pointer to the register block"]
|
|
#[inline(always)]
|
|
pub const fn ptr() -> *const tim0::RegisterBlock {
|
|
Self::PTR
|
|
}
|
|
#[doc = r" Steal an instance of this peripheral"]
|
|
#[doc = r""]
|
|
#[doc = r" # Safety"]
|
|
#[doc = r""]
|
|
#[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
|
|
#[doc = r" that may race with any existing instances, for example by only"]
|
|
#[doc = r" accessing read-only or write-only registers, or by consuming the"]
|
|
#[doc = r" original peripheral and using critical sections to coordinate"]
|
|
#[doc = r" access between multiple new instances."]
|
|
#[doc = r""]
|
|
#[doc = r" Additionally, other software such as HALs may rely on only one"]
|
|
#[doc = r" peripheral instance existing to ensure memory safety; ensure"]
|
|
#[doc = r" no stolen instances are passed to such software."]
|
|
pub unsafe fn steal() -> Self {
|
|
Self {
|
|
_marker: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
impl Deref for Tim4 {
|
|
type Target = tim0::RegisterBlock;
|
|
#[inline(always)]
|
|
fn deref(&self) -> &Self::Target {
|
|
unsafe { &*Self::PTR }
|
|
}
|
|
}
|
|
impl core::fmt::Debug for Tim4 {
|
|
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
|
|
f.debug_struct("Tim4").finish()
|
|
}
|
|
}
|
|
#[doc = "Timer/Counter Peripheral"]
|
|
pub use self::tim0 as tim4;
|
|
#[doc = "Timer/Counter Peripheral"]
|
|
pub struct Tim5 {
|
|
_marker: PhantomData<*const ()>,
|
|
}
|
|
unsafe impl Send for Tim5 {}
|
|
impl Tim5 {
|
|
#[doc = r"Pointer to the register block"]
|
|
pub const PTR: *const tim0::RegisterBlock = 0x4001_9400 as *const _;
|
|
#[doc = r"Return the pointer to the register block"]
|
|
#[inline(always)]
|
|
pub const fn ptr() -> *const tim0::RegisterBlock {
|
|
Self::PTR
|
|
}
|
|
#[doc = r" Steal an instance of this peripheral"]
|
|
#[doc = r""]
|
|
#[doc = r" # Safety"]
|
|
#[doc = r""]
|
|
#[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
|
|
#[doc = r" that may race with any existing instances, for example by only"]
|
|
#[doc = r" accessing read-only or write-only registers, or by consuming the"]
|
|
#[doc = r" original peripheral and using critical sections to coordinate"]
|
|
#[doc = r" access between multiple new instances."]
|
|
#[doc = r""]
|
|
#[doc = r" Additionally, other software such as HALs may rely on only one"]
|
|
#[doc = r" peripheral instance existing to ensure memory safety; ensure"]
|
|
#[doc = r" no stolen instances are passed to such software."]
|
|
pub unsafe fn steal() -> Self {
|
|
Self {
|
|
_marker: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
impl Deref for Tim5 {
|
|
type Target = tim0::RegisterBlock;
|
|
#[inline(always)]
|
|
fn deref(&self) -> &Self::Target {
|
|
unsafe { &*Self::PTR }
|
|
}
|
|
}
|
|
impl core::fmt::Debug for Tim5 {
|
|
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
|
|
f.debug_struct("Tim5").finish()
|
|
}
|
|
}
|
|
#[doc = "Timer/Counter Peripheral"]
|
|
pub use self::tim0 as tim5;
|
|
#[doc = "Timer/Counter Peripheral"]
|
|
pub struct Tim6 {
|
|
_marker: PhantomData<*const ()>,
|
|
}
|
|
unsafe impl Send for Tim6 {}
|
|
impl Tim6 {
|
|
#[doc = r"Pointer to the register block"]
|
|
pub const PTR: *const tim0::RegisterBlock = 0x4001_9800 as *const _;
|
|
#[doc = r"Return the pointer to the register block"]
|
|
#[inline(always)]
|
|
pub const fn ptr() -> *const tim0::RegisterBlock {
|
|
Self::PTR
|
|
}
|
|
#[doc = r" Steal an instance of this peripheral"]
|
|
#[doc = r""]
|
|
#[doc = r" # Safety"]
|
|
#[doc = r""]
|
|
#[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
|
|
#[doc = r" that may race with any existing instances, for example by only"]
|
|
#[doc = r" accessing read-only or write-only registers, or by consuming the"]
|
|
#[doc = r" original peripheral and using critical sections to coordinate"]
|
|
#[doc = r" access between multiple new instances."]
|
|
#[doc = r""]
|
|
#[doc = r" Additionally, other software such as HALs may rely on only one"]
|
|
#[doc = r" peripheral instance existing to ensure memory safety; ensure"]
|
|
#[doc = r" no stolen instances are passed to such software."]
|
|
pub unsafe fn steal() -> Self {
|
|
Self {
|
|
_marker: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
impl Deref for Tim6 {
|
|
type Target = tim0::RegisterBlock;
|
|
#[inline(always)]
|
|
fn deref(&self) -> &Self::Target {
|
|
unsafe { &*Self::PTR }
|
|
}
|
|
}
|
|
impl core::fmt::Debug for Tim6 {
|
|
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
|
|
f.debug_struct("Tim6").finish()
|
|
}
|
|
}
|
|
#[doc = "Timer/Counter Peripheral"]
|
|
pub use self::tim0 as tim6;
|
|
#[doc = "Timer/Counter Peripheral"]
|
|
pub struct Tim7 {
|
|
_marker: PhantomData<*const ()>,
|
|
}
|
|
unsafe impl Send for Tim7 {}
|
|
impl Tim7 {
|
|
#[doc = r"Pointer to the register block"]
|
|
pub const PTR: *const tim0::RegisterBlock = 0x4001_9c00 as *const _;
|
|
#[doc = r"Return the pointer to the register block"]
|
|
#[inline(always)]
|
|
pub const fn ptr() -> *const tim0::RegisterBlock {
|
|
Self::PTR
|
|
}
|
|
#[doc = r" Steal an instance of this peripheral"]
|
|
#[doc = r""]
|
|
#[doc = r" # Safety"]
|
|
#[doc = r""]
|
|
#[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
|
|
#[doc = r" that may race with any existing instances, for example by only"]
|
|
#[doc = r" accessing read-only or write-only registers, or by consuming the"]
|
|
#[doc = r" original peripheral and using critical sections to coordinate"]
|
|
#[doc = r" access between multiple new instances."]
|
|
#[doc = r""]
|
|
#[doc = r" Additionally, other software such as HALs may rely on only one"]
|
|
#[doc = r" peripheral instance existing to ensure memory safety; ensure"]
|
|
#[doc = r" no stolen instances are passed to such software."]
|
|
pub unsafe fn steal() -> Self {
|
|
Self {
|
|
_marker: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
impl Deref for Tim7 {
|
|
type Target = tim0::RegisterBlock;
|
|
#[inline(always)]
|
|
fn deref(&self) -> &Self::Target {
|
|
unsafe { &*Self::PTR }
|
|
}
|
|
}
|
|
impl core::fmt::Debug for Tim7 {
|
|
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
|
|
f.debug_struct("Tim7").finish()
|
|
}
|
|
}
|
|
#[doc = "Timer/Counter Peripheral"]
|
|
pub use self::tim0 as tim7;
|
|
#[doc = "Timer/Counter Peripheral"]
|
|
pub struct Tim8 {
|
|
_marker: PhantomData<*const ()>,
|
|
}
|
|
unsafe impl Send for Tim8 {}
|
|
impl Tim8 {
|
|
#[doc = r"Pointer to the register block"]
|
|
pub const PTR: *const tim0::RegisterBlock = 0x4001_a000 as *const _;
|
|
#[doc = r"Return the pointer to the register block"]
|
|
#[inline(always)]
|
|
pub const fn ptr() -> *const tim0::RegisterBlock {
|
|
Self::PTR
|
|
}
|
|
#[doc = r" Steal an instance of this peripheral"]
|
|
#[doc = r""]
|
|
#[doc = r" # Safety"]
|
|
#[doc = r""]
|
|
#[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
|
|
#[doc = r" that may race with any existing instances, for example by only"]
|
|
#[doc = r" accessing read-only or write-only registers, or by consuming the"]
|
|
#[doc = r" original peripheral and using critical sections to coordinate"]
|
|
#[doc = r" access between multiple new instances."]
|
|
#[doc = r""]
|
|
#[doc = r" Additionally, other software such as HALs may rely on only one"]
|
|
#[doc = r" peripheral instance existing to ensure memory safety; ensure"]
|
|
#[doc = r" no stolen instances are passed to such software."]
|
|
pub unsafe fn steal() -> Self {
|
|
Self {
|
|
_marker: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
impl Deref for Tim8 {
|
|
type Target = tim0::RegisterBlock;
|
|
#[inline(always)]
|
|
fn deref(&self) -> &Self::Target {
|
|
unsafe { &*Self::PTR }
|
|
}
|
|
}
|
|
impl core::fmt::Debug for Tim8 {
|
|
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
|
|
f.debug_struct("Tim8").finish()
|
|
}
|
|
}
|
|
#[doc = "Timer/Counter Peripheral"]
|
|
pub use self::tim0 as tim8;
|
|
#[doc = "Timer/Counter Peripheral"]
|
|
pub struct Tim9 {
|
|
_marker: PhantomData<*const ()>,
|
|
}
|
|
unsafe impl Send for Tim9 {}
|
|
impl Tim9 {
|
|
#[doc = r"Pointer to the register block"]
|
|
pub const PTR: *const tim0::RegisterBlock = 0x4001_a400 as *const _;
|
|
#[doc = r"Return the pointer to the register block"]
|
|
#[inline(always)]
|
|
pub const fn ptr() -> *const tim0::RegisterBlock {
|
|
Self::PTR
|
|
}
|
|
#[doc = r" Steal an instance of this peripheral"]
|
|
#[doc = r""]
|
|
#[doc = r" # Safety"]
|
|
#[doc = r""]
|
|
#[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
|
|
#[doc = r" that may race with any existing instances, for example by only"]
|
|
#[doc = r" accessing read-only or write-only registers, or by consuming the"]
|
|
#[doc = r" original peripheral and using critical sections to coordinate"]
|
|
#[doc = r" access between multiple new instances."]
|
|
#[doc = r""]
|
|
#[doc = r" Additionally, other software such as HALs may rely on only one"]
|
|
#[doc = r" peripheral instance existing to ensure memory safety; ensure"]
|
|
#[doc = r" no stolen instances are passed to such software."]
|
|
pub unsafe fn steal() -> Self {
|
|
Self {
|
|
_marker: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
impl Deref for Tim9 {
|
|
type Target = tim0::RegisterBlock;
|
|
#[inline(always)]
|
|
fn deref(&self) -> &Self::Target {
|
|
unsafe { &*Self::PTR }
|
|
}
|
|
}
|
|
impl core::fmt::Debug for Tim9 {
|
|
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
|
|
f.debug_struct("Tim9").finish()
|
|
}
|
|
}
|
|
#[doc = "Timer/Counter Peripheral"]
|
|
pub use self::tim0 as tim9;
|
|
#[doc = "Timer/Counter Peripheral"]
|
|
pub struct Tim10 {
|
|
_marker: PhantomData<*const ()>,
|
|
}
|
|
unsafe impl Send for Tim10 {}
|
|
impl Tim10 {
|
|
#[doc = r"Pointer to the register block"]
|
|
pub const PTR: *const tim0::RegisterBlock = 0x4001_a800 as *const _;
|
|
#[doc = r"Return the pointer to the register block"]
|
|
#[inline(always)]
|
|
pub const fn ptr() -> *const tim0::RegisterBlock {
|
|
Self::PTR
|
|
}
|
|
#[doc = r" Steal an instance of this peripheral"]
|
|
#[doc = r""]
|
|
#[doc = r" # Safety"]
|
|
#[doc = r""]
|
|
#[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
|
|
#[doc = r" that may race with any existing instances, for example by only"]
|
|
#[doc = r" accessing read-only or write-only registers, or by consuming the"]
|
|
#[doc = r" original peripheral and using critical sections to coordinate"]
|
|
#[doc = r" access between multiple new instances."]
|
|
#[doc = r""]
|
|
#[doc = r" Additionally, other software such as HALs may rely on only one"]
|
|
#[doc = r" peripheral instance existing to ensure memory safety; ensure"]
|
|
#[doc = r" no stolen instances are passed to such software."]
|
|
pub unsafe fn steal() -> Self {
|
|
Self {
|
|
_marker: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
impl Deref for Tim10 {
|
|
type Target = tim0::RegisterBlock;
|
|
#[inline(always)]
|
|
fn deref(&self) -> &Self::Target {
|
|
unsafe { &*Self::PTR }
|
|
}
|
|
}
|
|
impl core::fmt::Debug for Tim10 {
|
|
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
|
|
f.debug_struct("Tim10").finish()
|
|
}
|
|
}
|
|
#[doc = "Timer/Counter Peripheral"]
|
|
pub use self::tim0 as tim10;
|
|
#[doc = "Timer/Counter Peripheral"]
|
|
pub struct Tim11 {
|
|
_marker: PhantomData<*const ()>,
|
|
}
|
|
unsafe impl Send for Tim11 {}
|
|
impl Tim11 {
|
|
#[doc = r"Pointer to the register block"]
|
|
pub const PTR: *const tim0::RegisterBlock = 0x4001_ac00 as *const _;
|
|
#[doc = r"Return the pointer to the register block"]
|
|
#[inline(always)]
|
|
pub const fn ptr() -> *const tim0::RegisterBlock {
|
|
Self::PTR
|
|
}
|
|
#[doc = r" Steal an instance of this peripheral"]
|
|
#[doc = r""]
|
|
#[doc = r" # Safety"]
|
|
#[doc = r""]
|
|
#[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
|
|
#[doc = r" that may race with any existing instances, for example by only"]
|
|
#[doc = r" accessing read-only or write-only registers, or by consuming the"]
|
|
#[doc = r" original peripheral and using critical sections to coordinate"]
|
|
#[doc = r" access between multiple new instances."]
|
|
#[doc = r""]
|
|
#[doc = r" Additionally, other software such as HALs may rely on only one"]
|
|
#[doc = r" peripheral instance existing to ensure memory safety; ensure"]
|
|
#[doc = r" no stolen instances are passed to such software."]
|
|
pub unsafe fn steal() -> Self {
|
|
Self {
|
|
_marker: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
impl Deref for Tim11 {
|
|
type Target = tim0::RegisterBlock;
|
|
#[inline(always)]
|
|
fn deref(&self) -> &Self::Target {
|
|
unsafe { &*Self::PTR }
|
|
}
|
|
}
|
|
impl core::fmt::Debug for Tim11 {
|
|
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
|
|
f.debug_struct("Tim11").finish()
|
|
}
|
|
}
|
|
#[doc = "Timer/Counter Peripheral"]
|
|
pub use self::tim0 as tim11;
|
|
#[doc = "Timer/Counter Peripheral"]
|
|
pub struct Tim12 {
|
|
_marker: PhantomData<*const ()>,
|
|
}
|
|
unsafe impl Send for Tim12 {}
|
|
impl Tim12 {
|
|
#[doc = r"Pointer to the register block"]
|
|
pub const PTR: *const tim0::RegisterBlock = 0x4001_b000 as *const _;
|
|
#[doc = r"Return the pointer to the register block"]
|
|
#[inline(always)]
|
|
pub const fn ptr() -> *const tim0::RegisterBlock {
|
|
Self::PTR
|
|
}
|
|
#[doc = r" Steal an instance of this peripheral"]
|
|
#[doc = r""]
|
|
#[doc = r" # Safety"]
|
|
#[doc = r""]
|
|
#[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
|
|
#[doc = r" that may race with any existing instances, for example by only"]
|
|
#[doc = r" accessing read-only or write-only registers, or by consuming the"]
|
|
#[doc = r" original peripheral and using critical sections to coordinate"]
|
|
#[doc = r" access between multiple new instances."]
|
|
#[doc = r""]
|
|
#[doc = r" Additionally, other software such as HALs may rely on only one"]
|
|
#[doc = r" peripheral instance existing to ensure memory safety; ensure"]
|
|
#[doc = r" no stolen instances are passed to such software."]
|
|
pub unsafe fn steal() -> Self {
|
|
Self {
|
|
_marker: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
impl Deref for Tim12 {
|
|
type Target = tim0::RegisterBlock;
|
|
#[inline(always)]
|
|
fn deref(&self) -> &Self::Target {
|
|
unsafe { &*Self::PTR }
|
|
}
|
|
}
|
|
impl core::fmt::Debug for Tim12 {
|
|
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
|
|
f.debug_struct("Tim12").finish()
|
|
}
|
|
}
|
|
#[doc = "Timer/Counter Peripheral"]
|
|
pub use self::tim0 as tim12;
|
|
#[doc = "Timer/Counter Peripheral"]
|
|
pub struct Tim13 {
|
|
_marker: PhantomData<*const ()>,
|
|
}
|
|
unsafe impl Send for Tim13 {}
|
|
impl Tim13 {
|
|
#[doc = r"Pointer to the register block"]
|
|
pub const PTR: *const tim0::RegisterBlock = 0x4001_b400 as *const _;
|
|
#[doc = r"Return the pointer to the register block"]
|
|
#[inline(always)]
|
|
pub const fn ptr() -> *const tim0::RegisterBlock {
|
|
Self::PTR
|
|
}
|
|
#[doc = r" Steal an instance of this peripheral"]
|
|
#[doc = r""]
|
|
#[doc = r" # Safety"]
|
|
#[doc = r""]
|
|
#[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
|
|
#[doc = r" that may race with any existing instances, for example by only"]
|
|
#[doc = r" accessing read-only or write-only registers, or by consuming the"]
|
|
#[doc = r" original peripheral and using critical sections to coordinate"]
|
|
#[doc = r" access between multiple new instances."]
|
|
#[doc = r""]
|
|
#[doc = r" Additionally, other software such as HALs may rely on only one"]
|
|
#[doc = r" peripheral instance existing to ensure memory safety; ensure"]
|
|
#[doc = r" no stolen instances are passed to such software."]
|
|
pub unsafe fn steal() -> Self {
|
|
Self {
|
|
_marker: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
impl Deref for Tim13 {
|
|
type Target = tim0::RegisterBlock;
|
|
#[inline(always)]
|
|
fn deref(&self) -> &Self::Target {
|
|
unsafe { &*Self::PTR }
|
|
}
|
|
}
|
|
impl core::fmt::Debug for Tim13 {
|
|
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
|
|
f.debug_struct("Tim13").finish()
|
|
}
|
|
}
|
|
#[doc = "Timer/Counter Peripheral"]
|
|
pub use self::tim0 as tim13;
|
|
#[doc = "Timer/Counter Peripheral"]
|
|
pub struct Tim14 {
|
|
_marker: PhantomData<*const ()>,
|
|
}
|
|
unsafe impl Send for Tim14 {}
|
|
impl Tim14 {
|
|
#[doc = r"Pointer to the register block"]
|
|
pub const PTR: *const tim0::RegisterBlock = 0x4001_b800 as *const _;
|
|
#[doc = r"Return the pointer to the register block"]
|
|
#[inline(always)]
|
|
pub const fn ptr() -> *const tim0::RegisterBlock {
|
|
Self::PTR
|
|
}
|
|
#[doc = r" Steal an instance of this peripheral"]
|
|
#[doc = r""]
|
|
#[doc = r" # Safety"]
|
|
#[doc = r""]
|
|
#[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
|
|
#[doc = r" that may race with any existing instances, for example by only"]
|
|
#[doc = r" accessing read-only or write-only registers, or by consuming the"]
|
|
#[doc = r" original peripheral and using critical sections to coordinate"]
|
|
#[doc = r" access between multiple new instances."]
|
|
#[doc = r""]
|
|
#[doc = r" Additionally, other software such as HALs may rely on only one"]
|
|
#[doc = r" peripheral instance existing to ensure memory safety; ensure"]
|
|
#[doc = r" no stolen instances are passed to such software."]
|
|
pub unsafe fn steal() -> Self {
|
|
Self {
|
|
_marker: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
impl Deref for Tim14 {
|
|
type Target = tim0::RegisterBlock;
|
|
#[inline(always)]
|
|
fn deref(&self) -> &Self::Target {
|
|
unsafe { &*Self::PTR }
|
|
}
|
|
}
|
|
impl core::fmt::Debug for Tim14 {
|
|
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
|
|
f.debug_struct("Tim14").finish()
|
|
}
|
|
}
|
|
#[doc = "Timer/Counter Peripheral"]
|
|
pub use self::tim0 as tim14;
|
|
#[doc = "Timer/Counter Peripheral"]
|
|
pub struct Tim15 {
|
|
_marker: PhantomData<*const ()>,
|
|
}
|
|
unsafe impl Send for Tim15 {}
|
|
impl Tim15 {
|
|
#[doc = r"Pointer to the register block"]
|
|
pub const PTR: *const tim0::RegisterBlock = 0x4001_bc00 as *const _;
|
|
#[doc = r"Return the pointer to the register block"]
|
|
#[inline(always)]
|
|
pub const fn ptr() -> *const tim0::RegisterBlock {
|
|
Self::PTR
|
|
}
|
|
#[doc = r" Steal an instance of this peripheral"]
|
|
#[doc = r""]
|
|
#[doc = r" # Safety"]
|
|
#[doc = r""]
|
|
#[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
|
|
#[doc = r" that may race with any existing instances, for example by only"]
|
|
#[doc = r" accessing read-only or write-only registers, or by consuming the"]
|
|
#[doc = r" original peripheral and using critical sections to coordinate"]
|
|
#[doc = r" access between multiple new instances."]
|
|
#[doc = r""]
|
|
#[doc = r" Additionally, other software such as HALs may rely on only one"]
|
|
#[doc = r" peripheral instance existing to ensure memory safety; ensure"]
|
|
#[doc = r" no stolen instances are passed to such software."]
|
|
pub unsafe fn steal() -> Self {
|
|
Self {
|
|
_marker: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
impl Deref for Tim15 {
|
|
type Target = tim0::RegisterBlock;
|
|
#[inline(always)]
|
|
fn deref(&self) -> &Self::Target {
|
|
unsafe { &*Self::PTR }
|
|
}
|
|
}
|
|
impl core::fmt::Debug for Tim15 {
|
|
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
|
|
f.debug_struct("Tim15").finish()
|
|
}
|
|
}
|
|
#[doc = "Timer/Counter Peripheral"]
|
|
pub use self::tim0 as tim15;
|
|
#[doc = "Timer/Counter Peripheral"]
|
|
pub struct Tim16 {
|
|
_marker: PhantomData<*const ()>,
|
|
}
|
|
unsafe impl Send for Tim16 {}
|
|
impl Tim16 {
|
|
#[doc = r"Pointer to the register block"]
|
|
pub const PTR: *const tim0::RegisterBlock = 0x4002_8000 as *const _;
|
|
#[doc = r"Return the pointer to the register block"]
|
|
#[inline(always)]
|
|
pub const fn ptr() -> *const tim0::RegisterBlock {
|
|
Self::PTR
|
|
}
|
|
#[doc = r" Steal an instance of this peripheral"]
|
|
#[doc = r""]
|
|
#[doc = r" # Safety"]
|
|
#[doc = r""]
|
|
#[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
|
|
#[doc = r" that may race with any existing instances, for example by only"]
|
|
#[doc = r" accessing read-only or write-only registers, or by consuming the"]
|
|
#[doc = r" original peripheral and using critical sections to coordinate"]
|
|
#[doc = r" access between multiple new instances."]
|
|
#[doc = r""]
|
|
#[doc = r" Additionally, other software such as HALs may rely on only one"]
|
|
#[doc = r" peripheral instance existing to ensure memory safety; ensure"]
|
|
#[doc = r" no stolen instances are passed to such software."]
|
|
pub unsafe fn steal() -> Self {
|
|
Self {
|
|
_marker: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
impl Deref for Tim16 {
|
|
type Target = tim0::RegisterBlock;
|
|
#[inline(always)]
|
|
fn deref(&self) -> &Self::Target {
|
|
unsafe { &*Self::PTR }
|
|
}
|
|
}
|
|
impl core::fmt::Debug for Tim16 {
|
|
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
|
|
f.debug_struct("Tim16").finish()
|
|
}
|
|
}
|
|
#[doc = "Timer/Counter Peripheral"]
|
|
pub use self::tim0 as tim16;
|
|
#[doc = "Timer/Counter Peripheral"]
|
|
pub struct Tim17 {
|
|
_marker: PhantomData<*const ()>,
|
|
}
|
|
unsafe impl Send for Tim17 {}
|
|
impl Tim17 {
|
|
#[doc = r"Pointer to the register block"]
|
|
pub const PTR: *const tim0::RegisterBlock = 0x4002_8400 as *const _;
|
|
#[doc = r"Return the pointer to the register block"]
|
|
#[inline(always)]
|
|
pub const fn ptr() -> *const tim0::RegisterBlock {
|
|
Self::PTR
|
|
}
|
|
#[doc = r" Steal an instance of this peripheral"]
|
|
#[doc = r""]
|
|
#[doc = r" # Safety"]
|
|
#[doc = r""]
|
|
#[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
|
|
#[doc = r" that may race with any existing instances, for example by only"]
|
|
#[doc = r" accessing read-only or write-only registers, or by consuming the"]
|
|
#[doc = r" original peripheral and using critical sections to coordinate"]
|
|
#[doc = r" access between multiple new instances."]
|
|
#[doc = r""]
|
|
#[doc = r" Additionally, other software such as HALs may rely on only one"]
|
|
#[doc = r" peripheral instance existing to ensure memory safety; ensure"]
|
|
#[doc = r" no stolen instances are passed to such software."]
|
|
pub unsafe fn steal() -> Self {
|
|
Self {
|
|
_marker: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
impl Deref for Tim17 {
|
|
type Target = tim0::RegisterBlock;
|
|
#[inline(always)]
|
|
fn deref(&self) -> &Self::Target {
|
|
unsafe { &*Self::PTR }
|
|
}
|
|
}
|
|
impl core::fmt::Debug for Tim17 {
|
|
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
|
|
f.debug_struct("Tim17").finish()
|
|
}
|
|
}
|
|
#[doc = "Timer/Counter Peripheral"]
|
|
pub use self::tim0 as tim17;
|
|
#[doc = "Timer/Counter Peripheral"]
|
|
pub struct Tim18 {
|
|
_marker: PhantomData<*const ()>,
|
|
}
|
|
unsafe impl Send for Tim18 {}
|
|
impl Tim18 {
|
|
#[doc = r"Pointer to the register block"]
|
|
pub const PTR: *const tim0::RegisterBlock = 0x4002_8800 as *const _;
|
|
#[doc = r"Return the pointer to the register block"]
|
|
#[inline(always)]
|
|
pub const fn ptr() -> *const tim0::RegisterBlock {
|
|
Self::PTR
|
|
}
|
|
#[doc = r" Steal an instance of this peripheral"]
|
|
#[doc = r""]
|
|
#[doc = r" # Safety"]
|
|
#[doc = r""]
|
|
#[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
|
|
#[doc = r" that may race with any existing instances, for example by only"]
|
|
#[doc = r" accessing read-only or write-only registers, or by consuming the"]
|
|
#[doc = r" original peripheral and using critical sections to coordinate"]
|
|
#[doc = r" access between multiple new instances."]
|
|
#[doc = r""]
|
|
#[doc = r" Additionally, other software such as HALs may rely on only one"]
|
|
#[doc = r" peripheral instance existing to ensure memory safety; ensure"]
|
|
#[doc = r" no stolen instances are passed to such software."]
|
|
pub unsafe fn steal() -> Self {
|
|
Self {
|
|
_marker: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
impl Deref for Tim18 {
|
|
type Target = tim0::RegisterBlock;
|
|
#[inline(always)]
|
|
fn deref(&self) -> &Self::Target {
|
|
unsafe { &*Self::PTR }
|
|
}
|
|
}
|
|
impl core::fmt::Debug for Tim18 {
|
|
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
|
|
f.debug_struct("Tim18").finish()
|
|
}
|
|
}
|
|
#[doc = "Timer/Counter Peripheral"]
|
|
pub use self::tim0 as tim18;
|
|
#[doc = "Timer/Counter Peripheral"]
|
|
pub struct Tim19 {
|
|
_marker: PhantomData<*const ()>,
|
|
}
|
|
unsafe impl Send for Tim19 {}
|
|
impl Tim19 {
|
|
#[doc = r"Pointer to the register block"]
|
|
pub const PTR: *const tim0::RegisterBlock = 0x4002_8c00 as *const _;
|
|
#[doc = r"Return the pointer to the register block"]
|
|
#[inline(always)]
|
|
pub const fn ptr() -> *const tim0::RegisterBlock {
|
|
Self::PTR
|
|
}
|
|
#[doc = r" Steal an instance of this peripheral"]
|
|
#[doc = r""]
|
|
#[doc = r" # Safety"]
|
|
#[doc = r""]
|
|
#[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
|
|
#[doc = r" that may race with any existing instances, for example by only"]
|
|
#[doc = r" accessing read-only or write-only registers, or by consuming the"]
|
|
#[doc = r" original peripheral and using critical sections to coordinate"]
|
|
#[doc = r" access between multiple new instances."]
|
|
#[doc = r""]
|
|
#[doc = r" Additionally, other software such as HALs may rely on only one"]
|
|
#[doc = r" peripheral instance existing to ensure memory safety; ensure"]
|
|
#[doc = r" no stolen instances are passed to such software."]
|
|
pub unsafe fn steal() -> Self {
|
|
Self {
|
|
_marker: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
impl Deref for Tim19 {
|
|
type Target = tim0::RegisterBlock;
|
|
#[inline(always)]
|
|
fn deref(&self) -> &Self::Target {
|
|
unsafe { &*Self::PTR }
|
|
}
|
|
}
|
|
impl core::fmt::Debug for Tim19 {
|
|
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
|
|
f.debug_struct("Tim19").finish()
|
|
}
|
|
}
|
|
#[doc = "Timer/Counter Peripheral"]
|
|
pub use self::tim0 as tim19;
|
|
#[doc = "Timer/Counter Peripheral"]
|
|
pub struct Tim20 {
|
|
_marker: PhantomData<*const ()>,
|
|
}
|
|
unsafe impl Send for Tim20 {}
|
|
impl Tim20 {
|
|
#[doc = r"Pointer to the register block"]
|
|
pub const PTR: *const tim0::RegisterBlock = 0x4002_9000 as *const _;
|
|
#[doc = r"Return the pointer to the register block"]
|
|
#[inline(always)]
|
|
pub const fn ptr() -> *const tim0::RegisterBlock {
|
|
Self::PTR
|
|
}
|
|
#[doc = r" Steal an instance of this peripheral"]
|
|
#[doc = r""]
|
|
#[doc = r" # Safety"]
|
|
#[doc = r""]
|
|
#[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
|
|
#[doc = r" that may race with any existing instances, for example by only"]
|
|
#[doc = r" accessing read-only or write-only registers, or by consuming the"]
|
|
#[doc = r" original peripheral and using critical sections to coordinate"]
|
|
#[doc = r" access between multiple new instances."]
|
|
#[doc = r""]
|
|
#[doc = r" Additionally, other software such as HALs may rely on only one"]
|
|
#[doc = r" peripheral instance existing to ensure memory safety; ensure"]
|
|
#[doc = r" no stolen instances are passed to such software."]
|
|
pub unsafe fn steal() -> Self {
|
|
Self {
|
|
_marker: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
impl Deref for Tim20 {
|
|
type Target = tim0::RegisterBlock;
|
|
#[inline(always)]
|
|
fn deref(&self) -> &Self::Target {
|
|
unsafe { &*Self::PTR }
|
|
}
|
|
}
|
|
impl core::fmt::Debug for Tim20 {
|
|
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
|
|
f.debug_struct("Tim20").finish()
|
|
}
|
|
}
|
|
#[doc = "Timer/Counter Peripheral"]
|
|
pub use self::tim0 as tim20;
|
|
#[doc = "Timer/Counter Peripheral"]
|
|
pub struct Tim21 {
|
|
_marker: PhantomData<*const ()>,
|
|
}
|
|
unsafe impl Send for Tim21 {}
|
|
impl Tim21 {
|
|
#[doc = r"Pointer to the register block"]
|
|
pub const PTR: *const tim0::RegisterBlock = 0x4002_9400 as *const _;
|
|
#[doc = r"Return the pointer to the register block"]
|
|
#[inline(always)]
|
|
pub const fn ptr() -> *const tim0::RegisterBlock {
|
|
Self::PTR
|
|
}
|
|
#[doc = r" Steal an instance of this peripheral"]
|
|
#[doc = r""]
|
|
#[doc = r" # Safety"]
|
|
#[doc = r""]
|
|
#[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
|
|
#[doc = r" that may race with any existing instances, for example by only"]
|
|
#[doc = r" accessing read-only or write-only registers, or by consuming the"]
|
|
#[doc = r" original peripheral and using critical sections to coordinate"]
|
|
#[doc = r" access between multiple new instances."]
|
|
#[doc = r""]
|
|
#[doc = r" Additionally, other software such as HALs may rely on only one"]
|
|
#[doc = r" peripheral instance existing to ensure memory safety; ensure"]
|
|
#[doc = r" no stolen instances are passed to such software."]
|
|
pub unsafe fn steal() -> Self {
|
|
Self {
|
|
_marker: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
impl Deref for Tim21 {
|
|
type Target = tim0::RegisterBlock;
|
|
#[inline(always)]
|
|
fn deref(&self) -> &Self::Target {
|
|
unsafe { &*Self::PTR }
|
|
}
|
|
}
|
|
impl core::fmt::Debug for Tim21 {
|
|
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
|
|
f.debug_struct("Tim21").finish()
|
|
}
|
|
}
|
|
#[doc = "Timer/Counter Peripheral"]
|
|
pub use self::tim0 as tim21;
|
|
#[doc = "Timer/Counter Peripheral"]
|
|
pub struct Tim22 {
|
|
_marker: PhantomData<*const ()>,
|
|
}
|
|
unsafe impl Send for Tim22 {}
|
|
impl Tim22 {
|
|
#[doc = r"Pointer to the register block"]
|
|
pub const PTR: *const tim0::RegisterBlock = 0x4002_9800 as *const _;
|
|
#[doc = r"Return the pointer to the register block"]
|
|
#[inline(always)]
|
|
pub const fn ptr() -> *const tim0::RegisterBlock {
|
|
Self::PTR
|
|
}
|
|
#[doc = r" Steal an instance of this peripheral"]
|
|
#[doc = r""]
|
|
#[doc = r" # Safety"]
|
|
#[doc = r""]
|
|
#[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
|
|
#[doc = r" that may race with any existing instances, for example by only"]
|
|
#[doc = r" accessing read-only or write-only registers, or by consuming the"]
|
|
#[doc = r" original peripheral and using critical sections to coordinate"]
|
|
#[doc = r" access between multiple new instances."]
|
|
#[doc = r""]
|
|
#[doc = r" Additionally, other software such as HALs may rely on only one"]
|
|
#[doc = r" peripheral instance existing to ensure memory safety; ensure"]
|
|
#[doc = r" no stolen instances are passed to such software."]
|
|
pub unsafe fn steal() -> Self {
|
|
Self {
|
|
_marker: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
impl Deref for Tim22 {
|
|
type Target = tim0::RegisterBlock;
|
|
#[inline(always)]
|
|
fn deref(&self) -> &Self::Target {
|
|
unsafe { &*Self::PTR }
|
|
}
|
|
}
|
|
impl core::fmt::Debug for Tim22 {
|
|
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
|
|
f.debug_struct("Tim22").finish()
|
|
}
|
|
}
|
|
#[doc = "Timer/Counter Peripheral"]
|
|
pub use self::tim0 as tim22;
|
|
#[doc = "Timer/Counter Peripheral"]
|
|
pub struct Tim23 {
|
|
_marker: PhantomData<*const ()>,
|
|
}
|
|
unsafe impl Send for Tim23 {}
|
|
impl Tim23 {
|
|
#[doc = r"Pointer to the register block"]
|
|
pub const PTR: *const tim0::RegisterBlock = 0x4002_9c00 as *const _;
|
|
#[doc = r"Return the pointer to the register block"]
|
|
#[inline(always)]
|
|
pub const fn ptr() -> *const tim0::RegisterBlock {
|
|
Self::PTR
|
|
}
|
|
#[doc = r" Steal an instance of this peripheral"]
|
|
#[doc = r""]
|
|
#[doc = r" # Safety"]
|
|
#[doc = r""]
|
|
#[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
|
|
#[doc = r" that may race with any existing instances, for example by only"]
|
|
#[doc = r" accessing read-only or write-only registers, or by consuming the"]
|
|
#[doc = r" original peripheral and using critical sections to coordinate"]
|
|
#[doc = r" access between multiple new instances."]
|
|
#[doc = r""]
|
|
#[doc = r" Additionally, other software such as HALs may rely on only one"]
|
|
#[doc = r" peripheral instance existing to ensure memory safety; ensure"]
|
|
#[doc = r" no stolen instances are passed to such software."]
|
|
pub unsafe fn steal() -> Self {
|
|
Self {
|
|
_marker: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
impl Deref for Tim23 {
|
|
type Target = tim0::RegisterBlock;
|
|
#[inline(always)]
|
|
fn deref(&self) -> &Self::Target {
|
|
unsafe { &*Self::PTR }
|
|
}
|
|
}
|
|
impl core::fmt::Debug for Tim23 {
|
|
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
|
|
f.debug_struct("Tim23").finish()
|
|
}
|
|
}
|
|
#[doc = "Timer/Counter Peripheral"]
|
|
pub use self::tim0 as tim23;
|
|
#[doc = "UART Peripheral"]
|
|
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 = 0x4002_4000 as *const _;
|
|
#[doc = r"Return the pointer to the register block"]
|
|
#[inline(always)]
|
|
pub const fn ptr() -> *const uart0::RegisterBlock {
|
|
Self::PTR
|
|
}
|
|
#[doc = r" Steal an instance of this peripheral"]
|
|
#[doc = r""]
|
|
#[doc = r" # Safety"]
|
|
#[doc = r""]
|
|
#[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
|
|
#[doc = r" that may race with any existing instances, for example by only"]
|
|
#[doc = r" accessing read-only or write-only registers, or by consuming the"]
|
|
#[doc = r" original peripheral and using critical sections to coordinate"]
|
|
#[doc = r" access between multiple new instances."]
|
|
#[doc = r""]
|
|
#[doc = r" Additionally, other software such as HALs may rely on only one"]
|
|
#[doc = r" peripheral instance existing to ensure memory safety; ensure"]
|
|
#[doc = r" no stolen instances are passed to such software."]
|
|
pub unsafe fn steal() -> Self {
|
|
Self {
|
|
_marker: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
impl Deref for 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 = "UART Peripheral"]
|
|
pub mod uart0;
|
|
#[doc = "UART Peripheral"]
|
|
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 = 0x4002_5000 as *const _;
|
|
#[doc = r"Return the pointer to the register block"]
|
|
#[inline(always)]
|
|
pub const fn ptr() -> *const uart0::RegisterBlock {
|
|
Self::PTR
|
|
}
|
|
#[doc = r" Steal an instance of this peripheral"]
|
|
#[doc = r""]
|
|
#[doc = r" # Safety"]
|
|
#[doc = r""]
|
|
#[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
|
|
#[doc = r" that may race with any existing instances, for example by only"]
|
|
#[doc = r" accessing read-only or write-only registers, or by consuming the"]
|
|
#[doc = r" original peripheral and using critical sections to coordinate"]
|
|
#[doc = r" access between multiple new instances."]
|
|
#[doc = r""]
|
|
#[doc = r" Additionally, other software such as HALs may rely on only one"]
|
|
#[doc = r" peripheral instance existing to ensure memory safety; ensure"]
|
|
#[doc = r" no stolen instances are passed to such software."]
|
|
pub unsafe fn steal() -> Self {
|
|
Self {
|
|
_marker: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
impl Deref for 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 = "UART Peripheral"]
|
|
pub use self::uart0 as uart1;
|
|
#[doc = "UART Peripheral"]
|
|
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 = 0x4001_7000 as *const _;
|
|
#[doc = r"Return the pointer to the register block"]
|
|
#[inline(always)]
|
|
pub const fn ptr() -> *const uart0::RegisterBlock {
|
|
Self::PTR
|
|
}
|
|
#[doc = r" Steal an instance of this peripheral"]
|
|
#[doc = r""]
|
|
#[doc = r" # Safety"]
|
|
#[doc = r""]
|
|
#[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
|
|
#[doc = r" that may race with any existing instances, for example by only"]
|
|
#[doc = r" accessing read-only or write-only registers, or by consuming the"]
|
|
#[doc = r" original peripheral and using critical sections to coordinate"]
|
|
#[doc = r" access between multiple new instances."]
|
|
#[doc = r""]
|
|
#[doc = r" Additionally, other software such as HALs may rely on only one"]
|
|
#[doc = r" peripheral instance existing to ensure memory safety; ensure"]
|
|
#[doc = r" no stolen instances are passed to such software."]
|
|
pub unsafe fn steal() -> Self {
|
|
Self {
|
|
_marker: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
impl Deref for 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 = "UART Peripheral"]
|
|
pub use self::uart0 as uart2;
|
|
#[doc = "SPI Peripheral"]
|
|
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 = 0x4001_5000 as *const _;
|
|
#[doc = r"Return the pointer to the register block"]
|
|
#[inline(always)]
|
|
pub const fn ptr() -> *const spi0::RegisterBlock {
|
|
Self::PTR
|
|
}
|
|
#[doc = r" Steal an instance of this peripheral"]
|
|
#[doc = r""]
|
|
#[doc = r" # Safety"]
|
|
#[doc = r""]
|
|
#[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
|
|
#[doc = r" that may race with any existing instances, for example by only"]
|
|
#[doc = r" accessing read-only or write-only registers, or by consuming the"]
|
|
#[doc = r" original peripheral and using critical sections to coordinate"]
|
|
#[doc = r" access between multiple new instances."]
|
|
#[doc = r""]
|
|
#[doc = r" Additionally, other software such as HALs may rely on only one"]
|
|
#[doc = r" peripheral instance existing to ensure memory safety; ensure"]
|
|
#[doc = r" no stolen instances are passed to such software."]
|
|
pub unsafe fn steal() -> Self {
|
|
Self {
|
|
_marker: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
impl Deref for 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 = "SPI Peripheral"]
|
|
pub mod spi0;
|
|
#[doc = "SPI Peripheral"]
|
|
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 = 0x4001_5400 as *const _;
|
|
#[doc = r"Return the pointer to the register block"]
|
|
#[inline(always)]
|
|
pub const fn ptr() -> *const spi0::RegisterBlock {
|
|
Self::PTR
|
|
}
|
|
#[doc = r" Steal an instance of this peripheral"]
|
|
#[doc = r""]
|
|
#[doc = r" # Safety"]
|
|
#[doc = r""]
|
|
#[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
|
|
#[doc = r" that may race with any existing instances, for example by only"]
|
|
#[doc = r" accessing read-only or write-only registers, or by consuming the"]
|
|
#[doc = r" original peripheral and using critical sections to coordinate"]
|
|
#[doc = r" access between multiple new instances."]
|
|
#[doc = r""]
|
|
#[doc = r" Additionally, other software such as HALs may rely on only one"]
|
|
#[doc = r" peripheral instance existing to ensure memory safety; ensure"]
|
|
#[doc = r" no stolen instances are passed to such software."]
|
|
pub unsafe fn steal() -> Self {
|
|
Self {
|
|
_marker: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
impl Deref for 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 = "SPI Peripheral"]
|
|
pub use self::spi0 as spi1;
|
|
#[doc = "SPI Peripheral"]
|
|
pub struct Spi2 {
|
|
_marker: PhantomData<*const ()>,
|
|
}
|
|
unsafe impl Send for Spi2 {}
|
|
impl Spi2 {
|
|
#[doc = r"Pointer to the register block"]
|
|
pub const PTR: *const spi0::RegisterBlock = 0x4001_5800 as *const _;
|
|
#[doc = r"Return the pointer to the register block"]
|
|
#[inline(always)]
|
|
pub const fn ptr() -> *const spi0::RegisterBlock {
|
|
Self::PTR
|
|
}
|
|
#[doc = r" Steal an instance of this peripheral"]
|
|
#[doc = r""]
|
|
#[doc = r" # Safety"]
|
|
#[doc = r""]
|
|
#[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
|
|
#[doc = r" that may race with any existing instances, for example by only"]
|
|
#[doc = r" accessing read-only or write-only registers, or by consuming the"]
|
|
#[doc = r" original peripheral and using critical sections to coordinate"]
|
|
#[doc = r" access between multiple new instances."]
|
|
#[doc = r""]
|
|
#[doc = r" Additionally, other software such as HALs may rely on only one"]
|
|
#[doc = r" peripheral instance existing to ensure memory safety; ensure"]
|
|
#[doc = r" no stolen instances are passed to such software."]
|
|
pub unsafe fn steal() -> Self {
|
|
Self {
|
|
_marker: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
impl Deref for Spi2 {
|
|
type Target = spi0::RegisterBlock;
|
|
#[inline(always)]
|
|
fn deref(&self) -> &Self::Target {
|
|
unsafe { &*Self::PTR }
|
|
}
|
|
}
|
|
impl core::fmt::Debug for Spi2 {
|
|
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
|
|
f.debug_struct("Spi2").finish()
|
|
}
|
|
}
|
|
#[doc = "SPI Peripheral"]
|
|
pub use self::spi0 as spi2;
|
|
#[doc = "SPI Peripheral"]
|
|
pub struct Spi3 {
|
|
_marker: PhantomData<*const ()>,
|
|
}
|
|
unsafe impl Send for Spi3 {}
|
|
impl Spi3 {
|
|
#[doc = r"Pointer to the register block"]
|
|
pub const PTR: *const spi0::RegisterBlock = 0x4001_5c00 as *const _;
|
|
#[doc = r"Return the pointer to the register block"]
|
|
#[inline(always)]
|
|
pub const fn ptr() -> *const spi0::RegisterBlock {
|
|
Self::PTR
|
|
}
|
|
#[doc = r" Steal an instance of this peripheral"]
|
|
#[doc = r""]
|
|
#[doc = r" # Safety"]
|
|
#[doc = r""]
|
|
#[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
|
|
#[doc = r" that may race with any existing instances, for example by only"]
|
|
#[doc = r" accessing read-only or write-only registers, or by consuming the"]
|
|
#[doc = r" original peripheral and using critical sections to coordinate"]
|
|
#[doc = r" access between multiple new instances."]
|
|
#[doc = r""]
|
|
#[doc = r" Additionally, other software such as HALs may rely on only one"]
|
|
#[doc = r" peripheral instance existing to ensure memory safety; ensure"]
|
|
#[doc = r" no stolen instances are passed to such software."]
|
|
pub unsafe fn steal() -> Self {
|
|
Self {
|
|
_marker: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
impl Deref for Spi3 {
|
|
type Target = spi0::RegisterBlock;
|
|
#[inline(always)]
|
|
fn deref(&self) -> &Self::Target {
|
|
unsafe { &*Self::PTR }
|
|
}
|
|
}
|
|
impl core::fmt::Debug for Spi3 {
|
|
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
|
|
f.debug_struct("Spi3").finish()
|
|
}
|
|
}
|
|
#[doc = "SPI Peripheral"]
|
|
pub use self::spi0 as spi3;
|
|
#[doc = "I2C Peripheral"]
|
|
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 = 0x4001_6000 as *const _;
|
|
#[doc = r"Return the pointer to the register block"]
|
|
#[inline(always)]
|
|
pub const fn ptr() -> *const i2c0::RegisterBlock {
|
|
Self::PTR
|
|
}
|
|
#[doc = r" Steal an instance of this peripheral"]
|
|
#[doc = r""]
|
|
#[doc = r" # Safety"]
|
|
#[doc = r""]
|
|
#[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
|
|
#[doc = r" that may race with any existing instances, for example by only"]
|
|
#[doc = r" accessing read-only or write-only registers, or by consuming the"]
|
|
#[doc = r" original peripheral and using critical sections to coordinate"]
|
|
#[doc = r" access between multiple new instances."]
|
|
#[doc = r""]
|
|
#[doc = r" Additionally, other software such as HALs may rely on only one"]
|
|
#[doc = r" peripheral instance existing to ensure memory safety; ensure"]
|
|
#[doc = r" no stolen instances are passed to such software."]
|
|
pub unsafe fn steal() -> Self {
|
|
Self {
|
|
_marker: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
impl Deref for 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 = "I2C Peripheral"]
|
|
pub mod i2c0;
|
|
#[doc = "I2C Peripheral"]
|
|
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 = 0x4001_6400 as *const _;
|
|
#[doc = r"Return the pointer to the register block"]
|
|
#[inline(always)]
|
|
pub const fn ptr() -> *const i2c0::RegisterBlock {
|
|
Self::PTR
|
|
}
|
|
#[doc = r" Steal an instance of this peripheral"]
|
|
#[doc = r""]
|
|
#[doc = r" # Safety"]
|
|
#[doc = r""]
|
|
#[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
|
|
#[doc = r" that may race with any existing instances, for example by only"]
|
|
#[doc = r" accessing read-only or write-only registers, or by consuming the"]
|
|
#[doc = r" original peripheral and using critical sections to coordinate"]
|
|
#[doc = r" access between multiple new instances."]
|
|
#[doc = r""]
|
|
#[doc = r" Additionally, other software such as HALs may rely on only one"]
|
|
#[doc = r" peripheral instance existing to ensure memory safety; ensure"]
|
|
#[doc = r" no stolen instances are passed to such software."]
|
|
pub unsafe fn steal() -> Self {
|
|
Self {
|
|
_marker: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
impl Deref for 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 = "I2C Peripheral"]
|
|
pub use self::i2c0 as i2c1;
|
|
#[doc = "I2C Peripheral"]
|
|
pub struct I2c2 {
|
|
_marker: PhantomData<*const ()>,
|
|
}
|
|
unsafe impl Send for I2c2 {}
|
|
impl I2c2 {
|
|
#[doc = r"Pointer to the register block"]
|
|
pub const PTR: *const i2c0::RegisterBlock = 0x4001_6800 as *const _;
|
|
#[doc = r"Return the pointer to the register block"]
|
|
#[inline(always)]
|
|
pub const fn ptr() -> *const i2c0::RegisterBlock {
|
|
Self::PTR
|
|
}
|
|
#[doc = r" Steal an instance of this peripheral"]
|
|
#[doc = r""]
|
|
#[doc = r" # Safety"]
|
|
#[doc = r""]
|
|
#[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
|
|
#[doc = r" that may race with any existing instances, for example by only"]
|
|
#[doc = r" accessing read-only or write-only registers, or by consuming the"]
|
|
#[doc = r" original peripheral and using critical sections to coordinate"]
|
|
#[doc = r" access between multiple new instances."]
|
|
#[doc = r""]
|
|
#[doc = r" Additionally, other software such as HALs may rely on only one"]
|
|
#[doc = r" peripheral instance existing to ensure memory safety; ensure"]
|
|
#[doc = r" no stolen instances are passed to such software."]
|
|
pub unsafe fn steal() -> Self {
|
|
Self {
|
|
_marker: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
impl Deref for I2c2 {
|
|
type Target = i2c0::RegisterBlock;
|
|
#[inline(always)]
|
|
fn deref(&self) -> &Self::Target {
|
|
unsafe { &*Self::PTR }
|
|
}
|
|
}
|
|
impl core::fmt::Debug for I2c2 {
|
|
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
|
|
f.debug_struct("I2c2").finish()
|
|
}
|
|
}
|
|
#[doc = "I2C Peripheral"]
|
|
pub use self::i2c0 as i2c2;
|
|
#[doc = "CAN Peripheral"]
|
|
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 = 0x4001_4000 as *const _;
|
|
#[doc = r"Return the pointer to the register block"]
|
|
#[inline(always)]
|
|
pub const fn ptr() -> *const can0::RegisterBlock {
|
|
Self::PTR
|
|
}
|
|
#[doc = r" Steal an instance of this peripheral"]
|
|
#[doc = r""]
|
|
#[doc = r" # Safety"]
|
|
#[doc = r""]
|
|
#[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
|
|
#[doc = r" that may race with any existing instances, for example by only"]
|
|
#[doc = r" accessing read-only or write-only registers, or by consuming the"]
|
|
#[doc = r" original peripheral and using critical sections to coordinate"]
|
|
#[doc = r" access between multiple new instances."]
|
|
#[doc = r""]
|
|
#[doc = r" Additionally, other software such as HALs may rely on only one"]
|
|
#[doc = r" peripheral instance existing to ensure memory safety; ensure"]
|
|
#[doc = r" no stolen instances are passed to such software."]
|
|
pub unsafe fn steal() -> Self {
|
|
Self {
|
|
_marker: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
impl Deref for 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 = "CAN Peripheral"]
|
|
pub mod can0;
|
|
#[doc = "CAN Peripheral"]
|
|
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 = 0x4001_4400 as *const _;
|
|
#[doc = r"Return the pointer to the register block"]
|
|
#[inline(always)]
|
|
pub const fn ptr() -> *const can0::RegisterBlock {
|
|
Self::PTR
|
|
}
|
|
#[doc = r" Steal an instance of this peripheral"]
|
|
#[doc = r""]
|
|
#[doc = r" # Safety"]
|
|
#[doc = r""]
|
|
#[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
|
|
#[doc = r" that may race with any existing instances, for example by only"]
|
|
#[doc = r" accessing read-only or write-only registers, or by consuming the"]
|
|
#[doc = r" original peripheral and using critical sections to coordinate"]
|
|
#[doc = r" access between multiple new instances."]
|
|
#[doc = r""]
|
|
#[doc = r" Additionally, other software such as HALs may rely on only one"]
|
|
#[doc = r" peripheral instance existing to ensure memory safety; ensure"]
|
|
#[doc = r" no stolen instances are passed to such software."]
|
|
pub unsafe fn steal() -> Self {
|
|
Self {
|
|
_marker: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
impl Deref for 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 = "CAN Peripheral"]
|
|
pub use self::can0 as can1;
|
|
#[doc = "Analog to Digital Converter Peripheral"]
|
|
pub struct Adc {
|
|
_marker: PhantomData<*const ()>,
|
|
}
|
|
unsafe impl Send for Adc {}
|
|
impl Adc {
|
|
#[doc = r"Pointer to the register block"]
|
|
pub const PTR: *const adc::RegisterBlock = 0x4002_2000 as *const _;
|
|
#[doc = r"Return the pointer to the register block"]
|
|
#[inline(always)]
|
|
pub const fn ptr() -> *const adc::RegisterBlock {
|
|
Self::PTR
|
|
}
|
|
#[doc = r" Steal an instance of this peripheral"]
|
|
#[doc = r""]
|
|
#[doc = r" # Safety"]
|
|
#[doc = r""]
|
|
#[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
|
|
#[doc = r" that may race with any existing instances, for example by only"]
|
|
#[doc = r" accessing read-only or write-only registers, or by consuming the"]
|
|
#[doc = r" original peripheral and using critical sections to coordinate"]
|
|
#[doc = r" access between multiple new instances."]
|
|
#[doc = r""]
|
|
#[doc = r" Additionally, other software such as HALs may rely on only one"]
|
|
#[doc = r" peripheral instance existing to ensure memory safety; ensure"]
|
|
#[doc = r" no stolen instances are passed to such software."]
|
|
pub unsafe fn steal() -> Self {
|
|
Self {
|
|
_marker: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
impl Deref for Adc {
|
|
type Target = adc::RegisterBlock;
|
|
#[inline(always)]
|
|
fn deref(&self) -> &Self::Target {
|
|
unsafe { &*Self::PTR }
|
|
}
|
|
}
|
|
impl core::fmt::Debug for Adc {
|
|
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
|
|
f.debug_struct("Adc").finish()
|
|
}
|
|
}
|
|
#[doc = "Analog to Digital Converter Peripheral"]
|
|
pub mod adc;
|
|
#[doc = "Digital to Analog Converter Peripheral"]
|
|
pub struct Dac0 {
|
|
_marker: PhantomData<*const ()>,
|
|
}
|
|
unsafe impl Send for Dac0 {}
|
|
impl Dac0 {
|
|
#[doc = r"Pointer to the register block"]
|
|
pub const PTR: *const dac0::RegisterBlock = 0x4002_3000 as *const _;
|
|
#[doc = r"Return the pointer to the register block"]
|
|
#[inline(always)]
|
|
pub const fn ptr() -> *const dac0::RegisterBlock {
|
|
Self::PTR
|
|
}
|
|
#[doc = r" Steal an instance of this peripheral"]
|
|
#[doc = r""]
|
|
#[doc = r" # Safety"]
|
|
#[doc = r""]
|
|
#[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
|
|
#[doc = r" that may race with any existing instances, for example by only"]
|
|
#[doc = r" accessing read-only or write-only registers, or by consuming the"]
|
|
#[doc = r" original peripheral and using critical sections to coordinate"]
|
|
#[doc = r" access between multiple new instances."]
|
|
#[doc = r""]
|
|
#[doc = r" Additionally, other software such as HALs may rely on only one"]
|
|
#[doc = r" peripheral instance existing to ensure memory safety; ensure"]
|
|
#[doc = r" no stolen instances are passed to such software."]
|
|
pub unsafe fn steal() -> Self {
|
|
Self {
|
|
_marker: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
impl Deref for Dac0 {
|
|
type Target = dac0::RegisterBlock;
|
|
#[inline(always)]
|
|
fn deref(&self) -> &Self::Target {
|
|
unsafe { &*Self::PTR }
|
|
}
|
|
}
|
|
impl core::fmt::Debug for Dac0 {
|
|
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
|
|
f.debug_struct("Dac0").finish()
|
|
}
|
|
}
|
|
#[doc = "Digital to Analog Converter Peripheral"]
|
|
pub mod dac0;
|
|
#[doc = "Digital to Analog Converter Peripheral"]
|
|
pub struct Dac1 {
|
|
_marker: PhantomData<*const ()>,
|
|
}
|
|
unsafe impl Send for Dac1 {}
|
|
impl Dac1 {
|
|
#[doc = r"Pointer to the register block"]
|
|
pub const PTR: *const dac0::RegisterBlock = 0x4002_3800 as *const _;
|
|
#[doc = r"Return the pointer to the register block"]
|
|
#[inline(always)]
|
|
pub const fn ptr() -> *const dac0::RegisterBlock {
|
|
Self::PTR
|
|
}
|
|
#[doc = r" Steal an instance of this peripheral"]
|
|
#[doc = r""]
|
|
#[doc = r" # Safety"]
|
|
#[doc = r""]
|
|
#[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
|
|
#[doc = r" that may race with any existing instances, for example by only"]
|
|
#[doc = r" accessing read-only or write-only registers, or by consuming the"]
|
|
#[doc = r" original peripheral and using critical sections to coordinate"]
|
|
#[doc = r" access between multiple new instances."]
|
|
#[doc = r""]
|
|
#[doc = r" Additionally, other software such as HALs may rely on only one"]
|
|
#[doc = r" peripheral instance existing to ensure memory safety; ensure"]
|
|
#[doc = r" no stolen instances are passed to such software."]
|
|
pub unsafe fn steal() -> Self {
|
|
Self {
|
|
_marker: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
impl Deref for Dac1 {
|
|
type Target = dac0::RegisterBlock;
|
|
#[inline(always)]
|
|
fn deref(&self) -> &Self::Target {
|
|
unsafe { &*Self::PTR }
|
|
}
|
|
}
|
|
impl core::fmt::Debug for Dac1 {
|
|
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
|
|
f.debug_struct("Dac1").finish()
|
|
}
|
|
}
|
|
#[doc = "Digital to Analog Converter Peripheral"]
|
|
pub use self::dac0 as dac1;
|
|
#[doc = "SpaceWire Peripheral"]
|
|
pub struct Spw {
|
|
_marker: PhantomData<*const ()>,
|
|
}
|
|
unsafe impl Send for Spw {}
|
|
impl Spw {
|
|
#[doc = r"Pointer to the register block"]
|
|
pub const PTR: *const spw::RegisterBlock = 0x4000_3000 as *const _;
|
|
#[doc = r"Return the pointer to the register block"]
|
|
#[inline(always)]
|
|
pub const fn ptr() -> *const spw::RegisterBlock {
|
|
Self::PTR
|
|
}
|
|
#[doc = r" Steal an instance of this peripheral"]
|
|
#[doc = r""]
|
|
#[doc = r" # Safety"]
|
|
#[doc = r""]
|
|
#[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
|
|
#[doc = r" that may race with any existing instances, for example by only"]
|
|
#[doc = r" accessing read-only or write-only registers, or by consuming the"]
|
|
#[doc = r" original peripheral and using critical sections to coordinate"]
|
|
#[doc = r" access between multiple new instances."]
|
|
#[doc = r""]
|
|
#[doc = r" Additionally, other software such as HALs may rely on only one"]
|
|
#[doc = r" peripheral instance existing to ensure memory safety; ensure"]
|
|
#[doc = r" no stolen instances are passed to such software."]
|
|
pub unsafe fn steal() -> Self {
|
|
Self {
|
|
_marker: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
impl Deref for Spw {
|
|
type Target = spw::RegisterBlock;
|
|
#[inline(always)]
|
|
fn deref(&self) -> &Self::Target {
|
|
unsafe { &*Self::PTR }
|
|
}
|
|
}
|
|
impl core::fmt::Debug for Spw {
|
|
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
|
|
f.debug_struct("Spw").finish()
|
|
}
|
|
}
|
|
#[doc = "SpaceWire Peripheral"]
|
|
pub mod spw;
|
|
#[doc = "Interrupt Router Peripheral"]
|
|
pub struct IrqRouter {
|
|
_marker: PhantomData<*const ()>,
|
|
}
|
|
unsafe impl Send for IrqRouter {}
|
|
impl IrqRouter {
|
|
#[doc = r"Pointer to the register block"]
|
|
pub const PTR: *const irq_router::RegisterBlock = 0x4000_2000 as *const _;
|
|
#[doc = r"Return the pointer to the register block"]
|
|
#[inline(always)]
|
|
pub const fn ptr() -> *const irq_router::RegisterBlock {
|
|
Self::PTR
|
|
}
|
|
#[doc = r" Steal an instance of this peripheral"]
|
|
#[doc = r""]
|
|
#[doc = r" # Safety"]
|
|
#[doc = r""]
|
|
#[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
|
|
#[doc = r" that may race with any existing instances, for example by only"]
|
|
#[doc = r" accessing read-only or write-only registers, or by consuming the"]
|
|
#[doc = r" original peripheral and using critical sections to coordinate"]
|
|
#[doc = r" access between multiple new instances."]
|
|
#[doc = r""]
|
|
#[doc = r" Additionally, other software such as HALs may rely on only one"]
|
|
#[doc = r" peripheral instance existing to ensure memory safety; ensure"]
|
|
#[doc = r" no stolen instances are passed to such software."]
|
|
pub unsafe fn steal() -> Self {
|
|
Self {
|
|
_marker: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
impl Deref for IrqRouter {
|
|
type Target = irq_router::RegisterBlock;
|
|
#[inline(always)]
|
|
fn deref(&self) -> &Self::Target {
|
|
unsafe { &*Self::PTR }
|
|
}
|
|
}
|
|
impl core::fmt::Debug for IrqRouter {
|
|
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
|
|
f.debug_struct("IrqRouter").finish()
|
|
}
|
|
}
|
|
#[doc = "Interrupt Router Peripheral"]
|
|
pub mod irq_router;
|
|
#[doc = "Watchdog Block Peripheral"]
|
|
pub struct WatchDog {
|
|
_marker: PhantomData<*const ()>,
|
|
}
|
|
unsafe impl Send for WatchDog {}
|
|
impl WatchDog {
|
|
#[doc = r"Pointer to the register block"]
|
|
pub const PTR: *const watch_dog::RegisterBlock = 0x4002_1000 as *const _;
|
|
#[doc = r"Return the pointer to the register block"]
|
|
#[inline(always)]
|
|
pub const fn ptr() -> *const watch_dog::RegisterBlock {
|
|
Self::PTR
|
|
}
|
|
#[doc = r" Steal an instance of this peripheral"]
|
|
#[doc = r""]
|
|
#[doc = r" # Safety"]
|
|
#[doc = r""]
|
|
#[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
|
|
#[doc = r" that may race with any existing instances, for example by only"]
|
|
#[doc = r" accessing read-only or write-only registers, or by consuming the"]
|
|
#[doc = r" original peripheral and using critical sections to coordinate"]
|
|
#[doc = r" access between multiple new instances."]
|
|
#[doc = r""]
|
|
#[doc = r" Additionally, other software such as HALs may rely on only one"]
|
|
#[doc = r" peripheral instance existing to ensure memory safety; ensure"]
|
|
#[doc = r" no stolen instances are passed to such software."]
|
|
pub unsafe fn steal() -> Self {
|
|
Self {
|
|
_marker: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
impl Deref for WatchDog {
|
|
type Target = watch_dog::RegisterBlock;
|
|
#[inline(always)]
|
|
fn deref(&self) -> &Self::Target {
|
|
unsafe { &*Self::PTR }
|
|
}
|
|
}
|
|
impl core::fmt::Debug for WatchDog {
|
|
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
|
|
f.debug_struct("WatchDog").finish()
|
|
}
|
|
}
|
|
#[doc = "Watchdog Block Peripheral"]
|
|
pub mod watch_dog;
|
|
#[doc = "True Random Number Generator"]
|
|
pub struct Trng {
|
|
_marker: PhantomData<*const ()>,
|
|
}
|
|
unsafe impl Send for Trng {}
|
|
impl Trng {
|
|
#[doc = r"Pointer to the register block"]
|
|
pub const PTR: *const trng::RegisterBlock = 0x4002_7000 as *const _;
|
|
#[doc = r"Return the pointer to the register block"]
|
|
#[inline(always)]
|
|
pub const fn ptr() -> *const trng::RegisterBlock {
|
|
Self::PTR
|
|
}
|
|
#[doc = r" Steal an instance of this peripheral"]
|
|
#[doc = r""]
|
|
#[doc = r" # Safety"]
|
|
#[doc = r""]
|
|
#[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
|
|
#[doc = r" that may race with any existing instances, for example by only"]
|
|
#[doc = r" accessing read-only or write-only registers, or by consuming the"]
|
|
#[doc = r" original peripheral and using critical sections to coordinate"]
|
|
#[doc = r" access between multiple new instances."]
|
|
#[doc = r""]
|
|
#[doc = r" Additionally, other software such as HALs may rely on only one"]
|
|
#[doc = r" peripheral instance existing to ensure memory safety; ensure"]
|
|
#[doc = r" no stolen instances are passed to such software."]
|
|
pub unsafe fn steal() -> Self {
|
|
Self {
|
|
_marker: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
impl Deref for Trng {
|
|
type Target = trng::RegisterBlock;
|
|
#[inline(always)]
|
|
fn deref(&self) -> &Self::Target {
|
|
unsafe { &*Self::PTR }
|
|
}
|
|
}
|
|
impl core::fmt::Debug for Trng {
|
|
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
|
|
f.debug_struct("Trng").finish()
|
|
}
|
|
}
|
|
#[doc = "True Random Number Generator"]
|
|
pub mod trng;
|
|
#[doc = "Ethernet Block"]
|
|
pub struct Eth {
|
|
_marker: PhantomData<*const ()>,
|
|
}
|
|
unsafe impl Send for Eth {}
|
|
impl Eth {
|
|
#[doc = r"Pointer to the register block"]
|
|
pub const PTR: *const eth::RegisterBlock = 0x4000_4000 as *const _;
|
|
#[doc = r"Return the pointer to the register block"]
|
|
#[inline(always)]
|
|
pub const fn ptr() -> *const eth::RegisterBlock {
|
|
Self::PTR
|
|
}
|
|
#[doc = r" Steal an instance of this peripheral"]
|
|
#[doc = r""]
|
|
#[doc = r" # Safety"]
|
|
#[doc = r""]
|
|
#[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
|
|
#[doc = r" that may race with any existing instances, for example by only"]
|
|
#[doc = r" accessing read-only or write-only registers, or by consuming the"]
|
|
#[doc = r" original peripheral and using critical sections to coordinate"]
|
|
#[doc = r" access between multiple new instances."]
|
|
#[doc = r""]
|
|
#[doc = r" Additionally, other software such as HALs may rely on only one"]
|
|
#[doc = r" peripheral instance existing to ensure memory safety; ensure"]
|
|
#[doc = r" no stolen instances are passed to such software."]
|
|
pub unsafe fn steal() -> Self {
|
|
Self {
|
|
_marker: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
impl Deref for Eth {
|
|
type Target = eth::RegisterBlock;
|
|
#[inline(always)]
|
|
fn deref(&self) -> &Self::Target {
|
|
unsafe { &*Self::PTR }
|
|
}
|
|
}
|
|
impl core::fmt::Debug for Eth {
|
|
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
|
|
f.debug_struct("Eth").finish()
|
|
}
|
|
}
|
|
#[doc = "Ethernet Block"]
|
|
pub mod eth;
|
|
#[no_mangle]
|
|
static mut DEVICE_PERIPHERALS: bool = false;
|
|
#[doc = r" All the peripherals."]
|
|
#[allow(non_snake_case)]
|
|
pub struct Peripherals {
|
|
#[doc = "CLKGEN"]
|
|
pub clkgen: Clkgen,
|
|
#[doc = "SYSCONFIG"]
|
|
pub sysconfig: Sysconfig,
|
|
#[doc = "DMA"]
|
|
pub dma: Dma,
|
|
#[doc = "IOCONFIG"]
|
|
pub ioconfig: Ioconfig,
|
|
#[doc = "UTILITY"]
|
|
pub utility: Utility,
|
|
#[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 = "PORTF"]
|
|
pub portf: Portf,
|
|
#[doc = "PORTG"]
|
|
pub portg: Portg,
|
|
#[doc = "TIM0"]
|
|
pub tim0: Tim0,
|
|
#[doc = "TIM1"]
|
|
pub tim1: Tim1,
|
|
#[doc = "TIM2"]
|
|
pub tim2: Tim2,
|
|
#[doc = "TIM3"]
|
|
pub tim3: Tim3,
|
|
#[doc = "TIM4"]
|
|
pub tim4: Tim4,
|
|
#[doc = "TIM5"]
|
|
pub tim5: Tim5,
|
|
#[doc = "TIM6"]
|
|
pub tim6: Tim6,
|
|
#[doc = "TIM7"]
|
|
pub tim7: Tim7,
|
|
#[doc = "TIM8"]
|
|
pub tim8: Tim8,
|
|
#[doc = "TIM9"]
|
|
pub tim9: Tim9,
|
|
#[doc = "TIM10"]
|
|
pub tim10: Tim10,
|
|
#[doc = "TIM11"]
|
|
pub tim11: Tim11,
|
|
#[doc = "TIM12"]
|
|
pub tim12: Tim12,
|
|
#[doc = "TIM13"]
|
|
pub tim13: Tim13,
|
|
#[doc = "TIM14"]
|
|
pub tim14: Tim14,
|
|
#[doc = "TIM15"]
|
|
pub tim15: Tim15,
|
|
#[doc = "TIM16"]
|
|
pub tim16: Tim16,
|
|
#[doc = "TIM17"]
|
|
pub tim17: Tim17,
|
|
#[doc = "TIM18"]
|
|
pub tim18: Tim18,
|
|
#[doc = "TIM19"]
|
|
pub tim19: Tim19,
|
|
#[doc = "TIM20"]
|
|
pub tim20: Tim20,
|
|
#[doc = "TIM21"]
|
|
pub tim21: Tim21,
|
|
#[doc = "TIM22"]
|
|
pub tim22: Tim22,
|
|
#[doc = "TIM23"]
|
|
pub tim23: Tim23,
|
|
#[doc = "UART0"]
|
|
pub uart0: Uart0,
|
|
#[doc = "UART1"]
|
|
pub uart1: Uart1,
|
|
#[doc = "UART2"]
|
|
pub uart2: Uart2,
|
|
#[doc = "SPI0"]
|
|
pub spi0: Spi0,
|
|
#[doc = "SPI1"]
|
|
pub spi1: Spi1,
|
|
#[doc = "SPI2"]
|
|
pub spi2: Spi2,
|
|
#[doc = "SPI3"]
|
|
pub spi3: Spi3,
|
|
#[doc = "I2C0"]
|
|
pub i2c0: I2c0,
|
|
#[doc = "I2C1"]
|
|
pub i2c1: I2c1,
|
|
#[doc = "I2C2"]
|
|
pub i2c2: I2c2,
|
|
#[doc = "CAN0"]
|
|
pub can0: Can0,
|
|
#[doc = "CAN1"]
|
|
pub can1: Can1,
|
|
#[doc = "ADC"]
|
|
pub adc: Adc,
|
|
#[doc = "DAC0"]
|
|
pub dac0: Dac0,
|
|
#[doc = "DAC1"]
|
|
pub dac1: Dac1,
|
|
#[doc = "SPW"]
|
|
pub spw: Spw,
|
|
#[doc = "IRQ_ROUTER"]
|
|
pub irq_router: IrqRouter,
|
|
#[doc = "WATCH_DOG"]
|
|
pub watch_dog: WatchDog,
|
|
#[doc = "TRNG"]
|
|
pub trng: Trng,
|
|
#[doc = "ETH"]
|
|
pub eth: Eth,
|
|
}
|
|
impl Peripherals {
|
|
#[doc = r" Returns all the peripherals *once*."]
|
|
#[cfg(feature = "critical-section")]
|
|
#[inline]
|
|
pub fn take() -> Option<Self> {
|
|
critical_section::with(|_| {
|
|
if unsafe { DEVICE_PERIPHERALS } {
|
|
return None;
|
|
}
|
|
Some(unsafe { Peripherals::steal() })
|
|
})
|
|
}
|
|
#[doc = r" Unchecked version of `Peripherals::take`."]
|
|
#[doc = r""]
|
|
#[doc = r" # Safety"]
|
|
#[doc = r""]
|
|
#[doc = r" Each of the returned peripherals must be used at most once."]
|
|
#[inline]
|
|
pub unsafe fn steal() -> Self {
|
|
DEVICE_PERIPHERALS = true;
|
|
Peripherals {
|
|
clkgen: Clkgen {
|
|
_marker: PhantomData,
|
|
},
|
|
sysconfig: Sysconfig {
|
|
_marker: PhantomData,
|
|
},
|
|
dma: Dma {
|
|
_marker: PhantomData,
|
|
},
|
|
ioconfig: Ioconfig {
|
|
_marker: PhantomData,
|
|
},
|
|
utility: Utility {
|
|
_marker: PhantomData,
|
|
},
|
|
porta: Porta {
|
|
_marker: PhantomData,
|
|
},
|
|
portb: Portb {
|
|
_marker: PhantomData,
|
|
},
|
|
portc: Portc {
|
|
_marker: PhantomData,
|
|
},
|
|
portd: Portd {
|
|
_marker: PhantomData,
|
|
},
|
|
porte: Porte {
|
|
_marker: PhantomData,
|
|
},
|
|
portf: Portf {
|
|
_marker: PhantomData,
|
|
},
|
|
portg: Portg {
|
|
_marker: PhantomData,
|
|
},
|
|
tim0: Tim0 {
|
|
_marker: PhantomData,
|
|
},
|
|
tim1: Tim1 {
|
|
_marker: PhantomData,
|
|
},
|
|
tim2: Tim2 {
|
|
_marker: PhantomData,
|
|
},
|
|
tim3: Tim3 {
|
|
_marker: PhantomData,
|
|
},
|
|
tim4: Tim4 {
|
|
_marker: PhantomData,
|
|
},
|
|
tim5: Tim5 {
|
|
_marker: PhantomData,
|
|
},
|
|
tim6: Tim6 {
|
|
_marker: PhantomData,
|
|
},
|
|
tim7: Tim7 {
|
|
_marker: PhantomData,
|
|
},
|
|
tim8: Tim8 {
|
|
_marker: PhantomData,
|
|
},
|
|
tim9: Tim9 {
|
|
_marker: PhantomData,
|
|
},
|
|
tim10: Tim10 {
|
|
_marker: PhantomData,
|
|
},
|
|
tim11: Tim11 {
|
|
_marker: PhantomData,
|
|
},
|
|
tim12: Tim12 {
|
|
_marker: PhantomData,
|
|
},
|
|
tim13: Tim13 {
|
|
_marker: PhantomData,
|
|
},
|
|
tim14: Tim14 {
|
|
_marker: PhantomData,
|
|
},
|
|
tim15: Tim15 {
|
|
_marker: PhantomData,
|
|
},
|
|
tim16: Tim16 {
|
|
_marker: PhantomData,
|
|
},
|
|
tim17: Tim17 {
|
|
_marker: PhantomData,
|
|
},
|
|
tim18: Tim18 {
|
|
_marker: PhantomData,
|
|
},
|
|
tim19: Tim19 {
|
|
_marker: PhantomData,
|
|
},
|
|
tim20: Tim20 {
|
|
_marker: PhantomData,
|
|
},
|
|
tim21: Tim21 {
|
|
_marker: PhantomData,
|
|
},
|
|
tim22: Tim22 {
|
|
_marker: PhantomData,
|
|
},
|
|
tim23: Tim23 {
|
|
_marker: PhantomData,
|
|
},
|
|
uart0: Uart0 {
|
|
_marker: PhantomData,
|
|
},
|
|
uart1: Uart1 {
|
|
_marker: PhantomData,
|
|
},
|
|
uart2: Uart2 {
|
|
_marker: PhantomData,
|
|
},
|
|
spi0: Spi0 {
|
|
_marker: PhantomData,
|
|
},
|
|
spi1: Spi1 {
|
|
_marker: PhantomData,
|
|
},
|
|
spi2: Spi2 {
|
|
_marker: PhantomData,
|
|
},
|
|
spi3: Spi3 {
|
|
_marker: PhantomData,
|
|
},
|
|
i2c0: I2c0 {
|
|
_marker: PhantomData,
|
|
},
|
|
i2c1: I2c1 {
|
|
_marker: PhantomData,
|
|
},
|
|
i2c2: I2c2 {
|
|
_marker: PhantomData,
|
|
},
|
|
can0: Can0 {
|
|
_marker: PhantomData,
|
|
},
|
|
can1: Can1 {
|
|
_marker: PhantomData,
|
|
},
|
|
adc: Adc {
|
|
_marker: PhantomData,
|
|
},
|
|
dac0: Dac0 {
|
|
_marker: PhantomData,
|
|
},
|
|
dac1: Dac1 {
|
|
_marker: PhantomData,
|
|
},
|
|
spw: Spw {
|
|
_marker: PhantomData,
|
|
},
|
|
irq_router: IrqRouter {
|
|
_marker: PhantomData,
|
|
},
|
|
watch_dog: WatchDog {
|
|
_marker: PhantomData,
|
|
},
|
|
trng: Trng {
|
|
_marker: PhantomData,
|
|
},
|
|
eth: Eth {
|
|
_marker: PhantomData,
|
|
},
|
|
}
|
|
}
|
|
}
|