#![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 { 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 { 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(), } } }