#![doc = "Peripheral access API for ESP32 microcontrollers (generated using svd2rust v0.28.0 ( ))\n\nYou can find an overview of the generated API [here].\n\nAPI features to be included in the [next] svd2rust release can be generated by cloning the svd2rust [repository], checking out the above commit, and running `cargo doc --open`.\n\n[here]: https://docs.rs/svd2rust/0.28.0/svd2rust/#peripheral-api\n[next]: https://github.com/rust-embedded/svd2rust/blob/master/CHANGELOG.md#unreleased\n[repository]: https://github.com/rust-embedded/svd2rust"]
#![deny(dead_code)]
#![deny(improper_ctypes)]
#![deny(missing_docs)]
#![deny(no_mangle_generic_items)]
#![deny(non_shorthand_field_patterns)]
#![deny(overflowing_literals)]
#![deny(path_statements)]
#![deny(patterns_in_fns_without_body)]
#![deny(private_in_public)]
#![deny(unconditional_recursion)]
#![deny(unused_allocation)]
#![deny(unused_comparisons)]
#![deny(unused_parens)]
#![deny(while_true)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![no_std]
use core::marker::PhantomData;
use core::ops::Deref;
#[doc = r"Number available in the NVIC for configuring priority"]
pub const NVIC_PRIO_BITS: u8 = 3;
#[allow(unused_imports)]
use generic::*;
#[doc = r"Common register and bit access and modify traits"]
pub mod generic;
#[cfg(feature = "rt")]
extern "C" {
fn WIFI_MAC();
fn WIFI_NMI();
fn WIFI_BB();
fn BT_MAC();
fn BT_BB();
fn BT_BB_NMI();
fn RWBT();
fn RWBLE();
fn RWBT_NMI();
fn RWBLE_NMI();
fn UHCI0();
fn UHCI1();
fn TG0_T0_LEVEL();
fn TG0_T1_LEVEL();
fn TG0_WDT_LEVEL();
fn TG0_LACT_LEVEL();
fn TG1_T0_LEVEL();
fn TG1_T1_LEVEL();
fn TG1_WDT_LEVEL();
fn TG1_LACT_LEVEL();
fn GPIO();
fn GPIO_NMI();
fn SPI0();
fn SPI1();
fn SPI2();
fn SPI3();
fn I2S0();
fn I2S1();
fn UART0();
fn UART1();
fn UART2();
fn PWM0();
fn PWM1();
fn LEDC();
fn EFUSE();
fn TWAI();
fn RTC_CORE();
fn RMT();
fn PCNT();
fn I2C_EXT0();
fn I2C_EXT1();
fn RSA();
fn SPI1_DMA();
fn SPI2_DMA();
fn SPI3_DMA();
fn TIMER1();
fn TIMER2();
fn TG0_T0_EDGE();
fn TG0_T1_EDGE();
fn TG0_WDT_EDGE();
fn TG0_LACT_EDGE();
fn TG1_T0_EDGE();
fn TG1_T1_EDGE();
fn TG1_WDT_EDGE();
fn TG1_LACT_EDGE();
}
#[doc(hidden)]
pub union Vector {
pub _handler: unsafe extern "C" fn(),
_reserved: u32,
}
#[cfg(feature = "rt")]
#[doc(hidden)]
pub static __INTERRUPTS: [Vector; 66] = [
Vector { _handler: WIFI_MAC },
Vector { _handler: WIFI_NMI },
Vector { _handler: WIFI_BB },
Vector { _handler: BT_MAC },
Vector { _handler: BT_BB },
Vector {
_handler: BT_BB_NMI,
},
Vector { _handler: RWBT },
Vector { _handler: RWBLE },
Vector { _handler: RWBT_NMI },
Vector {
_handler: RWBLE_NMI,
},
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _handler: UHCI0 },
Vector { _handler: UHCI1 },
Vector {
_handler: TG0_T0_LEVEL,
},
Vector {
_handler: TG0_T1_LEVEL,
},
Vector {
_handler: TG0_WDT_LEVEL,
},
Vector {
_handler: TG0_LACT_LEVEL,
},
Vector {
_handler: TG1_T0_LEVEL,
},
Vector {
_handler: TG1_T1_LEVEL,
},
Vector {
_handler: TG1_WDT_LEVEL,
},
Vector {
_handler: TG1_LACT_LEVEL,
},
Vector { _handler: GPIO },
Vector { _handler: GPIO_NMI },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _handler: SPI0 },
Vector { _handler: SPI1 },
Vector { _handler: SPI2 },
Vector { _handler: SPI3 },
Vector { _handler: I2S0 },
Vector { _handler: I2S1 },
Vector { _handler: UART0 },
Vector { _handler: UART1 },
Vector { _handler: UART2 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _handler: PWM0 },
Vector { _handler: PWM1 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _handler: LEDC },
Vector { _handler: EFUSE },
Vector { _handler: TWAI },
Vector { _handler: RTC_CORE },
Vector { _handler: RMT },
Vector { _handler: PCNT },
Vector { _handler: I2C_EXT0 },
Vector { _handler: I2C_EXT1 },
Vector { _handler: RSA },
Vector { _handler: SPI1_DMA },
Vector { _handler: SPI2_DMA },
Vector { _handler: SPI3_DMA },
Vector { _reserved: 0 },
Vector { _handler: TIMER1 },
Vector { _handler: TIMER2 },
Vector {
_handler: TG0_T0_EDGE,
},
Vector {
_handler: TG0_T1_EDGE,
},
Vector {
_handler: TG0_WDT_EDGE,
},
Vector {
_handler: TG0_LACT_EDGE,
},
Vector {
_handler: TG1_T0_EDGE,
},
Vector {
_handler: TG1_T1_EDGE,
},
Vector {
_handler: TG1_WDT_EDGE,
},
Vector {
_handler: TG1_LACT_EDGE,
},
];
#[doc = r"Enumeration of all the interrupts."]
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
#[repr(u16)]
pub enum Interrupt {
#[doc = "0 - WIFI_MAC"]
WIFI_MAC = 0,
#[doc = "1 - WIFI_NMI"]
WIFI_NMI = 1,
#[doc = "2 - WIFI_BB"]
WIFI_BB = 2,
#[doc = "3 - BT_MAC"]
BT_MAC = 3,
#[doc = "4 - BT_BB"]
BT_BB = 4,
#[doc = "5 - BT_BB_NMI"]
BT_BB_NMI = 5,
#[doc = "6 - RWBT"]
RWBT = 6,
#[doc = "7 - RWBLE"]
RWBLE = 7,
#[doc = "8 - RWBT_NMI"]
RWBT_NMI = 8,
#[doc = "9 - RWBLE_NMI"]
RWBLE_NMI = 9,
#[doc = "12 - UHCI0"]
UHCI0 = 12,
#[doc = "13 - UHCI1"]
UHCI1 = 13,
#[doc = "14 - TG0_T0_LEVEL"]
TG0_T0_LEVEL = 14,
#[doc = "15 - TG0_T1_LEVEL"]
TG0_T1_LEVEL = 15,
#[doc = "16 - TG0_WDT_LEVEL"]
TG0_WDT_LEVEL = 16,
#[doc = "17 - TG0_LACT_LEVEL"]
TG0_LACT_LEVEL = 17,
#[doc = "18 - TG1_T0_LEVEL"]
TG1_T0_LEVEL = 18,
#[doc = "19 - TG1_T1_LEVEL"]
TG1_T1_LEVEL = 19,
#[doc = "20 - TG1_WDT_LEVEL"]
TG1_WDT_LEVEL = 20,
#[doc = "21 - TG1_LACT_LEVEL"]
TG1_LACT_LEVEL = 21,
#[doc = "22 - GPIO"]
GPIO = 22,
#[doc = "23 - GPIO_NMI"]
GPIO_NMI = 23,
#[doc = "28 - SPI0"]
SPI0 = 28,
#[doc = "29 - SPI1"]
SPI1 = 29,
#[doc = "30 - SPI2"]
SPI2 = 30,
#[doc = "31 - SPI3"]
SPI3 = 31,
#[doc = "32 - I2S0"]
I2S0 = 32,
#[doc = "33 - I2S1"]
I2S1 = 33,
#[doc = "34 - UART0"]
UART0 = 34,
#[doc = "35 - UART1"]
UART1 = 35,
#[doc = "36 - UART2"]
UART2 = 36,
#[doc = "39 - PWM0"]
PWM0 = 39,
#[doc = "40 - PWM1"]
PWM1 = 40,
#[doc = "43 - LEDC"]
LEDC = 43,
#[doc = "44 - EFUSE"]
EFUSE = 44,
#[doc = "45 - TWAI"]
TWAI = 45,
#[doc = "46 - RTC_CORE"]
RTC_CORE = 46,
#[doc = "47 - RMT"]
RMT = 47,
#[doc = "48 - PCNT"]
PCNT = 48,
#[doc = "49 - I2C_EXT0"]
I2C_EXT0 = 49,
#[doc = "50 - I2C_EXT1"]
I2C_EXT1 = 50,
#[doc = "51 - RSA"]
RSA = 51,
#[doc = "52 - SPI1_DMA"]
SPI1_DMA = 52,
#[doc = "53 - SPI2_DMA"]
SPI2_DMA = 53,
#[doc = "54 - SPI3_DMA"]
SPI3_DMA = 54,
#[doc = "56 - TIMER1"]
TIMER1 = 56,
#[doc = "57 - TIMER2"]
TIMER2 = 57,
#[doc = "58 - TG0_T0_EDGE"]
TG0_T0_EDGE = 58,
#[doc = "59 - TG0_T1_EDGE"]
TG0_T1_EDGE = 59,
#[doc = "60 - TG0_WDT_EDGE"]
TG0_WDT_EDGE = 60,
#[doc = "61 - TG0_LACT_EDGE"]
TG0_LACT_EDGE = 61,
#[doc = "62 - TG1_T0_EDGE"]
TG1_T0_EDGE = 62,
#[doc = "63 - TG1_T1_EDGE"]
TG1_T1_EDGE = 63,
#[doc = "64 - TG1_WDT_EDGE"]
TG1_WDT_EDGE = 64,
#[doc = "65 - TG1_LACT_EDGE"]
TG1_LACT_EDGE = 65,
}
unsafe impl xtensa_lx::interrupt::InterruptNumber for Interrupt {
#[inline(always)]
fn number(self) -> u16 {
self as u16
}
}
#[doc = r" TryFromInterruptError"]
#[derive(Debug, Copy, Clone)]
pub struct TryFromInterruptError(());
impl Interrupt {
#[doc = r" Attempt to convert a given value into an `Interrupt`"]
#[inline]
pub fn try_from(value: u16) -> Result<Self, TryFromInterruptError> {
match value {
0 => Ok(Interrupt::WIFI_MAC),
1 => Ok(Interrupt::WIFI_NMI),
2 => Ok(Interrupt::WIFI_BB),
3 => Ok(Interrupt::BT_MAC),
4 => Ok(Interrupt::BT_BB),
5 => Ok(Interrupt::BT_BB_NMI),
6 => Ok(Interrupt::RWBT),
7 => Ok(Interrupt::RWBLE),
8 => Ok(Interrupt::RWBT_NMI),
9 => Ok(Interrupt::RWBLE_NMI),
12 => Ok(Interrupt::UHCI0),
13 => Ok(Interrupt::UHCI1),
14 => Ok(Interrupt::TG0_T0_LEVEL),
15 => Ok(Interrupt::TG0_T1_LEVEL),
16 => Ok(Interrupt::TG0_WDT_LEVEL),
17 => Ok(Interrupt::TG0_LACT_LEVEL),
18 => Ok(Interrupt::TG1_T0_LEVEL),
19 => Ok(Interrupt::TG1_T1_LEVEL),
20 => Ok(Interrupt::TG1_WDT_LEVEL),
21 => Ok(Interrupt::TG1_LACT_LEVEL),
22 => Ok(Interrupt::GPIO),
23 => Ok(Interrupt::GPIO_NMI),
28 => Ok(Interrupt::SPI0),
29 => Ok(Interrupt::SPI1),
30 => Ok(Interrupt::SPI2),
31 => Ok(Interrupt::SPI3),
32 => Ok(Interrupt::I2S0),
33 => Ok(Interrupt::I2S1),
34 => Ok(Interrupt::UART0),
35 => Ok(Interrupt::UART1),
36 => Ok(Interrupt::UART2),
39 => Ok(Interrupt::PWM0),
40 => Ok(Interrupt::PWM1),
43 => Ok(Interrupt::LEDC),
44 => Ok(Interrupt::EFUSE),
45 => Ok(Interrupt::TWAI),
46 => Ok(Interrupt::RTC_CORE),
47 => Ok(Interrupt::RMT),
48 => Ok(Interrupt::PCNT),
49 => Ok(Interrupt::I2C_EXT0),
50 => Ok(Interrupt::I2C_EXT1),
51 => Ok(Interrupt::RSA),
52 => Ok(Interrupt::SPI1_DMA),
53 => Ok(Interrupt::SPI2_DMA),
54 => Ok(Interrupt::SPI3_DMA),
56 => Ok(Interrupt::TIMER1),
57 => Ok(Interrupt::TIMER2),
58 => Ok(Interrupt::TG0_T0_EDGE),
59 => Ok(Interrupt::TG0_T1_EDGE),
60 => Ok(Interrupt::TG0_WDT_EDGE),
61 => Ok(Interrupt::TG0_LACT_EDGE),
62 => Ok(Interrupt::TG1_T0_EDGE),
63 => Ok(Interrupt::TG1_T1_EDGE),
64 => Ok(Interrupt::TG1_WDT_EDGE),
65 => Ok(Interrupt::TG1_LACT_EDGE),
_ => Err(TryFromInterruptError(())),
}
}
}
#[doc = "AES (Advanced Encryption Standard) Accelerator"]
pub struct AES {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for AES {}
impl AES {
#[doc = r"Pointer to the register block"]
pub const PTR: *const aes::RegisterBlock = 0x3ff0_1000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const aes::RegisterBlock {
Self::PTR
}
}
impl Deref for AES {
type Target = aes::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for AES {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("AES").finish()
}
}
#[doc = "AES (Advanced Encryption Standard) Accelerator"]
pub mod aes;
#[doc = "Advanced Peripheral Bus Controller"]
pub struct APB_CTRL {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for APB_CTRL {}
impl APB_CTRL {
#[doc = r"Pointer to the register block"]
pub const PTR: *const apb_ctrl::RegisterBlock = 0x3ff6_6000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const apb_ctrl::RegisterBlock {
Self::PTR
}
}
impl Deref for APB_CTRL {
type Target = apb_ctrl::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for APB_CTRL {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("APB_CTRL").finish()
}
}
#[doc = "Advanced Peripheral Bus Controller"]
pub mod apb_ctrl;
#[doc = "Peripheral BB"]
pub struct BB {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for BB {}
impl BB {
#[doc = r"Pointer to the register block"]
pub const PTR: *const bb::RegisterBlock = 0x3ff5_d000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const bb::RegisterBlock {
Self::PTR
}
}
impl Deref for BB {
type Target = bb::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for BB {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("BB").finish()
}
}
#[doc = "Peripheral BB"]
pub mod bb;
#[doc = "Peripheral DPORT"]
pub struct DPORT {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for DPORT {}
impl DPORT {
#[doc = r"Pointer to the register block"]
pub const PTR: *const dport::RegisterBlock = 0x3ff0_0000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const dport::RegisterBlock {
Self::PTR
}
}
impl Deref for DPORT {
type Target = dport::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for DPORT {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("DPORT").finish()
}
}
#[doc = "Peripheral DPORT"]
pub mod dport;
#[doc = "eFuse Controller"]
pub struct EFUSE {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for EFUSE {}
impl EFUSE {
#[doc = r"Pointer to the register block"]
pub const PTR: *const efuse::RegisterBlock = 0x3ff5_a000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const efuse::RegisterBlock {
Self::PTR
}
}
impl Deref for EFUSE {
type Target = efuse::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for EFUSE {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("EFUSE").finish()
}
}
#[doc = "eFuse Controller"]
pub mod efuse;
#[doc = "Flash Encryption Peripheral"]
pub struct FLASH_ENCRYPTION {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for FLASH_ENCRYPTION {}
impl FLASH_ENCRYPTION {
#[doc = r"Pointer to the register block"]
pub const PTR: *const flash_encryption::RegisterBlock = 0x3ff4_6000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const flash_encryption::RegisterBlock {
Self::PTR
}
}
impl Deref for FLASH_ENCRYPTION {
type Target = flash_encryption::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for FLASH_ENCRYPTION {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("FLASH_ENCRYPTION").finish()
}
}
#[doc = "Flash Encryption Peripheral"]
pub mod flash_encryption;
#[doc = "Peripheral FRC_TIMER"]
pub struct FRC_TIMER {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for FRC_TIMER {}
impl FRC_TIMER {
#[doc = r"Pointer to the register block"]
pub const PTR: *const frc_timer::RegisterBlock = 0x3ff4_7000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const frc_timer::RegisterBlock {
Self::PTR
}
}
impl Deref for FRC_TIMER {
type Target = frc_timer::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for FRC_TIMER {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("FRC_TIMER").finish()
}
}
#[doc = "Peripheral FRC_TIMER"]
pub mod frc_timer;
#[doc = "General Purpose Input/Output"]
pub struct GPIO {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for GPIO {}
impl GPIO {
#[doc = r"Pointer to the register block"]
pub const PTR: *const gpio::RegisterBlock = 0x3ff4_4000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const gpio::RegisterBlock {
Self::PTR
}
}
impl Deref for GPIO {
type Target = gpio::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for GPIO {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("GPIO").finish()
}
}
#[doc = "General Purpose Input/Output"]
pub mod gpio;
#[doc = "Sigma-Delta Modulation"]
pub struct GPIO_SD {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for GPIO_SD {}
impl GPIO_SD {
#[doc = r"Pointer to the register block"]
pub const PTR: *const gpio_sd::RegisterBlock = 0x3ff4_4f00 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const gpio_sd::RegisterBlock {
Self::PTR
}
}
impl Deref for GPIO_SD {
type Target = gpio_sd::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for GPIO_SD {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("GPIO_SD").finish()
}
}
#[doc = "Sigma-Delta Modulation"]
pub mod gpio_sd;
#[doc = "Peripheral HINF"]
pub struct HINF {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for HINF {}
impl HINF {
#[doc = r"Pointer to the register block"]
pub const PTR: *const hinf::RegisterBlock = 0x3ff4_b000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const hinf::RegisterBlock {
Self::PTR
}
}
impl Deref for HINF {
type Target = hinf::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for HINF {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("HINF").finish()
}
}
#[doc = "Peripheral HINF"]
pub mod hinf;
#[doc = "I2C (Inter-Integrated Circuit) Controller"]
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 = 0x3ff5_3000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const i2c0::RegisterBlock {
Self::PTR
}
}
impl Deref for I2C0 {
type Target = i2c0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for I2C0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("I2C0").finish()
}
}
#[doc = "I2C (Inter-Integrated Circuit) Controller"]
pub mod i2c0;
#[doc = "I2C (Inter-Integrated Circuit) Controller"]
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 = 0x3ff6_7000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const i2c0::RegisterBlock {
Self::PTR
}
}
impl Deref for I2C1 {
type Target = i2c0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for I2C1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("I2C1").finish()
}
}
#[doc = "I2C (Inter-Integrated Circuit) Controller"]
pub use self::i2c0 as i2c1;
#[doc = "I2S (Inter-IC Sound) Controller"]
pub struct I2S0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for I2S0 {}
impl I2S0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const i2s0::RegisterBlock = 0x3ff4_f000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const i2s0::RegisterBlock {
Self::PTR
}
}
impl Deref for I2S0 {
type Target = i2s0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for I2S0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("I2S0").finish()
}
}
#[doc = "I2S (Inter-IC Sound) Controller"]
pub mod i2s0;
#[doc = "I2S (Inter-IC Sound) Controller"]
pub struct I2S1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for I2S1 {}
impl I2S1 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const i2s0::RegisterBlock = 0x3ff6_d000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const i2s0::RegisterBlock {
Self::PTR
}
}
impl Deref for I2S1 {
type Target = i2s0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for I2S1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("I2S1").finish()
}
}
#[doc = "I2S (Inter-IC Sound) Controller"]
pub use self::i2s0 as i2s1;
#[doc = "Input/Output Multiplexer"]
pub struct IO_MUX {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for IO_MUX {}
impl IO_MUX {
#[doc = r"Pointer to the register block"]
pub const PTR: *const io_mux::RegisterBlock = 0x3ff4_9000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const io_mux::RegisterBlock {
Self::PTR
}
}
impl Deref for IO_MUX {
type Target = io_mux::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for IO_MUX {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("IO_MUX").finish()
}
}
#[doc = "Input/Output Multiplexer"]
pub mod io_mux;
#[doc = "LED Control PWM (Pulse Width Modulation)"]
pub struct LEDC {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for LEDC {}
impl LEDC {
#[doc = r"Pointer to the register block"]
pub const PTR: *const ledc::RegisterBlock = 0x3ff5_9000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const ledc::RegisterBlock {
Self::PTR
}
}
impl Deref for LEDC {
type Target = ledc::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for LEDC {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("LEDC").finish()
}
}
#[doc = "LED Control PWM (Pulse Width Modulation)"]
pub mod ledc;
#[doc = "Motor Control Pulse-Width Modulation"]
pub struct PWM0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PWM0 {}
impl PWM0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const pwm0::RegisterBlock = 0x3ff5_e000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const pwm0::RegisterBlock {
Self::PTR
}
}
impl Deref for PWM0 {
type Target = pwm0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for PWM0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("PWM0").finish()
}
}
#[doc = "Motor Control Pulse-Width Modulation"]
pub mod pwm0;
#[doc = "Motor Control Pulse-Width Modulation"]
pub struct PWM1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PWM1 {}
impl PWM1 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const pwm0::RegisterBlock = 0x3ff6_c000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const pwm0::RegisterBlock {
Self::PTR
}
}
impl Deref for PWM1 {
type Target = pwm0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for PWM1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("PWM1").finish()
}
}
#[doc = "Motor Control Pulse-Width Modulation"]
pub use self::pwm0 as pwm1;
#[doc = "Peripheral NRX"]
pub struct NRX {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for NRX {}
impl NRX {
#[doc = r"Pointer to the register block"]
pub const PTR: *const nrx::RegisterBlock = 0x3ff5_cc00 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const nrx::RegisterBlock {
Self::PTR
}
}
impl Deref for NRX {
type Target = nrx::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for NRX {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("NRX").finish()
}
}
#[doc = "Peripheral NRX"]
pub mod nrx;
#[doc = "Pulse Count Controller"]
pub struct PCNT {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PCNT {}
impl PCNT {
#[doc = r"Pointer to the register block"]
pub const PTR: *const pcnt::RegisterBlock = 0x3ff5_7000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const pcnt::RegisterBlock {
Self::PTR
}
}
impl Deref for PCNT {
type Target = pcnt::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for PCNT {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("PCNT").finish()
}
}
#[doc = "Pulse Count Controller"]
pub mod pcnt;
#[doc = "Remote Control Peripheral"]
pub struct RMT {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for RMT {}
impl RMT {
#[doc = r"Pointer to the register block"]
pub const PTR: *const rmt::RegisterBlock = 0x3ff5_6000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const rmt::RegisterBlock {
Self::PTR
}
}
impl Deref for RMT {
type Target = rmt::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for RMT {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("RMT").finish()
}
}
#[doc = "Remote Control Peripheral"]
pub mod rmt;
#[doc = "Hardware random number generator"]
pub struct RNG {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for RNG {}
impl RNG {
#[doc = r"Pointer to the register block"]
pub const PTR: *const rng::RegisterBlock = 0x6003_5000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const rng::RegisterBlock {
Self::PTR
}
}
impl Deref for RNG {
type Target = rng::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for RNG {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("RNG").finish()
}
}
#[doc = "Hardware random number generator"]
pub mod rng;
#[doc = "RSA (Rivest Shamir Adleman) Accelerator"]
pub struct RSA {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for RSA {}
impl RSA {
#[doc = r"Pointer to the register block"]
pub const PTR: *const rsa::RegisterBlock = 0x3ff0_2000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const rsa::RegisterBlock {
Self::PTR
}
}
impl Deref for RSA {
type Target = rsa::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for RSA {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("RSA").finish()
}
}
#[doc = "RSA (Rivest Shamir Adleman) Accelerator"]
pub mod rsa;
#[doc = "Real-Time Clock Control"]
pub struct RTC_CNTL {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for RTC_CNTL {}
impl RTC_CNTL {
#[doc = r"Pointer to the register block"]
pub const PTR: *const rtc_cntl::RegisterBlock = 0x3ff4_8000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const rtc_cntl::RegisterBlock {
Self::PTR
}
}
impl Deref for RTC_CNTL {
type Target = rtc_cntl::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for RTC_CNTL {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("RTC_CNTL").finish()
}
}
#[doc = "Real-Time Clock Control"]
pub mod rtc_cntl;
#[doc = "Peripheral RTCIO"]
pub struct RTCIO {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for RTCIO {}
impl RTCIO {
#[doc = r"Pointer to the register block"]
pub const PTR: *const rtcio::RegisterBlock = 0x3ff4_8400 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const rtcio::RegisterBlock {
Self::PTR
}
}
impl Deref for RTCIO {
type Target = rtcio::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for RTCIO {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("RTCIO").finish()
}
}
#[doc = "Peripheral RTCIO"]
pub mod rtcio;
#[doc = "Peripheral RTC_I2C"]
pub struct RTC_I2C {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for RTC_I2C {}
impl RTC_I2C {
#[doc = r"Pointer to the register block"]
pub const PTR: *const rtc_i2c::RegisterBlock = 0x3ff4_8c00 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const rtc_i2c::RegisterBlock {
Self::PTR
}
}
impl Deref for RTC_I2C {
type Target = rtc_i2c::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for RTC_I2C {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("RTC_I2C").finish()
}
}
#[doc = "Peripheral RTC_I2C"]
pub mod rtc_i2c;
#[doc = "SD/MMC Host Controller"]
pub struct SDMMC {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SDMMC {}
impl SDMMC {
#[doc = r"Pointer to the register block"]
pub const PTR: *const sdmmc::RegisterBlock = 0x3ff6_8000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const sdmmc::RegisterBlock {
Self::PTR
}
}
impl Deref for SDMMC {
type Target = sdmmc::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for SDMMC {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("SDMMC").finish()
}
}
#[doc = "SD/MMC Host Controller"]
pub mod sdmmc;
#[doc = "Peripheral SENS"]
pub struct SENS {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SENS {}
impl SENS {
#[doc = r"Pointer to the register block"]
pub const PTR: *const sens::RegisterBlock = 0x3ff4_8800 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const sens::RegisterBlock {
Self::PTR
}
}
impl Deref for SENS {
type Target = sens::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for SENS {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("SENS").finish()
}
}
#[doc = "Peripheral SENS"]
pub mod sens;
#[doc = "SHA (Secure Hash Algorithm) Accelerator"]
pub struct SHA {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SHA {}
impl SHA {
#[doc = r"Pointer to the register block"]
pub const PTR: *const sha::RegisterBlock = 0x3ff0_3000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const sha::RegisterBlock {
Self::PTR
}
}
impl Deref for SHA {
type Target = sha::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for SHA {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("SHA").finish()
}
}
#[doc = "SHA (Secure Hash Algorithm) Accelerator"]
pub mod sha;
#[doc = "Peripheral SLC"]
pub struct SLC {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SLC {}
impl SLC {
#[doc = r"Pointer to the register block"]
pub const PTR: *const slc::RegisterBlock = 0x3ff5_8000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const slc::RegisterBlock {
Self::PTR
}
}
impl Deref for SLC {
type Target = slc::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for SLC {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("SLC").finish()
}
}
#[doc = "Peripheral SLC"]
pub mod slc;
#[doc = "Peripheral SLCHOST"]
pub struct SLCHOST {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SLCHOST {}
impl SLCHOST {
#[doc = r"Pointer to the register block"]
pub const PTR: *const slchost::RegisterBlock = 0x3ff5_5000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const slchost::RegisterBlock {
Self::PTR
}
}
impl Deref for SLCHOST {
type Target = slchost::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for SLCHOST {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("SLCHOST").finish()
}
}
#[doc = "Peripheral SLCHOST"]
pub mod slchost;
#[doc = "SPI (Serial Peripheral Interface) Controller"]
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 = 0x3ff4_3000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const spi0::RegisterBlock {
Self::PTR
}
}
impl Deref for SPI0 {
type Target = spi0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for SPI0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("SPI0").finish()
}
}
#[doc = "SPI (Serial Peripheral Interface) Controller"]
pub mod spi0;
#[doc = "SPI (Serial Peripheral Interface) Controller"]
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 = 0x3ff4_2000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const spi0::RegisterBlock {
Self::PTR
}
}
impl Deref for SPI1 {
type Target = spi0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for SPI1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("SPI1").finish()
}
}
#[doc = "SPI (Serial Peripheral Interface) Controller"]
pub use self::spi0 as spi1;
#[doc = "SPI (Serial Peripheral Interface) Controller"]
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 = 0x3ff6_4000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const spi0::RegisterBlock {
Self::PTR
}
}
impl Deref for 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 (Serial Peripheral Interface) Controller"]
pub use self::spi0 as spi2;
#[doc = "SPI (Serial Peripheral Interface) Controller"]
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 = 0x3ff6_5000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const spi0::RegisterBlock {
Self::PTR
}
}
impl Deref for 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 (Serial Peripheral Interface) Controller"]
pub use self::spi0 as spi3;
#[doc = "Timer Group"]
pub struct TIMG0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for TIMG0 {}
impl TIMG0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const timg0::RegisterBlock = 0x3ff5_f000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const timg0::RegisterBlock {
Self::PTR
}
}
impl Deref for TIMG0 {
type Target = timg0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for TIMG0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("TIMG0").finish()
}
}
#[doc = "Timer Group"]
pub mod timg0;
#[doc = "Timer Group"]
pub struct TIMG1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for TIMG1 {}
impl TIMG1 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const timg0::RegisterBlock = 0x3ff6_0000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const timg0::RegisterBlock {
Self::PTR
}
}
impl Deref for TIMG1 {
type Target = timg0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for TIMG1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("TIMG1").finish()
}
}
#[doc = "Timer Group"]
pub use self::timg0 as timg1;
#[doc = "Two-Wire Automotive Interface"]
pub struct TWAI {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for TWAI {}
impl TWAI {
#[doc = r"Pointer to the register block"]
pub const PTR: *const twai::RegisterBlock = 0x3ff6_b000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const twai::RegisterBlock {
Self::PTR
}
}
impl Deref for TWAI {
type Target = twai::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for TWAI {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("TWAI").finish()
}
}
#[doc = "Two-Wire Automotive Interface"]
pub mod twai;
#[doc = "UART (Universal Asynchronous Receiver-Transmitter) Controller"]
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 = 0x3ff4_0000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const uart0::RegisterBlock {
Self::PTR
}
}
impl Deref for UART0 {
type Target = uart0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for UART0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("UART0").finish()
}
}
#[doc = "UART (Universal Asynchronous Receiver-Transmitter) Controller"]
pub mod uart0;
#[doc = "UART (Universal Asynchronous Receiver-Transmitter) Controller"]
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 = 0x3ff5_0000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const uart0::RegisterBlock {
Self::PTR
}
}
impl Deref for UART1 {
type Target = uart0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for UART1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("UART1").finish()
}
}
#[doc = "UART (Universal Asynchronous Receiver-Transmitter) Controller"]
pub use self::uart0 as uart1;
#[doc = "UART (Universal Asynchronous Receiver-Transmitter) Controller"]
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 = 0x3ff6_e000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const uart0::RegisterBlock {
Self::PTR
}
}
impl Deref for UART2 {
type Target = uart0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for UART2 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("UART2").finish()
}
}
#[doc = "UART (Universal Asynchronous Receiver-Transmitter) Controller"]
pub use self::uart0 as uart2;
#[doc = "Universal Host Controller Interface"]
pub struct UHCI0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for UHCI0 {}
impl UHCI0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const uhci0::RegisterBlock = 0x3ff5_4000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const uhci0::RegisterBlock {
Self::PTR
}
}
impl Deref for UHCI0 {
type Target = uhci0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for UHCI0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("UHCI0").finish()
}
}
#[doc = "Universal Host Controller Interface"]
pub mod uhci0;
#[doc = "Universal Host Controller Interface"]
pub struct UHCI1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for UHCI1 {}
impl UHCI1 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const uhci0::RegisterBlock = 0x3ff4_c000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const uhci0::RegisterBlock {
Self::PTR
}
}
impl Deref for UHCI1 {
type Target = uhci0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for UHCI1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("UHCI1").finish()
}
}
#[doc = "Universal Host Controller Interface"]
pub use self::uhci0 as uhci1;
#[no_mangle]
static mut DEVICE_PERIPHERALS: bool = false;
#[doc = r" All the peripherals."]
#[allow(non_snake_case)]
pub struct Peripherals {
#[doc = "AES"]
pub AES: AES,
#[doc = "APB_CTRL"]
pub APB_CTRL: APB_CTRL,
#[doc = "BB"]
pub BB: BB,
#[doc = "DPORT"]
pub DPORT: DPORT,
#[doc = "EFUSE"]
pub EFUSE: EFUSE,
#[doc = "FLASH_ENCRYPTION"]
pub FLASH_ENCRYPTION: FLASH_ENCRYPTION,
#[doc = "FRC_TIMER"]
pub FRC_TIMER: FRC_TIMER,
#[doc = "GPIO"]
pub GPIO: GPIO,
#[doc = "GPIO_SD"]
pub GPIO_SD: GPIO_SD,
#[doc = "HINF"]
pub HINF: HINF,
#[doc = "I2C0"]
pub I2C0: I2C0,
#[doc = "I2C1"]
pub I2C1: I2C1,
#[doc = "I2S0"]
pub I2S0: I2S0,
#[doc = "I2S1"]
pub I2S1: I2S1,
#[doc = "IO_MUX"]
pub IO_MUX: IO_MUX,
#[doc = "LEDC"]
pub LEDC: LEDC,
#[doc = "PWM0"]
pub PWM0: PWM0,
#[doc = "PWM1"]
pub PWM1: PWM1,
#[doc = "NRX"]
pub NRX: NRX,
#[doc = "PCNT"]
pub PCNT: PCNT,
#[doc = "RMT"]
pub RMT: RMT,
#[doc = "RNG"]
pub RNG: RNG,
#[doc = "RSA"]
pub RSA: RSA,
#[doc = "RTC_CNTL"]
pub RTC_CNTL: RTC_CNTL,
#[doc = "RTCIO"]
pub RTCIO: RTCIO,
#[doc = "RTC_I2C"]
pub RTC_I2C: RTC_I2C,
#[doc = "SDMMC"]
pub SDMMC: SDMMC,
#[doc = "SENS"]
pub SENS: SENS,
#[doc = "SHA"]
pub SHA: SHA,
#[doc = "SLC"]
pub SLC: SLC,
#[doc = "SLCHOST"]
pub SLCHOST: SLCHOST,
#[doc = "SPI0"]
pub SPI0: SPI0,
#[doc = "SPI1"]
pub SPI1: SPI1,
#[doc = "SPI2"]
pub SPI2: SPI2,
#[doc = "SPI3"]
pub SPI3: SPI3,
#[doc = "TIMG0"]
pub TIMG0: TIMG0,
#[doc = "TIMG1"]
pub TIMG1: TIMG1,
#[doc = "TWAI"]
pub TWAI: TWAI,
#[doc = "UART0"]
pub UART0: UART0,
#[doc = "UART1"]
pub UART1: UART1,
#[doc = "UART2"]
pub UART2: UART2,
#[doc = "UHCI0"]
pub UHCI0: UHCI0,
#[doc = "UHCI1"]
pub UHCI1: UHCI1,
}
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 {
AES: AES {
_marker: PhantomData,
},
APB_CTRL: APB_CTRL {
_marker: PhantomData,
},
BB: BB {
_marker: PhantomData,
},
DPORT: DPORT {
_marker: PhantomData,
},
EFUSE: EFUSE {
_marker: PhantomData,
},
FLASH_ENCRYPTION: FLASH_ENCRYPTION {
_marker: PhantomData,
},
FRC_TIMER: FRC_TIMER {
_marker: PhantomData,
},
GPIO: GPIO {
_marker: PhantomData,
},
GPIO_SD: GPIO_SD {
_marker: PhantomData,
},
HINF: HINF {
_marker: PhantomData,
},
I2C0: I2C0 {
_marker: PhantomData,
},
I2C1: I2C1 {
_marker: PhantomData,
},
I2S0: I2S0 {
_marker: PhantomData,
},
I2S1: I2S1 {
_marker: PhantomData,
},
IO_MUX: IO_MUX {
_marker: PhantomData,
},
LEDC: LEDC {
_marker: PhantomData,
},
PWM0: PWM0 {
_marker: PhantomData,
},
PWM1: PWM1 {
_marker: PhantomData,
},
NRX: NRX {
_marker: PhantomData,
},
PCNT: PCNT {
_marker: PhantomData,
},
RMT: RMT {
_marker: PhantomData,
},
RNG: RNG {
_marker: PhantomData,
},
RSA: RSA {
_marker: PhantomData,
},
RTC_CNTL: RTC_CNTL {
_marker: PhantomData,
},
RTCIO: RTCIO {
_marker: PhantomData,
},
RTC_I2C: RTC_I2C {
_marker: PhantomData,
},
SDMMC: SDMMC {
_marker: PhantomData,
},
SENS: SENS {
_marker: PhantomData,
},
SHA: SHA {
_marker: PhantomData,
},
SLC: SLC {
_marker: PhantomData,
},
SLCHOST: SLCHOST {
_marker: PhantomData,
},
SPI0: SPI0 {
_marker: PhantomData,
},
SPI1: SPI1 {
_marker: PhantomData,
},
SPI2: SPI2 {
_marker: PhantomData,
},
SPI3: SPI3 {
_marker: PhantomData,
},
TIMG0: TIMG0 {
_marker: PhantomData,
},
TIMG1: TIMG1 {
_marker: PhantomData,
},
TWAI: TWAI {
_marker: PhantomData,
},
UART0: UART0 {
_marker: PhantomData,
},
UART1: UART1 {
_marker: PhantomData,
},
UART2: UART2 {
_marker: PhantomData,
},
UHCI0: UHCI0 {
_marker: PhantomData,
},
UHCI1: UHCI1 {
_marker: PhantomData,
},
}
}
}