#![doc = "Peripheral access API for ESP32-S3 microcontrollers (generated using svd2rust v0.34.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.34.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"]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![doc(html_logo_url = "https://avatars.githubusercontent.com/u/46717278")]
#![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 = 0;
#[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_PWR();
fn WIFI_BB();
fn BT_MAC();
fn BT_BB();
fn BT_BB_NMI();
fn RWBT();
fn RWBLE();
fn RWBT_NMI();
fn RWBLE_NMI();
fn I2C_MASTER();
fn SLC0();
fn SLC1();
fn UHCI0();
fn UHCI1();
fn GPIO();
fn GPIO_NMI();
fn GPIO_INTR_2();
fn GPIO_NMI_2();
fn SPI1();
fn SPI2();
fn SPI3();
fn LCD_CAM();
fn I2S0();
fn I2S1();
fn UART0();
fn UART1();
fn UART2();
fn SDIO_HOST();
fn MCPWM0();
fn MCPWM1();
fn LEDC();
fn EFUSE();
fn TWAI0();
fn USB();
fn RTC_CORE();
fn RMT();
fn PCNT();
fn I2C_EXT0();
fn I2C_EXT1();
fn SPI2_DMA();
fn SPI3_DMA();
fn WDT();
fn TIMER1();
fn TIMER2();
fn TG0_T0_LEVEL();
fn TG0_T1_LEVEL();
fn TG0_WDT_LEVEL();
fn TG1_T0_LEVEL();
fn TG1_T1_LEVEL();
fn TG1_WDT_LEVEL();
fn CACHE_IA();
fn SYSTIMER_TARGET0();
fn SYSTIMER_TARGET1();
fn SYSTIMER_TARGET2();
fn SPI_MEM_REJECT_CACHE();
fn DCACHE_PRELOAD0();
fn ICACHE_PRELOAD0();
fn DCACHE_SYNC0();
fn ICACHE_SYNC0();
fn APB_ADC();
fn DMA_IN_CH0();
fn DMA_IN_CH1();
fn DMA_IN_CH2();
fn DMA_IN_CH3();
fn DMA_IN_CH4();
fn DMA_OUT_CH0();
fn DMA_OUT_CH1();
fn DMA_OUT_CH2();
fn DMA_OUT_CH3();
fn DMA_OUT_CH4();
fn RSA();
fn SHA();
fn FROM_CPU_INTR0();
fn FROM_CPU_INTR1();
fn FROM_CPU_INTR2();
fn FROM_CPU_INTR3();
fn ASSIST_DEBUG();
fn DMA_APBPERI_PMS();
fn CORE0_IRAM0_PMS();
fn CORE0_DRAM0_PMS();
fn CORE0_PIF_PMS();
fn CORE0_PIF_PMS_SIZE();
fn CORE1_IRAM0_PMS();
fn CORE1_DRAM0_PMS();
fn CORE1_PIF_PMS();
fn CORE1_PIF_PMS_SIZE();
fn BACKUP_PMS_VIOLATE();
fn CACHE_CORE0_ACS();
fn CACHE_CORE1_ACS();
fn USB_DEVICE();
fn PERI_BACKUP();
fn DMA_EXTMEM_REJECT();
}
#[doc(hidden)]
#[repr(C)]
pub union Vector {
pub _handler: unsafe extern "C" fn(),
_reserved: u32,
}
#[cfg(feature = "rt")]
#[link_section = ".rwtext"]
#[doc(hidden)]
pub static __INTERRUPTS: [Vector; 99] = [
Vector { _handler: WIFI_MAC },
Vector { _handler: WIFI_NMI },
Vector { _handler: WIFI_PWR },
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 {
_handler: I2C_MASTER,
},
Vector { _handler: SLC0 },
Vector { _handler: SLC1 },
Vector { _handler: UHCI0 },
Vector { _handler: UHCI1 },
Vector { _handler: GPIO },
Vector { _handler: GPIO_NMI },
Vector {
_handler: GPIO_INTR_2,
},
Vector {
_handler: GPIO_NMI_2,
},
Vector { _handler: SPI1 },
Vector { _handler: SPI2 },
Vector { _handler: SPI3 },
Vector { _reserved: 0 },
Vector { _handler: LCD_CAM },
Vector { _handler: I2S0 },
Vector { _handler: I2S1 },
Vector { _handler: UART0 },
Vector { _handler: UART1 },
Vector { _handler: UART2 },
Vector {
_handler: SDIO_HOST,
},
Vector { _handler: MCPWM0 },
Vector { _handler: MCPWM1 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector { _handler: LEDC },
Vector { _handler: EFUSE },
Vector { _handler: TWAI0 },
Vector { _handler: USB },
Vector { _handler: RTC_CORE },
Vector { _handler: RMT },
Vector { _handler: PCNT },
Vector { _handler: I2C_EXT0 },
Vector { _handler: I2C_EXT1 },
Vector { _handler: SPI2_DMA },
Vector { _handler: SPI3_DMA },
Vector { _reserved: 0 },
Vector { _handler: WDT },
Vector { _handler: TIMER1 },
Vector { _handler: TIMER2 },
Vector {
_handler: TG0_T0_LEVEL,
},
Vector {
_handler: TG0_T1_LEVEL,
},
Vector {
_handler: TG0_WDT_LEVEL,
},
Vector {
_handler: TG1_T0_LEVEL,
},
Vector {
_handler: TG1_T1_LEVEL,
},
Vector {
_handler: TG1_WDT_LEVEL,
},
Vector { _handler: CACHE_IA },
Vector {
_handler: SYSTIMER_TARGET0,
},
Vector {
_handler: SYSTIMER_TARGET1,
},
Vector {
_handler: SYSTIMER_TARGET2,
},
Vector {
_handler: SPI_MEM_REJECT_CACHE,
},
Vector {
_handler: DCACHE_PRELOAD0,
},
Vector {
_handler: ICACHE_PRELOAD0,
},
Vector {
_handler: DCACHE_SYNC0,
},
Vector {
_handler: ICACHE_SYNC0,
},
Vector { _handler: APB_ADC },
Vector {
_handler: DMA_IN_CH0,
},
Vector {
_handler: DMA_IN_CH1,
},
Vector {
_handler: DMA_IN_CH2,
},
Vector {
_handler: DMA_IN_CH3,
},
Vector {
_handler: DMA_IN_CH4,
},
Vector {
_handler: DMA_OUT_CH0,
},
Vector {
_handler: DMA_OUT_CH1,
},
Vector {
_handler: DMA_OUT_CH2,
},
Vector {
_handler: DMA_OUT_CH3,
},
Vector {
_handler: DMA_OUT_CH4,
},
Vector { _handler: RSA },
Vector { _handler: SHA },
Vector { _reserved: 0 },
Vector {
_handler: FROM_CPU_INTR0,
},
Vector {
_handler: FROM_CPU_INTR1,
},
Vector {
_handler: FROM_CPU_INTR2,
},
Vector {
_handler: FROM_CPU_INTR3,
},
Vector {
_handler: ASSIST_DEBUG,
},
Vector {
_handler: DMA_APBPERI_PMS,
},
Vector {
_handler: CORE0_IRAM0_PMS,
},
Vector {
_handler: CORE0_DRAM0_PMS,
},
Vector {
_handler: CORE0_PIF_PMS,
},
Vector {
_handler: CORE0_PIF_PMS_SIZE,
},
Vector {
_handler: CORE1_IRAM0_PMS,
},
Vector {
_handler: CORE1_DRAM0_PMS,
},
Vector {
_handler: CORE1_PIF_PMS,
},
Vector {
_handler: CORE1_PIF_PMS_SIZE,
},
Vector {
_handler: BACKUP_PMS_VIOLATE,
},
Vector {
_handler: CACHE_CORE0_ACS,
},
Vector {
_handler: CACHE_CORE1_ACS,
},
Vector {
_handler: USB_DEVICE,
},
Vector {
_handler: PERI_BACKUP,
},
Vector {
_handler: DMA_EXTMEM_REJECT,
},
];
#[doc = r"Enumeration of all the interrupts."]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[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_PWR"]
WIFI_PWR = 2,
#[doc = "3 - WIFI_BB"]
WIFI_BB = 3,
#[doc = "4 - BT_MAC"]
BT_MAC = 4,
#[doc = "5 - BT_BB"]
BT_BB = 5,
#[doc = "6 - BT_BB_NMI"]
BT_BB_NMI = 6,
#[doc = "7 - RWBT"]
RWBT = 7,
#[doc = "8 - RWBLE"]
RWBLE = 8,
#[doc = "9 - RWBT_NMI"]
RWBT_NMI = 9,
#[doc = "10 - RWBLE_NMI"]
RWBLE_NMI = 10,
#[doc = "11 - I2C_MASTER"]
I2C_MASTER = 11,
#[doc = "12 - SLC0"]
SLC0 = 12,
#[doc = "13 - SLC1"]
SLC1 = 13,
#[doc = "14 - UHCI0"]
UHCI0 = 14,
#[doc = "15 - UHCI1"]
UHCI1 = 15,
#[doc = "16 - GPIO"]
GPIO = 16,
#[doc = "17 - GPIO_NMI"]
GPIO_NMI = 17,
#[doc = "18 - GPIO_INTR_2"]
GPIO_INTR_2 = 18,
#[doc = "19 - GPIO_NMI_2"]
GPIO_NMI_2 = 19,
#[doc = "20 - SPI1"]
SPI1 = 20,
#[doc = "21 - SPI2"]
SPI2 = 21,
#[doc = "22 - SPI3"]
SPI3 = 22,
#[doc = "24 - LCD_CAM"]
LCD_CAM = 24,
#[doc = "25 - I2S0"]
I2S0 = 25,
#[doc = "26 - I2S1"]
I2S1 = 26,
#[doc = "27 - UART0"]
UART0 = 27,
#[doc = "28 - UART1"]
UART1 = 28,
#[doc = "29 - UART2"]
UART2 = 29,
#[doc = "30 - SDIO_HOST"]
SDIO_HOST = 30,
#[doc = "31 - MCPWM0"]
MCPWM0 = 31,
#[doc = "32 - MCPWM1"]
MCPWM1 = 32,
#[doc = "35 - LEDC"]
LEDC = 35,
#[doc = "36 - EFUSE"]
EFUSE = 36,
#[doc = "37 - TWAI0"]
TWAI0 = 37,
#[doc = "38 - USB"]
USB = 38,
#[doc = "39 - RTC_CORE"]
RTC_CORE = 39,
#[doc = "40 - RMT"]
RMT = 40,
#[doc = "41 - PCNT"]
PCNT = 41,
#[doc = "42 - I2C_EXT0"]
I2C_EXT0 = 42,
#[doc = "43 - I2C_EXT1"]
I2C_EXT1 = 43,
#[doc = "44 - SPI2_DMA"]
SPI2_DMA = 44,
#[doc = "45 - SPI3_DMA"]
SPI3_DMA = 45,
#[doc = "47 - WDT"]
WDT = 47,
#[doc = "48 - TIMER1"]
TIMER1 = 48,
#[doc = "49 - TIMER2"]
TIMER2 = 49,
#[doc = "50 - TG0_T0_LEVEL"]
TG0_T0_LEVEL = 50,
#[doc = "51 - TG0_T1_LEVEL"]
TG0_T1_LEVEL = 51,
#[doc = "52 - TG0_WDT_LEVEL"]
TG0_WDT_LEVEL = 52,
#[doc = "53 - TG1_T0_LEVEL"]
TG1_T0_LEVEL = 53,
#[doc = "54 - TG1_T1_LEVEL"]
TG1_T1_LEVEL = 54,
#[doc = "55 - TG1_WDT_LEVEL"]
TG1_WDT_LEVEL = 55,
#[doc = "56 - CACHE_IA"]
CACHE_IA = 56,
#[doc = "57 - SYSTIMER_TARGET0"]
SYSTIMER_TARGET0 = 57,
#[doc = "58 - SYSTIMER_TARGET1"]
SYSTIMER_TARGET1 = 58,
#[doc = "59 - SYSTIMER_TARGET2"]
SYSTIMER_TARGET2 = 59,
#[doc = "60 - SPI_MEM_REJECT_CACHE"]
SPI_MEM_REJECT_CACHE = 60,
#[doc = "61 - DCACHE_PRELOAD0"]
DCACHE_PRELOAD0 = 61,
#[doc = "62 - ICACHE_PRELOAD0"]
ICACHE_PRELOAD0 = 62,
#[doc = "63 - DCACHE_SYNC0"]
DCACHE_SYNC0 = 63,
#[doc = "64 - ICACHE_SYNC0"]
ICACHE_SYNC0 = 64,
#[doc = "65 - APB_ADC"]
APB_ADC = 65,
#[doc = "66 - DMA_IN_CH0"]
DMA_IN_CH0 = 66,
#[doc = "67 - DMA_IN_CH1"]
DMA_IN_CH1 = 67,
#[doc = "68 - DMA_IN_CH2"]
DMA_IN_CH2 = 68,
#[doc = "69 - DMA_IN_CH3"]
DMA_IN_CH3 = 69,
#[doc = "70 - DMA_IN_CH4"]
DMA_IN_CH4 = 70,
#[doc = "71 - DMA_OUT_CH0"]
DMA_OUT_CH0 = 71,
#[doc = "72 - DMA_OUT_CH1"]
DMA_OUT_CH1 = 72,
#[doc = "73 - DMA_OUT_CH2"]
DMA_OUT_CH2 = 73,
#[doc = "74 - DMA_OUT_CH3"]
DMA_OUT_CH3 = 74,
#[doc = "75 - DMA_OUT_CH4"]
DMA_OUT_CH4 = 75,
#[doc = "76 - RSA"]
RSA = 76,
#[doc = "77 - SHA"]
SHA = 77,
#[doc = "79 - FROM_CPU_INTR0"]
FROM_CPU_INTR0 = 79,
#[doc = "80 - FROM_CPU_INTR1"]
FROM_CPU_INTR1 = 80,
#[doc = "81 - FROM_CPU_INTR2"]
FROM_CPU_INTR2 = 81,
#[doc = "82 - FROM_CPU_INTR3"]
FROM_CPU_INTR3 = 82,
#[doc = "83 - ASSIST_DEBUG"]
ASSIST_DEBUG = 83,
#[doc = "84 - DMA_APBPERI_PMS"]
DMA_APBPERI_PMS = 84,
#[doc = "85 - CORE0_IRAM0_PMS"]
CORE0_IRAM0_PMS = 85,
#[doc = "86 - CORE0_DRAM0_PMS"]
CORE0_DRAM0_PMS = 86,
#[doc = "87 - CORE0_PIF_PMS"]
CORE0_PIF_PMS = 87,
#[doc = "88 - CORE0_PIF_PMS_SIZE"]
CORE0_PIF_PMS_SIZE = 88,
#[doc = "89 - CORE1_IRAM0_PMS"]
CORE1_IRAM0_PMS = 89,
#[doc = "90 - CORE1_DRAM0_PMS"]
CORE1_DRAM0_PMS = 90,
#[doc = "91 - CORE1_PIF_PMS"]
CORE1_PIF_PMS = 91,
#[doc = "92 - CORE1_PIF_PMS_SIZE"]
CORE1_PIF_PMS_SIZE = 92,
#[doc = "93 - BACKUP_PMS_VIOLATE"]
BACKUP_PMS_VIOLATE = 93,
#[doc = "94 - CACHE_CORE0_ACS"]
CACHE_CORE0_ACS = 94,
#[doc = "95 - CACHE_CORE1_ACS"]
CACHE_CORE1_ACS = 95,
#[doc = "96 - USB_DEVICE"]
USB_DEVICE = 96,
#[doc = "97 - PERI_BACKUP"]
PERI_BACKUP = 97,
#[doc = "98 - DMA_EXTMEM_REJECT"]
DMA_EXTMEM_REJECT = 98,
}
#[doc = r" TryFromInterruptError"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[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_PWR),
3 => Ok(Interrupt::WIFI_BB),
4 => Ok(Interrupt::BT_MAC),
5 => Ok(Interrupt::BT_BB),
6 => Ok(Interrupt::BT_BB_NMI),
7 => Ok(Interrupt::RWBT),
8 => Ok(Interrupt::RWBLE),
9 => Ok(Interrupt::RWBT_NMI),
10 => Ok(Interrupt::RWBLE_NMI),
11 => Ok(Interrupt::I2C_MASTER),
12 => Ok(Interrupt::SLC0),
13 => Ok(Interrupt::SLC1),
14 => Ok(Interrupt::UHCI0),
15 => Ok(Interrupt::UHCI1),
16 => Ok(Interrupt::GPIO),
17 => Ok(Interrupt::GPIO_NMI),
18 => Ok(Interrupt::GPIO_INTR_2),
19 => Ok(Interrupt::GPIO_NMI_2),
20 => Ok(Interrupt::SPI1),
21 => Ok(Interrupt::SPI2),
22 => Ok(Interrupt::SPI3),
24 => Ok(Interrupt::LCD_CAM),
25 => Ok(Interrupt::I2S0),
26 => Ok(Interrupt::I2S1),
27 => Ok(Interrupt::UART0),
28 => Ok(Interrupt::UART1),
29 => Ok(Interrupt::UART2),
30 => Ok(Interrupt::SDIO_HOST),
31 => Ok(Interrupt::MCPWM0),
32 => Ok(Interrupt::MCPWM1),
35 => Ok(Interrupt::LEDC),
36 => Ok(Interrupt::EFUSE),
37 => Ok(Interrupt::TWAI0),
38 => Ok(Interrupt::USB),
39 => Ok(Interrupt::RTC_CORE),
40 => Ok(Interrupt::RMT),
41 => Ok(Interrupt::PCNT),
42 => Ok(Interrupt::I2C_EXT0),
43 => Ok(Interrupt::I2C_EXT1),
44 => Ok(Interrupt::SPI2_DMA),
45 => Ok(Interrupt::SPI3_DMA),
47 => Ok(Interrupt::WDT),
48 => Ok(Interrupt::TIMER1),
49 => Ok(Interrupt::TIMER2),
50 => Ok(Interrupt::TG0_T0_LEVEL),
51 => Ok(Interrupt::TG0_T1_LEVEL),
52 => Ok(Interrupt::TG0_WDT_LEVEL),
53 => Ok(Interrupt::TG1_T0_LEVEL),
54 => Ok(Interrupt::TG1_T1_LEVEL),
55 => Ok(Interrupt::TG1_WDT_LEVEL),
56 => Ok(Interrupt::CACHE_IA),
57 => Ok(Interrupt::SYSTIMER_TARGET0),
58 => Ok(Interrupt::SYSTIMER_TARGET1),
59 => Ok(Interrupt::SYSTIMER_TARGET2),
60 => Ok(Interrupt::SPI_MEM_REJECT_CACHE),
61 => Ok(Interrupt::DCACHE_PRELOAD0),
62 => Ok(Interrupt::ICACHE_PRELOAD0),
63 => Ok(Interrupt::DCACHE_SYNC0),
64 => Ok(Interrupt::ICACHE_SYNC0),
65 => Ok(Interrupt::APB_ADC),
66 => Ok(Interrupt::DMA_IN_CH0),
67 => Ok(Interrupt::DMA_IN_CH1),
68 => Ok(Interrupt::DMA_IN_CH2),
69 => Ok(Interrupt::DMA_IN_CH3),
70 => Ok(Interrupt::DMA_IN_CH4),
71 => Ok(Interrupt::DMA_OUT_CH0),
72 => Ok(Interrupt::DMA_OUT_CH1),
73 => Ok(Interrupt::DMA_OUT_CH2),
74 => Ok(Interrupt::DMA_OUT_CH3),
75 => Ok(Interrupt::DMA_OUT_CH4),
76 => Ok(Interrupt::RSA),
77 => Ok(Interrupt::SHA),
79 => Ok(Interrupt::FROM_CPU_INTR0),
80 => Ok(Interrupt::FROM_CPU_INTR1),
81 => Ok(Interrupt::FROM_CPU_INTR2),
82 => Ok(Interrupt::FROM_CPU_INTR3),
83 => Ok(Interrupt::ASSIST_DEBUG),
84 => Ok(Interrupt::DMA_APBPERI_PMS),
85 => Ok(Interrupt::CORE0_IRAM0_PMS),
86 => Ok(Interrupt::CORE0_DRAM0_PMS),
87 => Ok(Interrupt::CORE0_PIF_PMS),
88 => Ok(Interrupt::CORE0_PIF_PMS_SIZE),
89 => Ok(Interrupt::CORE1_IRAM0_PMS),
90 => Ok(Interrupt::CORE1_DRAM0_PMS),
91 => Ok(Interrupt::CORE1_PIF_PMS),
92 => Ok(Interrupt::CORE1_PIF_PMS_SIZE),
93 => Ok(Interrupt::BACKUP_PMS_VIOLATE),
94 => Ok(Interrupt::CACHE_CORE0_ACS),
95 => Ok(Interrupt::CACHE_CORE1_ACS),
96 => Ok(Interrupt::USB_DEVICE),
97 => Ok(Interrupt::PERI_BACKUP),
98 => Ok(Interrupt::DMA_EXTMEM_REJECT),
_ => 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 = 0x6003_a000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const aes::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 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 = "APB (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 = 0x6002_6000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const apb_ctrl::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 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 = "APB (Advanced Peripheral Bus) Controller"]
pub mod apb_ctrl;
#[doc = "SAR (Successive Approximation Register) Analog-to-Digital Converter"]
pub struct APB_SARADC {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for APB_SARADC {}
impl APB_SARADC {
#[doc = r"Pointer to the register block"]
pub const PTR: *const apb_saradc::RegisterBlock = 0x6004_0000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const apb_saradc::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 APB_SARADC {
type Target = apb_saradc::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for APB_SARADC {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("APB_SARADC").finish()
}
}
#[doc = "SAR (Successive Approximation Register) Analog-to-Digital Converter"]
pub mod apb_saradc;
#[doc = "BB Peripheral"]
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 = 0x6001_d000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const bb::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 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 = "BB Peripheral"]
pub mod bb;
#[doc = "Debug Assist"]
pub struct ASSIST_DEBUG {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for ASSIST_DEBUG {}
impl ASSIST_DEBUG {
#[doc = r"Pointer to the register block"]
pub const PTR: *const assist_debug::RegisterBlock = 0x600c_e000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const assist_debug::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 ASSIST_DEBUG {
type Target = assist_debug::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for ASSIST_DEBUG {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("ASSIST_DEBUG").finish()
}
}
#[doc = "Debug Assist"]
pub mod assist_debug;
#[doc = "DMA (Direct Memory Access) Controller"]
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 = 0x6003_f000 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 (Direct Memory Access) Controller"]
pub mod dma;
#[doc = "Digital Signature"]
pub struct DS {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for DS {}
impl DS {
#[doc = r"Pointer to the register block"]
pub const PTR: *const ds::RegisterBlock = 0x6003_d000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const ds::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 DS {
type Target = ds::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for DS {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("DS").finish()
}
}
#[doc = "Digital Signature"]
pub mod ds;
#[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 = 0x6000_7000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const efuse::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 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 = "External Memory"]
pub struct EXTMEM {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for EXTMEM {}
impl EXTMEM {
#[doc = r"Pointer to the register block"]
pub const PTR: *const extmem::RegisterBlock = 0x600c_4000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const extmem::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 EXTMEM {
type Target = extmem::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for EXTMEM {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("EXTMEM").finish()
}
}
#[doc = "External Memory"]
pub mod extmem;
#[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 = 0x6000_4000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const gpio::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 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 = 0x6000_4f00 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const gpio_sd::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 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 = "HMAC (Hash-based Message Authentication Code) Accelerator"]
pub struct HMAC {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for HMAC {}
impl HMAC {
#[doc = r"Pointer to the register block"]
pub const PTR: *const hmac::RegisterBlock = 0x6003_e000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const hmac::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 HMAC {
type Target = hmac::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for HMAC {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("HMAC").finish()
}
}
#[doc = "HMAC (Hash-based Message Authentication Code) Accelerator"]
pub mod hmac;
#[doc = "I2C (Inter-Integrated Circuit) Controller 0"]
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 = 0x6001_3000 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 (Inter-Integrated Circuit) Controller 0"]
pub mod i2c0;
#[doc = "I2C (Inter-Integrated Circuit) Controller 1"]
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 = 0x6002_7000 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 (Inter-Integrated Circuit) Controller 1"]
pub use self::i2c0 as i2c1;
#[doc = "I2S (Inter-IC Sound) Controller 0"]
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 = 0x6000_f000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const i2s0::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 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 0"]
pub mod i2s0;
#[doc = "I2S (Inter-IC Sound) Controller 1"]
pub struct I2S1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for I2S1 {}
impl I2S1 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const i2s1::RegisterBlock = 0x6002_d000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const i2s1::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 I2S1 {
type Target = i2s1::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 1"]
pub mod i2s1;
#[doc = "Interrupt Controller (Core 0)"]
pub struct INTERRUPT_CORE0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for INTERRUPT_CORE0 {}
impl INTERRUPT_CORE0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const interrupt_core0::RegisterBlock = 0x600c_2000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const interrupt_core0::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 INTERRUPT_CORE0 {
type Target = interrupt_core0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for INTERRUPT_CORE0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("INTERRUPT_CORE0").finish()
}
}
#[doc = "Interrupt Controller (Core 0)"]
pub mod interrupt_core0;
#[doc = "Interrupt Controller (Core 1)"]
pub struct INTERRUPT_CORE1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for INTERRUPT_CORE1 {}
impl INTERRUPT_CORE1 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const interrupt_core1::RegisterBlock = 0x600c_2000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const interrupt_core1::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 INTERRUPT_CORE1 {
type Target = interrupt_core1::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for INTERRUPT_CORE1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("INTERRUPT_CORE1").finish()
}
}
#[doc = "Interrupt Controller (Core 1)"]
pub mod interrupt_core1;
#[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 = 0x6000_9000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const io_mux::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 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 = "Camera/LCD Controller"]
pub struct LCD_CAM {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for LCD_CAM {}
impl LCD_CAM {
#[doc = r"Pointer to the register block"]
pub const PTR: *const lcd_cam::RegisterBlock = 0x6004_1000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const lcd_cam::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 LCD_CAM {
type Target = lcd_cam::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for LCD_CAM {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("LCD_CAM").finish()
}
}
#[doc = "Camera/LCD Controller"]
pub mod lcd_cam;
#[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 = 0x6001_9000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const ledc::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 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 = "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 = 0x6001_7000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const pcnt::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 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 = "PERI_BACKUP Peripheral"]
pub struct PERI_BACKUP {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PERI_BACKUP {}
impl PERI_BACKUP {
#[doc = r"Pointer to the register block"]
pub const PTR: *const peri_backup::RegisterBlock = 0x6002_a000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const peri_backup::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 PERI_BACKUP {
type Target = peri_backup::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for PERI_BACKUP {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("PERI_BACKUP").finish()
}
}
#[doc = "PERI_BACKUP Peripheral"]
pub mod peri_backup;
#[doc = "Motor Control Pulse-Width Modulation 0"]
pub struct MCPWM0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for MCPWM0 {}
impl MCPWM0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const mcpwm0::RegisterBlock = 0x6001_e000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const mcpwm0::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 MCPWM0 {
type Target = mcpwm0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for MCPWM0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("MCPWM0").finish()
}
}
#[doc = "Motor Control Pulse-Width Modulation 0"]
pub mod mcpwm0;
#[doc = "Motor Control Pulse-Width Modulation 1"]
pub struct MCPWM1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for MCPWM1 {}
impl MCPWM1 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const mcpwm0::RegisterBlock = 0x6002_c000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const mcpwm0::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 MCPWM1 {
type Target = mcpwm0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for MCPWM1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("MCPWM1").finish()
}
}
#[doc = "Motor Control Pulse-Width Modulation 1"]
pub use self::mcpwm0 as mcpwm1;
#[doc = "Remote Control"]
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 = 0x6001_6000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const rmt::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 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"]
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_4f6c as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const rng::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 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 = 0x6003_c000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const rsa::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 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 = 0x6000_8000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const rtc_cntl::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 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 = "Low-power I2C (Inter-Integrated Circuit) Controller"]
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 = 0x6000_8c00 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const rtc_i2c::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 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 = "Low-power I2C (Inter-Integrated Circuit) Controller"]
pub mod rtc_i2c;
#[doc = "Low-power Input/Output"]
pub struct RTC_IO {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for RTC_IO {}
impl RTC_IO {
#[doc = r"Pointer to the register block"]
pub const PTR: *const rtc_io::RegisterBlock = 0x6000_8400 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const rtc_io::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 RTC_IO {
type Target = rtc_io::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for RTC_IO {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("RTC_IO").finish()
}
}
#[doc = "Low-power Input/Output"]
pub mod rtc_io;
#[doc = "SD/MMC Host Controller"]
pub struct SDHOST {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SDHOST {}
impl SDHOST {
#[doc = r"Pointer to the register block"]
pub const PTR: *const sdhost::RegisterBlock = 0x6002_8000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const sdhost::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 SDHOST {
type Target = sdhost::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for SDHOST {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("SDHOST").finish()
}
}
#[doc = "SD/MMC Host Controller"]
pub mod sdhost;
#[doc = "SENS Peripheral"]
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 = 0x6000_8800 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const sens::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 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 = "SENS Peripheral"]
pub mod sens;
#[doc = "SENSITIVE Peripheral"]
pub struct SENSITIVE {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SENSITIVE {}
impl SENSITIVE {
#[doc = r"Pointer to the register block"]
pub const PTR: *const sensitive::RegisterBlock = 0x600c_1000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const sensitive::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 SENSITIVE {
type Target = sensitive::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for SENSITIVE {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("SENSITIVE").finish()
}
}
#[doc = "SENSITIVE Peripheral"]
pub mod sensitive;
#[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 = 0x6003_b000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const sha::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 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 = "SPI (Serial Peripheral Interface) Controller 0"]
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 = 0x6000_3000 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 (Serial Peripheral Interface) Controller 0"]
pub mod spi0;
#[doc = "SPI (Serial Peripheral Interface) Controller 1"]
pub struct SPI1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SPI1 {}
impl SPI1 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const spi1::RegisterBlock = 0x6000_2000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const spi1::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 = spi1::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 1"]
pub mod spi1;
#[doc = "SPI (Serial Peripheral Interface) Controller 2"]
pub struct SPI2 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SPI2 {}
impl SPI2 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const spi2::RegisterBlock = 0x6002_4000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const spi2::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 = spi2::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 2"]
pub mod spi2;
#[doc = "SPI (Serial Peripheral Interface) Controller 3"]
pub struct SPI3 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SPI3 {}
impl SPI3 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const spi2::RegisterBlock = 0x6002_5000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const spi2::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 = spi2::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 3"]
pub use self::spi2 as spi3;
#[doc = "System Configuration Registers"]
pub struct SYSTEM {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SYSTEM {}
impl SYSTEM {
#[doc = r"Pointer to the register block"]
pub const PTR: *const system::RegisterBlock = 0x600c_0000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const system::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 SYSTEM {
type Target = system::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for SYSTEM {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("SYSTEM").finish()
}
}
#[doc = "System Configuration Registers"]
pub mod system;
#[doc = "System Timer"]
pub struct SYSTIMER {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SYSTIMER {}
impl SYSTIMER {
#[doc = r"Pointer to the register block"]
pub const PTR: *const systimer::RegisterBlock = 0x6002_3000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const systimer::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 SYSTIMER {
type Target = systimer::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for SYSTIMER {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("SYSTIMER").finish()
}
}
#[doc = "System Timer"]
pub mod systimer;
#[doc = "Timer Group 0"]
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 = 0x6001_f000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const timg0::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 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 0"]
pub mod timg0;
#[doc = "Timer Group 1"]
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 = 0x6002_0000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const timg0::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 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 1"]
pub use self::timg0 as timg1;
#[doc = "Two-Wire Automotive Interface"]
pub struct TWAI0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for TWAI0 {}
impl TWAI0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const twai0::RegisterBlock = 0x6002_b000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const twai0::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 TWAI0 {
type Target = twai0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for TWAI0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("TWAI0").finish()
}
}
#[doc = "Two-Wire Automotive Interface"]
pub mod twai0;
#[doc = "UART (Universal Asynchronous Receiver-Transmitter) Controller 0"]
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 = 0x6000_0000 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 (Universal Asynchronous Receiver-Transmitter) Controller 0"]
pub mod uart0;
#[doc = "UART (Universal Asynchronous Receiver-Transmitter) Controller 1"]
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 = 0x6001_0000 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 (Universal Asynchronous Receiver-Transmitter) Controller 1"]
pub use self::uart0 as uart1;
#[doc = "UART (Universal Asynchronous Receiver-Transmitter) Controller 2"]
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 = 0x6002_e000 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 (Universal Asynchronous Receiver-Transmitter) Controller 2"]
pub use self::uart0 as uart2;
#[doc = "Universal Host Controller Interface 0"]
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 = 0x6001_4000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const uhci0::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 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 0"]
pub mod uhci0;
#[doc = "Universal Host Controller Interface 1"]
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 = 0x6000_c000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const uhci0::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 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 1"]
pub use self::uhci0 as uhci1;
#[doc = "USB OTG (On-The-Go)"]
pub struct USB0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for USB0 {}
impl USB0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const usb0::RegisterBlock = 0x6008_0000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const usb0::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 USB0 {
type Target = usb0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for USB0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("USB0").finish()
}
}
#[doc = "USB OTG (On-The-Go)"]
pub mod usb0;
#[doc = "Full-speed USB Serial/JTAG Controller"]
pub struct USB_DEVICE {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for USB_DEVICE {}
impl USB_DEVICE {
#[doc = r"Pointer to the register block"]
pub const PTR: *const usb_device::RegisterBlock = 0x6003_8000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const usb_device::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 USB_DEVICE {
type Target = usb_device::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for USB_DEVICE {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("USB_DEVICE").finish()
}
}
#[doc = "Full-speed USB Serial/JTAG Controller"]
pub mod usb_device;
#[doc = "USB_WRAP Peripheral"]
pub struct USB_WRAP {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for USB_WRAP {}
impl USB_WRAP {
#[doc = r"Pointer to the register block"]
pub const PTR: *const usb_wrap::RegisterBlock = 0x6003_9000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const usb_wrap::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 USB_WRAP {
type Target = usb_wrap::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for USB_WRAP {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("USB_WRAP").finish()
}
}
#[doc = "USB_WRAP Peripheral"]
pub mod usb_wrap;
#[doc = "WCL Peripheral"]
pub struct WCL {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for WCL {}
impl WCL {
#[doc = r"Pointer to the register block"]
pub const PTR: *const wcl::RegisterBlock = 0x600d_0000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const wcl::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 WCL {
type Target = wcl::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for WCL {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("WCL").finish()
}
}
#[doc = "WCL Peripheral"]
pub mod wcl;
#[doc = "XTS-AES-128 Flash Encryption"]
pub struct XTS_AES {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for XTS_AES {}
impl XTS_AES {
#[doc = r"Pointer to the register block"]
pub const PTR: *const xts_aes::RegisterBlock = 0x600c_c000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const xts_aes::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 XTS_AES {
type Target = xts_aes::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for XTS_AES {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("XTS_AES").finish()
}
}
#[doc = "XTS-AES-128 Flash Encryption"]
pub mod xts_aes;
#[doc = "NRX Peripheral"]
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 = 0x6001_cc00 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const nrx::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 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 = "NRX Peripheral"]
pub mod nrx;
#[doc = "need des"]
pub struct FE {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for FE {}
impl FE {
#[doc = r"Pointer to the register block"]
pub const PTR: *const fe::RegisterBlock = 0x6000_6000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const fe::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 FE {
type Target = fe::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for FE {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("FE").finish()
}
}
#[doc = "need des"]
pub mod fe;
#[doc = "need des"]
pub struct FE2 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for FE2 {}
impl FE2 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const fe2::RegisterBlock = 0x6000_5000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const fe2::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 FE2 {
type Target = fe2::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for FE2 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("FE2").finish()
}
}
#[doc = "need des"]
pub mod fe2;
#[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 = "APB_SARADC"]
pub APB_SARADC: APB_SARADC,
#[doc = "BB"]
pub BB: BB,
#[doc = "ASSIST_DEBUG"]
pub ASSIST_DEBUG: ASSIST_DEBUG,
#[doc = "DMA"]
pub DMA: DMA,
#[doc = "DS"]
pub DS: DS,
#[doc = "EFUSE"]
pub EFUSE: EFUSE,
#[doc = "EXTMEM"]
pub EXTMEM: EXTMEM,
#[doc = "GPIO"]
pub GPIO: GPIO,
#[doc = "GPIO_SD"]
pub GPIO_SD: GPIO_SD,
#[doc = "HMAC"]
pub HMAC: HMAC,
#[doc = "I2C0"]
pub I2C0: I2C0,
#[doc = "I2C1"]
pub I2C1: I2C1,
#[doc = "I2S0"]
pub I2S0: I2S0,
#[doc = "I2S1"]
pub I2S1: I2S1,
#[doc = "INTERRUPT_CORE0"]
pub INTERRUPT_CORE0: INTERRUPT_CORE0,
#[doc = "INTERRUPT_CORE1"]
pub INTERRUPT_CORE1: INTERRUPT_CORE1,
#[doc = "IO_MUX"]
pub IO_MUX: IO_MUX,
#[doc = "LCD_CAM"]
pub LCD_CAM: LCD_CAM,
#[doc = "LEDC"]
pub LEDC: LEDC,
#[doc = "PCNT"]
pub PCNT: PCNT,
#[doc = "PERI_BACKUP"]
pub PERI_BACKUP: PERI_BACKUP,
#[doc = "MCPWM0"]
pub MCPWM0: MCPWM0,
#[doc = "MCPWM1"]
pub MCPWM1: MCPWM1,
#[doc = "RMT"]
pub RMT: RMT,
#[doc = "RNG"]
pub RNG: RNG,
#[doc = "RSA"]
pub RSA: RSA,
#[doc = "RTC_CNTL"]
pub RTC_CNTL: RTC_CNTL,
#[doc = "RTC_I2C"]
pub RTC_I2C: RTC_I2C,
#[doc = "RTC_IO"]
pub RTC_IO: RTC_IO,
#[doc = "SDHOST"]
pub SDHOST: SDHOST,
#[doc = "SENS"]
pub SENS: SENS,
#[doc = "SENSITIVE"]
pub SENSITIVE: SENSITIVE,
#[doc = "SHA"]
pub SHA: SHA,
#[doc = "SPI0"]
pub SPI0: SPI0,
#[doc = "SPI1"]
pub SPI1: SPI1,
#[doc = "SPI2"]
pub SPI2: SPI2,
#[doc = "SPI3"]
pub SPI3: SPI3,
#[doc = "SYSTEM"]
pub SYSTEM: SYSTEM,
#[doc = "SYSTIMER"]
pub SYSTIMER: SYSTIMER,
#[doc = "TIMG0"]
pub TIMG0: TIMG0,
#[doc = "TIMG1"]
pub TIMG1: TIMG1,
#[doc = "TWAI0"]
pub TWAI0: TWAI0,
#[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,
#[doc = "USB0"]
pub USB0: USB0,
#[doc = "USB_DEVICE"]
pub USB_DEVICE: USB_DEVICE,
#[doc = "USB_WRAP"]
pub USB_WRAP: USB_WRAP,
#[doc = "WCL"]
pub WCL: WCL,
#[doc = "XTS_AES"]
pub XTS_AES: XTS_AES,
#[doc = "NRX"]
pub NRX: NRX,
#[doc = "FE"]
pub FE: FE,
#[doc = "FE2"]
pub FE2: FE2,
}
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::steal(),
APB_CTRL: APB_CTRL::steal(),
APB_SARADC: APB_SARADC::steal(),
BB: BB::steal(),
ASSIST_DEBUG: ASSIST_DEBUG::steal(),
DMA: DMA::steal(),
DS: DS::steal(),
EFUSE: EFUSE::steal(),
EXTMEM: EXTMEM::steal(),
GPIO: GPIO::steal(),
GPIO_SD: GPIO_SD::steal(),
HMAC: HMAC::steal(),
I2C0: I2C0::steal(),
I2C1: I2C1::steal(),
I2S0: I2S0::steal(),
I2S1: I2S1::steal(),
INTERRUPT_CORE0: INTERRUPT_CORE0::steal(),
INTERRUPT_CORE1: INTERRUPT_CORE1::steal(),
IO_MUX: IO_MUX::steal(),
LCD_CAM: LCD_CAM::steal(),
LEDC: LEDC::steal(),
PCNT: PCNT::steal(),
PERI_BACKUP: PERI_BACKUP::steal(),
MCPWM0: MCPWM0::steal(),
MCPWM1: MCPWM1::steal(),
RMT: RMT::steal(),
RNG: RNG::steal(),
RSA: RSA::steal(),
RTC_CNTL: RTC_CNTL::steal(),
RTC_I2C: RTC_I2C::steal(),
RTC_IO: RTC_IO::steal(),
SDHOST: SDHOST::steal(),
SENS: SENS::steal(),
SENSITIVE: SENSITIVE::steal(),
SHA: SHA::steal(),
SPI0: SPI0::steal(),
SPI1: SPI1::steal(),
SPI2: SPI2::steal(),
SPI3: SPI3::steal(),
SYSTEM: SYSTEM::steal(),
SYSTIMER: SYSTIMER::steal(),
TIMG0: TIMG0::steal(),
TIMG1: TIMG1::steal(),
TWAI0: TWAI0::steal(),
UART0: UART0::steal(),
UART1: UART1::steal(),
UART2: UART2::steal(),
UHCI0: UHCI0::steal(),
UHCI1: UHCI1::steal(),
USB0: USB0::steal(),
USB_DEVICE: USB_DEVICE::steal(),
USB_WRAP: USB_WRAP::steal(),
WCL: WCL::steal(),
XTS_AES: XTS_AES::steal(),
NRX: NRX::steal(),
FE: FE::steal(),
FE2: FE2::steal(),
}
}
}