#![doc = "Peripheral access API for ESP32-C5 microcontrollers (generated using svd2rust v0.37.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.37.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]
#![cfg_attr(docsrs, feature(doc_cfg))]
#[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_MAC_NMI();
    fn WIFI_PWR();
    fn WIFI_BB();
    fn BT_MAC();
    fn BT_BB();
    fn BT_BB_NMI();
    fn LP_TIMER();
    fn COEX();
    fn BLE_TIMER();
    fn BLE_SEC();
    fn I2C_MASTER();
    fn ZB_MAC();
    fn PMU();
    fn EFUSE();
    fn LP_RTC_TIMER();
    fn LP_UART();
    fn LP_I2C();
    fn LP_WDT();
    fn LP_APM_M0();
    fn LP_APM_M1();
    fn HUK();
    fn FROM_CPU_INTR0();
    fn FROM_CPU_INTR1();
    fn FROM_CPU_INTR2();
    fn FROM_CPU_INTR3();
    fn ASSIST_DEBUG();
    fn TRACE();
    fn CACHE();
    fn CPU_PERI_TIMEOUT();
    fn GPIO();
    fn GPIO_EXT();
    fn PAU();
    fn HP_APM_M0();
    fn HP_APM_M1();
    fn HP_APM_M2();
    fn HP_APM_M3();
    fn HP_APM_M4();
    fn LP_APM0();
    fn CPU_APM_M0();
    fn CPU_APM_M1();
    fn MSPI();
    fn I2S0();
    fn UHCI0();
    fn UART0();
    fn UART1();
    fn LEDC();
    fn TWAI0();
    fn TWAI0_TIMER();
    fn TWAI1();
    fn TWAI1_TIMER();
    fn USB_DEVICE();
    fn RMT();
    fn I2C_EXT0();
    fn TG0_T0_LEVEL();
    fn TG0_WDT_LEVEL();
    fn TG1_T0_LEVEL();
    fn TG1_WDT_LEVEL();
    fn SYSTIMER_TARGET0();
    fn SYSTIMER_TARGET1();
    fn SYSTIMER_TARGET2();
    fn APB_ADC();
    fn MCPWM0();
    fn PCNT();
    fn PARL_IO_TX();
    fn PARL_IO_RX();
    fn DMA_IN_CH0();
    fn DMA_IN_CH1();
    fn DMA_IN_CH2();
    fn DMA_OUT_CH0();
    fn DMA_OUT_CH1();
    fn DMA_OUT_CH2();
    fn SPI2();
    fn AES();
    fn SHA();
    fn RSA();
    fn ECC();
    fn ECDSA();
}
#[doc(hidden)]
#[repr(C)]
pub union Vector {
    pub _handler: unsafe extern "C" fn(),
    pub _reserved: usize,
}
#[cfg(feature = "rt")]
#[doc(hidden)]
#[link_section = ".rwtext"]
#[no_mangle]
pub static __EXTERNAL_INTERRUPTS: [Vector; 83] = [
    Vector { _handler: WIFI_MAC },
    Vector {
        _handler: WIFI_MAC_NMI,
    },
    Vector { _handler: WIFI_PWR },
    Vector { _handler: WIFI_BB },
    Vector { _handler: BT_MAC },
    Vector { _handler: BT_BB },
    Vector {
        _handler: BT_BB_NMI,
    },
    Vector { _handler: LP_TIMER },
    Vector { _handler: COEX },
    Vector {
        _handler: BLE_TIMER,
    },
    Vector { _handler: BLE_SEC },
    Vector {
        _handler: I2C_MASTER,
    },
    Vector { _handler: ZB_MAC },
    Vector { _handler: PMU },
    Vector { _handler: EFUSE },
    Vector {
        _handler: LP_RTC_TIMER,
    },
    Vector { _handler: LP_UART },
    Vector { _handler: LP_I2C },
    Vector { _handler: LP_WDT },
    Vector { _reserved: 0 },
    Vector {
        _handler: LP_APM_M0,
    },
    Vector {
        _handler: LP_APM_M1,
    },
    Vector { _handler: HUK },
    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: TRACE },
    Vector { _handler: CACHE },
    Vector {
        _handler: CPU_PERI_TIMEOUT,
    },
    Vector { _handler: GPIO },
    Vector { _handler: GPIO_EXT },
    Vector { _handler: PAU },
    Vector { _reserved: 0 },
    Vector { _reserved: 0 },
    Vector {
        _handler: HP_APM_M0,
    },
    Vector {
        _handler: HP_APM_M1,
    },
    Vector {
        _handler: HP_APM_M2,
    },
    Vector {
        _handler: HP_APM_M3,
    },
    Vector {
        _handler: HP_APM_M4,
    },
    Vector { _handler: LP_APM0 },
    Vector {
        _handler: CPU_APM_M0,
    },
    Vector {
        _handler: CPU_APM_M1,
    },
    Vector { _handler: MSPI },
    Vector { _handler: I2S0 },
    Vector { _handler: UHCI0 },
    Vector { _handler: UART0 },
    Vector { _handler: UART1 },
    Vector { _handler: LEDC },
    Vector { _handler: TWAI0 },
    Vector {
        _handler: TWAI0_TIMER,
    },
    Vector { _handler: TWAI1 },
    Vector {
        _handler: TWAI1_TIMER,
    },
    Vector {
        _handler: USB_DEVICE,
    },
    Vector { _handler: RMT },
    Vector { _handler: I2C_EXT0 },
    Vector {
        _handler: TG0_T0_LEVEL,
    },
    Vector {
        _handler: TG0_WDT_LEVEL,
    },
    Vector {
        _handler: TG1_T0_LEVEL,
    },
    Vector {
        _handler: TG1_WDT_LEVEL,
    },
    Vector {
        _handler: SYSTIMER_TARGET0,
    },
    Vector {
        _handler: SYSTIMER_TARGET1,
    },
    Vector {
        _handler: SYSTIMER_TARGET2,
    },
    Vector { _handler: APB_ADC },
    Vector { _handler: MCPWM0 },
    Vector { _handler: PCNT },
    Vector {
        _handler: PARL_IO_TX,
    },
    Vector {
        _handler: PARL_IO_RX,
    },
    Vector { _reserved: 0 },
    Vector { _reserved: 0 },
    Vector {
        _handler: DMA_IN_CH0,
    },
    Vector {
        _handler: DMA_IN_CH1,
    },
    Vector {
        _handler: DMA_IN_CH2,
    },
    Vector {
        _handler: DMA_OUT_CH0,
    },
    Vector {
        _handler: DMA_OUT_CH1,
    },
    Vector {
        _handler: DMA_OUT_CH2,
    },
    Vector { _handler: SPI2 },
    Vector { _handler: AES },
    Vector { _handler: SHA },
    Vector { _handler: RSA },
    Vector { _handler: ECC },
    Vector { _handler: ECDSA },
];
#[doc(hidden)]
pub mod interrupt;
pub use self::interrupt::Interrupt;
#[doc = "Core Local Interrupts"]
pub type CLINT = crate::Periph<clint::RegisterBlock, 0x2000_0000>;
impl core::fmt::Debug for CLINT {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("CLINT").finish()
    }
}
#[doc = "Core Local Interrupts"]
pub mod clint;
#[doc = "Core Local Interrupt Controller"]
pub type CLIC = crate::Periph<clic::RegisterBlock, 0x2080_0000>;
impl core::fmt::Debug for CLIC {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("CLIC").finish()
    }
}
#[doc = "Core Local Interrupt Controller"]
pub mod clic;
#[doc = "AES (Advanced Encryption Standard) Accelerator"]
pub type AES = crate::Periph<aes::RegisterBlock, 0x6008_8000>;
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 = "AHB_DMA Peripheral"]
pub type DMA = crate::Periph<dma::RegisterBlock, 0x6008_0000>;
impl core::fmt::Debug for DMA {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("DMA").finish()
    }
}
#[doc = "AHB_DMA Peripheral"]
pub mod dma;
#[doc = "SAR (Successive Approximation Register) Analog-to-Digital Converter"]
pub type APB_SARADC = crate::Periph<apb_saradc::RegisterBlock, 0x6000_e000>;
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 = "BITSCRAMBLER Peripheral"]
pub type BITSCRAMBLER = crate::Periph<bitscrambler::RegisterBlock, 0x6008_2000>;
impl core::fmt::Debug for BITSCRAMBLER {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("BITSCRAMBLER").finish()
    }
}
#[doc = "BITSCRAMBLER Peripheral"]
pub mod bitscrambler;
#[doc = "ASSIST_DEBUG (BUS_MONITOR) Peripheral"]
pub type ASSIST_DEBUG = crate::Periph<assist_debug::RegisterBlock, 0x600c_2000>;
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 = "ASSIST_DEBUG (BUS_MONITOR) Peripheral"]
pub mod assist_debug;
#[doc = "Digital Signature"]
pub type DS = crate::Periph<ds::RegisterBlock, 0x6008_c000>;
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 = "ECC (ECC Hardware Accelerator)"]
pub type ECC = crate::Periph<ecc::RegisterBlock, 0x6008_b000>;
impl core::fmt::Debug for ECC {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("ECC").finish()
    }
}
#[doc = "ECC (ECC Hardware Accelerator)"]
pub mod ecc;
#[doc = "ECDSA (Elliptic Curve Digital Signature Algorithm) Accelerator"]
pub type ECDSA = crate::Periph<ecdsa::RegisterBlock, 0x6008_e000>;
impl core::fmt::Debug for ECDSA {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("ECDSA").finish()
    }
}
#[doc = "ECDSA (Elliptic Curve Digital Signature Algorithm) Accelerator"]
pub mod ecdsa;
#[doc = "eFuse Controller"]
pub type EFUSE = crate::Periph<efuse::RegisterBlock, 0x600b_4800>;
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 = "General Purpose Input/Output"]
pub type GPIO = crate::Periph<gpio::RegisterBlock, 0x6009_1000>;
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 = "GPIO_EXT Peripheral"]
pub type GPIO_EXT = crate::Periph<gpio_ext::RegisterBlock, 0x6009_1e00>;
impl core::fmt::Debug for GPIO_EXT {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("GPIO_EXT").finish()
    }
}
#[doc = "GPIO_EXT Peripheral"]
pub mod gpio_ext;
#[doc = "HMAC (Hash-based Message Authentication Code) Accelerator"]
pub type HMAC = crate::Periph<hmac::RegisterBlock, 0x6008_d000>;
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 = "HP_APM Peripheral"]
pub type HP_APM = crate::Periph<hp_apm::RegisterBlock, 0x6009_9000>;
impl core::fmt::Debug for HP_APM {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("HP_APM").finish()
    }
}
#[doc = "HP_APM Peripheral"]
pub mod hp_apm;
#[doc = "IEEE802154 Peripheral"]
pub type IEEE802154 = crate::Periph<ieee802154::RegisterBlock, 0x600a_3000>;
impl core::fmt::Debug for IEEE802154 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("IEEE802154").finish()
    }
}
#[doc = "IEEE802154 Peripheral"]
pub mod ieee802154;
#[doc = "MODEM_SYSCON"]
pub type MODEM_SYSCON = crate::Periph<modem_syscon::RegisterBlock, 0x600a_9c00>;
impl core::fmt::Debug for MODEM_SYSCON {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("MODEM_SYSCON").finish()
    }
}
#[doc = "MODEM_SYSCON"]
pub mod modem_syscon;
#[doc = "MODEM_LPCON"]
pub type MODEM_LPCON = crate::Periph<modem_lpcon::RegisterBlock, 0x600a_f000>;
impl core::fmt::Debug for MODEM_LPCON {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("MODEM_LPCON").finish()
    }
}
#[doc = "MODEM_LPCON"]
pub mod modem_lpcon;
#[doc = "I2C_ANA_MST Peripheral"]
pub type I2C_ANA_MST = crate::Periph<i2c_ana_mst::RegisterBlock, 0x600a_f800>;
impl core::fmt::Debug for I2C_ANA_MST {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("I2C_ANA_MST").finish()
    }
}
#[doc = "I2C_ANA_MST Peripheral"]
pub mod i2c_ana_mst;
#[doc = "HP_SYSTEM Peripheral"]
pub type HP_SYS = crate::Periph<hp_sys::RegisterBlock, 0x6009_5000>;
impl core::fmt::Debug for HP_SYS {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("HP_SYS").finish()
    }
}
#[doc = "HP_SYSTEM Peripheral"]
pub mod hp_sys;
#[doc = "HUK Peripheral"]
pub type HUK = crate::Periph<huk::RegisterBlock, 0x600b_3000>;
impl core::fmt::Debug for HUK {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("HUK").finish()
    }
}
#[doc = "HUK Peripheral"]
pub mod huk;
#[doc = "I2C (Inter-Integrated Circuit) Controller 0"]
pub type I2C0 = crate::Periph<i2c0::RegisterBlock, 0x6000_4000>;
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 = "I2S (Inter-IC Sound) Controller 0"]
pub type I2S0 = crate::Periph<i2s0::RegisterBlock, 0x6000_c000>;
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 = "Interrupt Controller (Core 0)"]
pub type INTERRUPT_CORE0 = crate::Periph<interrupt_core0::RegisterBlock, 0x6001_0000>;
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 = "INTPRI Peripheral"]
pub type INTPRI = crate::Periph<intpri::RegisterBlock, 0x600c_5000>;
impl core::fmt::Debug for INTPRI {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("INTPRI").finish()
    }
}
#[doc = "INTPRI Peripheral"]
pub mod intpri;
#[doc = "Cache controller, preload/sync, and performance counters"]
pub type CACHE = crate::Periph<cache::RegisterBlock, 0x600c_8000>;
impl core::fmt::Debug for CACHE {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("CACHE").finish()
    }
}
#[doc = "Cache controller, preload/sync, and performance counters"]
pub mod cache;
#[doc = "Input/Output Multiplexer"]
pub type IO_MUX = crate::Periph<io_mux::RegisterBlock, 0x6009_0000>;
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 = "KEYMNG Peripheral"]
pub type KEYMNG = crate::Periph<keymng::RegisterBlock, 0x6008_7000>;
impl core::fmt::Debug for KEYMNG {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("KEYMNG").finish()
    }
}
#[doc = "KEYMNG Peripheral"]
pub mod keymng;
#[doc = "LED Control PWM (Pulse Width Modulation)"]
pub type LEDC = crate::Periph<ledc::RegisterBlock, 0x6000_7000>;
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 = "LPPERI Peripheral"]
pub type LPPERI = crate::Periph<lpperi::RegisterBlock, 0x600b_2800>;
impl core::fmt::Debug for LPPERI {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("LPPERI").finish()
    }
}
#[doc = "LPPERI Peripheral"]
pub mod lpperi;
#[doc = "LP_ANA Peripheral"]
pub type LP_ANA = crate::Periph<lp_ana::RegisterBlock, 0x600b_2c00>;
impl core::fmt::Debug for LP_ANA {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("LP_ANA").finish()
    }
}
#[doc = "LP_ANA Peripheral"]
pub mod lp_ana;
#[doc = "LP_AON Peripheral"]
pub type LP_AON = crate::Periph<lp_aon::RegisterBlock, 0x600b_1000>;
impl core::fmt::Debug for LP_AON {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("LP_AON").finish()
    }
}
#[doc = "LP_AON Peripheral"]
pub mod lp_aon;
#[doc = "LP_APM0 Peripheral"]
pub type LP_APM0 = crate::Periph<lp_apm0::RegisterBlock, 0x600b_3800>;
impl core::fmt::Debug for LP_APM0 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("LP_APM0").finish()
    }
}
#[doc = "LP_APM0 Peripheral"]
pub mod lp_apm0;
#[doc = "LP_APM Peripheral"]
pub type LP_APM = crate::Periph<lp_apm::RegisterBlock, 0x600b_3800>;
impl core::fmt::Debug for LP_APM {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("LP_APM").finish()
    }
}
#[doc = "LP_APM Peripheral"]
pub mod lp_apm;
#[doc = "LP_CLKRST Peripheral"]
pub type LP_CLKRST = crate::Periph<lp_clkrst::RegisterBlock, 0x600b_0400>;
impl core::fmt::Debug for LP_CLKRST {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("LP_CLKRST").finish()
    }
}
#[doc = "LP_CLKRST Peripheral"]
pub mod lp_clkrst;
#[doc = "LP_IO Peripheral"]
pub type LP_IO = crate::Periph<lp_io::RegisterBlock, 0x600b_4400>;
impl core::fmt::Debug for LP_IO {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("LP_IO").finish()
    }
}
#[doc = "LP_IO Peripheral"]
pub mod lp_io;
#[doc = "Low-power I2C (Inter-Integrated Circuit) Controller 0"]
pub type LP_I2C0 = crate::Periph<lp_i2c0::RegisterBlock, 0x600b_1800>;
impl core::fmt::Debug for LP_I2C0 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("LP_I2C0").finish()
    }
}
#[doc = "Low-power I2C (Inter-Integrated Circuit) Controller 0"]
pub mod lp_i2c0;
#[doc = "LP_I2C_ANA_MST Peripheral"]
pub type LP_I2C_ANA_MST = crate::Periph<lp_i2c_ana_mst::RegisterBlock, 0x600b_2400>;
impl core::fmt::Debug for LP_I2C_ANA_MST {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("LP_I2C_ANA_MST").finish()
    }
}
#[doc = "LP_I2C_ANA_MST Peripheral"]
pub mod lp_i2c_ana_mst;
#[doc = "Low-power Input/Output Multiplexer"]
pub type LP_IO_MUX = crate::Periph<lp_io_mux::RegisterBlock, 0x600b_4000>;
impl core::fmt::Debug for LP_IO_MUX {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("LP_IO_MUX").finish()
    }
}
#[doc = "Low-power Input/Output Multiplexer"]
pub mod lp_io_mux;
#[doc = "Low-power Trusted Execution Environment"]
pub type LP_TEE = crate::Periph<lp_tee::RegisterBlock, 0x600b_3400>;
impl core::fmt::Debug for LP_TEE {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("LP_TEE").finish()
    }
}
#[doc = "Low-power Trusted Execution Environment"]
pub mod lp_tee;
#[doc = "Low-power Timer"]
pub type LP_TIMER = crate::Periph<lp_timer::RegisterBlock, 0x600b_0c00>;
impl core::fmt::Debug for LP_TIMER {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("LP_TIMER").finish()
    }
}
#[doc = "Low-power Timer"]
pub mod lp_timer;
#[doc = "Low-power UART (Universal Asynchronous Receiver-Transmitter) Controller"]
pub type LP_UART = crate::Periph<lp_uart::RegisterBlock, 0x600b_1400>;
impl core::fmt::Debug for LP_UART {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("LP_UART").finish()
    }
}
#[doc = "Low-power UART (Universal Asynchronous Receiver-Transmitter) Controller"]
pub mod lp_uart;
#[doc = "Low-power Watchdog Timer"]
pub type LP_WDT = crate::Periph<lp_wdt::RegisterBlock, 0x600b_1c00>;
impl core::fmt::Debug for LP_WDT {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("LP_WDT").finish()
    }
}
#[doc = "Low-power Watchdog Timer"]
pub mod lp_wdt;
#[doc = "Motor Control Pulse-Width Modulation 0"]
pub type MCPWM0 = crate::Periph<mcpwm0::RegisterBlock, 0x6001_4000>;
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 = "MEM_MONITOR Peripheral"]
pub type MEM_MONITOR = crate::Periph<mem_monitor::RegisterBlock, 0x6009_2000>;
impl core::fmt::Debug for MEM_MONITOR {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("MEM_MONITOR").finish()
    }
}
#[doc = "MEM_MONITOR Peripheral"]
pub mod mem_monitor;
#[doc = "Parallel IO Controller"]
pub type PARL_IO = crate::Periph<parl_io::RegisterBlock, 0x6001_5000>;
impl core::fmt::Debug for PARL_IO {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("PARL_IO").finish()
    }
}
#[doc = "Parallel IO Controller"]
pub mod parl_io;
#[doc = "HINF"]
pub type HINF = crate::Periph<hinf::RegisterBlock, 0x6001_6000>;
impl core::fmt::Debug for HINF {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("HINF").finish()
    }
}
#[doc = "HINF"]
pub mod hinf;
#[doc = "SDIO SLC"]
pub type SLC = crate::Periph<slc::RegisterBlock, 0x6001_7000>;
impl core::fmt::Debug for SLC {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("SLC").finish()
    }
}
#[doc = "SDIO SLC"]
pub mod slc;
#[doc = "PAU Peripheral"]
pub type PAU = crate::Periph<pau::RegisterBlock, 0x6009_3000>;
impl core::fmt::Debug for PAU {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("PAU").finish()
    }
}
#[doc = "PAU Peripheral"]
pub mod pau;
#[doc = "Pulse Count Controller"]
pub type PCNT = crate::Periph<pcnt::RegisterBlock, 0x6001_2000>;
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 = "PCR Peripheral"]
pub type PCR = crate::Periph<pcr::RegisterBlock, 0x6009_6000>;
impl core::fmt::Debug for PCR {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("PCR").finish()
    }
}
#[doc = "PCR Peripheral"]
pub mod pcr;
#[doc = "PMU Peripheral"]
pub type PMU = crate::Periph<pmu::RegisterBlock, 0x600b_0000>;
impl core::fmt::Debug for PMU {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("PMU").finish()
    }
}
#[doc = "PMU Peripheral"]
pub mod pmu;
#[doc = "PVT Peripheral"]
pub type PVT = crate::Periph<pvt::RegisterBlock, 0x6001_9000>;
impl core::fmt::Debug for PVT {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("PVT").finish()
    }
}
#[doc = "PVT Peripheral"]
pub mod pvt;
#[doc = "Remote Control"]
pub type RMT = crate::Periph<rmt::RegisterBlock, 0x6000_6000>;
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 type RNG = crate::Periph<rng::RegisterBlock, 0x600b_2800>;
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 type RSA = crate::Periph<rsa::RegisterBlock, 0x6008_a000>;
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 = "SHA (Secure Hash Algorithm) Accelerator"]
pub type SHA = crate::Periph<sha::RegisterBlock, 0x6008_9000>;
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 = "Event Task Matrix"]
pub type SOC_ETM = crate::Periph<soc_etm::RegisterBlock, 0x6001_3000>;
impl core::fmt::Debug for SOC_ETM {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("SOC_ETM").finish()
    }
}
#[doc = "Event Task Matrix"]
pub mod soc_etm;
#[doc = "SPI (Serial Peripheral Interface) Controller 0"]
pub type SPI0 = crate::Periph<spi0::RegisterBlock, 0x6000_2000>;
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 type SPI1 = crate::Periph<spi1::RegisterBlock, 0x6000_3000>;
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 type SPI2 = crate::Periph<spi2::RegisterBlock, 0x6008_1000>;
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 = "System Timer"]
pub type SYSTIMER = crate::Periph<systimer::RegisterBlock, 0x6000_a000>;
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 = "TEE Peripheral"]
pub type TEE = crate::Periph<tee::RegisterBlock, 0x6009_8000>;
impl core::fmt::Debug for TEE {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("TEE").finish()
    }
}
#[doc = "TEE Peripheral"]
pub mod tee;
#[doc = "Timer Group 0"]
pub type TIMG0 = crate::Periph<timg0::RegisterBlock, 0x6000_8000>;
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 type TIMG1 = crate::Periph<timg0::RegisterBlock, 0x6000_9000>;
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 = "RISC-V Trace Encoder"]
pub type TRACE = crate::Periph<trace::RegisterBlock, 0x600c_0000>;
impl core::fmt::Debug for TRACE {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("TRACE").finish()
    }
}
#[doc = "RISC-V Trace Encoder"]
pub mod trace;
#[doc = "Two-Wire Automotive Interface"]
pub type TWAI0 = crate::Periph<twai0::RegisterBlock, 0x6000_b000>;
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 = "Two-Wire Automotive Interface"]
pub type TWAI1 = crate::Periph<twai0::RegisterBlock, 0x6000_d000>;
impl core::fmt::Debug for TWAI1 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("TWAI1").finish()
    }
}
#[doc = "Two-Wire Automotive Interface"]
pub use self::twai0 as twai1;
#[doc = "UART (Universal Asynchronous Receiver-Transmitter) Controller 0"]
pub type UART0 = crate::Periph<uart0::RegisterBlock, 0x6000_0000>;
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 type UART1 = crate::Periph<uart0::RegisterBlock, 0x6000_1000>;
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 = "Universal Host Controller Interface 0"]
pub type UHCI0 = crate::Periph<uhci0::RegisterBlock, 0x6000_5000>;
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 = "Full-speed USB Serial/JTAG Controller"]
pub type USB_DEVICE = crate::Periph<usb_device::RegisterBlock, 0x6000_f000>;
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;
#[no_mangle]
static mut DEVICE_PERIPHERALS: bool = false;
#[doc = r" All the peripherals."]
#[allow(non_snake_case)]
pub struct Peripherals {
    #[doc = "CLINT"]
    pub CLINT: CLINT,
    #[doc = "CLIC"]
    pub CLIC: CLIC,
    #[doc = "AES"]
    pub AES: AES,
    #[doc = "DMA"]
    pub DMA: DMA,
    #[doc = "APB_SARADC"]
    pub APB_SARADC: APB_SARADC,
    #[doc = "BITSCRAMBLER"]
    pub BITSCRAMBLER: BITSCRAMBLER,
    #[doc = "ASSIST_DEBUG"]
    pub ASSIST_DEBUG: ASSIST_DEBUG,
    #[doc = "DS"]
    pub DS: DS,
    #[doc = "ECC"]
    pub ECC: ECC,
    #[doc = "ECDSA"]
    pub ECDSA: ECDSA,
    #[doc = "EFUSE"]
    pub EFUSE: EFUSE,
    #[doc = "GPIO"]
    pub GPIO: GPIO,
    #[doc = "GPIO_EXT"]
    pub GPIO_EXT: GPIO_EXT,
    #[doc = "HMAC"]
    pub HMAC: HMAC,
    #[doc = "HP_APM"]
    pub HP_APM: HP_APM,
    #[doc = "IEEE802154"]
    pub IEEE802154: IEEE802154,
    #[doc = "MODEM_SYSCON"]
    pub MODEM_SYSCON: MODEM_SYSCON,
    #[doc = "MODEM_LPCON"]
    pub MODEM_LPCON: MODEM_LPCON,
    #[doc = "I2C_ANA_MST"]
    pub I2C_ANA_MST: I2C_ANA_MST,
    #[doc = "HP_SYS"]
    pub HP_SYS: HP_SYS,
    #[doc = "HUK"]
    pub HUK: HUK,
    #[doc = "I2C0"]
    pub I2C0: I2C0,
    #[doc = "I2S0"]
    pub I2S0: I2S0,
    #[doc = "INTERRUPT_CORE0"]
    pub INTERRUPT_CORE0: INTERRUPT_CORE0,
    #[doc = "INTPRI"]
    pub INTPRI: INTPRI,
    #[doc = "CACHE"]
    pub CACHE: CACHE,
    #[doc = "IO_MUX"]
    pub IO_MUX: IO_MUX,
    #[doc = "KEYMNG"]
    pub KEYMNG: KEYMNG,
    #[doc = "LEDC"]
    pub LEDC: LEDC,
    #[doc = "LPPERI"]
    pub LPPERI: LPPERI,
    #[doc = "LP_ANA"]
    pub LP_ANA: LP_ANA,
    #[doc = "LP_AON"]
    pub LP_AON: LP_AON,
    #[doc = "LP_APM0"]
    pub LP_APM0: LP_APM0,
    #[doc = "LP_APM"]
    pub LP_APM: LP_APM,
    #[doc = "LP_CLKRST"]
    pub LP_CLKRST: LP_CLKRST,
    #[doc = "LP_IO"]
    pub LP_IO: LP_IO,
    #[doc = "LP_I2C0"]
    pub LP_I2C0: LP_I2C0,
    #[doc = "LP_I2C_ANA_MST"]
    pub LP_I2C_ANA_MST: LP_I2C_ANA_MST,
    #[doc = "LP_IO_MUX"]
    pub LP_IO_MUX: LP_IO_MUX,
    #[doc = "LP_TEE"]
    pub LP_TEE: LP_TEE,
    #[doc = "LP_TIMER"]
    pub LP_TIMER: LP_TIMER,
    #[doc = "LP_UART"]
    pub LP_UART: LP_UART,
    #[doc = "LP_WDT"]
    pub LP_WDT: LP_WDT,
    #[doc = "MCPWM0"]
    pub MCPWM0: MCPWM0,
    #[doc = "MEM_MONITOR"]
    pub MEM_MONITOR: MEM_MONITOR,
    #[doc = "PARL_IO"]
    pub PARL_IO: PARL_IO,
    #[doc = "HINF"]
    pub HINF: HINF,
    #[doc = "SLC"]
    pub SLC: SLC,
    #[doc = "PAU"]
    pub PAU: PAU,
    #[doc = "PCNT"]
    pub PCNT: PCNT,
    #[doc = "PCR"]
    pub PCR: PCR,
    #[doc = "PMU"]
    pub PMU: PMU,
    #[doc = "PVT"]
    pub PVT: PVT,
    #[doc = "RMT"]
    pub RMT: RMT,
    #[doc = "RNG"]
    pub RNG: RNG,
    #[doc = "RSA"]
    pub RSA: RSA,
    #[doc = "SHA"]
    pub SHA: SHA,
    #[doc = "SOC_ETM"]
    pub SOC_ETM: SOC_ETM,
    #[doc = "SPI0"]
    pub SPI0: SPI0,
    #[doc = "SPI1"]
    pub SPI1: SPI1,
    #[doc = "SPI2"]
    pub SPI2: SPI2,
    #[doc = "SYSTIMER"]
    pub SYSTIMER: SYSTIMER,
    #[doc = "TEE"]
    pub TEE: TEE,
    #[doc = "TIMG0"]
    pub TIMG0: TIMG0,
    #[doc = "TIMG1"]
    pub TIMG1: TIMG1,
    #[doc = "TRACE"]
    pub TRACE: TRACE,
    #[doc = "TWAI0"]
    pub TWAI0: TWAI0,
    #[doc = "TWAI1"]
    pub TWAI1: TWAI1,
    #[doc = "UART0"]
    pub UART0: UART0,
    #[doc = "UART1"]
    pub UART1: UART1,
    #[doc = "UHCI0"]
    pub UHCI0: UHCI0,
    #[doc = "USB_DEVICE"]
    pub USB_DEVICE: USB_DEVICE,
}
impl Peripherals {
    #[doc = r" Returns all the peripherals *once*."]
    #[cfg(feature = "critical-section")]
    #[inline]
    pub fn take() -> Option<Self> {
        critical_section::with(|_| {
            if unsafe { DEVICE_PERIPHERALS } {
                return None;
            }
            Some(unsafe { Peripherals::steal() })
        })
    }
    #[doc = r" Unchecked version of `Peripherals::take`."]
    #[doc = r""]
    #[doc = r" # Safety"]
    #[doc = r""]
    #[doc = r" Each of the returned peripherals must be used at most once."]
    #[inline]
    pub unsafe fn steal() -> Self {
        DEVICE_PERIPHERALS = true;
        Peripherals {
            CLINT: CLINT::steal(),
            CLIC: CLIC::steal(),
            AES: AES::steal(),
            DMA: DMA::steal(),
            APB_SARADC: APB_SARADC::steal(),
            BITSCRAMBLER: BITSCRAMBLER::steal(),
            ASSIST_DEBUG: ASSIST_DEBUG::steal(),
            DS: DS::steal(),
            ECC: ECC::steal(),
            ECDSA: ECDSA::steal(),
            EFUSE: EFUSE::steal(),
            GPIO: GPIO::steal(),
            GPIO_EXT: GPIO_EXT::steal(),
            HMAC: HMAC::steal(),
            HP_APM: HP_APM::steal(),
            IEEE802154: IEEE802154::steal(),
            MODEM_SYSCON: MODEM_SYSCON::steal(),
            MODEM_LPCON: MODEM_LPCON::steal(),
            I2C_ANA_MST: I2C_ANA_MST::steal(),
            HP_SYS: HP_SYS::steal(),
            HUK: HUK::steal(),
            I2C0: I2C0::steal(),
            I2S0: I2S0::steal(),
            INTERRUPT_CORE0: INTERRUPT_CORE0::steal(),
            INTPRI: INTPRI::steal(),
            CACHE: CACHE::steal(),
            IO_MUX: IO_MUX::steal(),
            KEYMNG: KEYMNG::steal(),
            LEDC: LEDC::steal(),
            LPPERI: LPPERI::steal(),
            LP_ANA: LP_ANA::steal(),
            LP_AON: LP_AON::steal(),
            LP_APM0: LP_APM0::steal(),
            LP_APM: LP_APM::steal(),
            LP_CLKRST: LP_CLKRST::steal(),
            LP_IO: LP_IO::steal(),
            LP_I2C0: LP_I2C0::steal(),
            LP_I2C_ANA_MST: LP_I2C_ANA_MST::steal(),
            LP_IO_MUX: LP_IO_MUX::steal(),
            LP_TEE: LP_TEE::steal(),
            LP_TIMER: LP_TIMER::steal(),
            LP_UART: LP_UART::steal(),
            LP_WDT: LP_WDT::steal(),
            MCPWM0: MCPWM0::steal(),
            MEM_MONITOR: MEM_MONITOR::steal(),
            PARL_IO: PARL_IO::steal(),
            HINF: HINF::steal(),
            SLC: SLC::steal(),
            PAU: PAU::steal(),
            PCNT: PCNT::steal(),
            PCR: PCR::steal(),
            PMU: PMU::steal(),
            PVT: PVT::steal(),
            RMT: RMT::steal(),
            RNG: RNG::steal(),
            RSA: RSA::steal(),
            SHA: SHA::steal(),
            SOC_ETM: SOC_ETM::steal(),
            SPI0: SPI0::steal(),
            SPI1: SPI1::steal(),
            SPI2: SPI2::steal(),
            SYSTIMER: SYSTIMER::steal(),
            TEE: TEE::steal(),
            TIMG0: TIMG0::steal(),
            TIMG1: TIMG1::steal(),
            TRACE: TRACE::steal(),
            TWAI0: TWAI0::steal(),
            TWAI1: TWAI1::steal(),
            UART0: UART0::steal(),
            UART1: UART1::steal(),
            UHCI0: UHCI0::steal(),
            USB_DEVICE: USB_DEVICE::steal(),
        }
    }
}
