#![doc = "Peripheral access API for RV32M1_RI5CY microcontrollers (generated using svd2rust v0.16.1)\n\nYou can find an overview of the API [here].\n\n[here]: https://docs.rs/svd2rust/0.16.1/svd2rust/#peripheral-api"]
#![deny(missing_docs)]
#![deny(warnings)]
#![allow(non_camel_case_types)]
#![no_std]
extern crate bare_metal;
extern crate riscv;
#[cfg(feature = "rt")]
extern crate riscv_rt;
extern crate vcell;
use core::marker::PhantomData;
use core::ops::Deref;
#[doc = r"Number available in the NVIC for configuring priority"]
pub const NVIC_PRIO_BITS: u8 = 3;
#[doc(hidden)]
pub mod interrupt;
pub use self::interrupt::Interrupt;
#[allow(unused_imports)]
use generic::*;
#[doc = r"Common register and bit access and modify traits"]
pub mod generic;
#[doc = "MSCM"]
pub struct MSCM {
  _marker: PhantomData<*const ()>,
}
unsafe impl Send for MSCM {}
impl MSCM {
  #[doc = r"Returns a pointer to the register block"]
  #[inline(always)]
  pub const fn ptr() -> *const mscm::RegisterBlock {
    0x4000_1000 as *const _
  }
}
impl Deref for MSCM {
  type Target = mscm::RegisterBlock;
  fn deref(&self) -> &Self::Target {
    unsafe { &*MSCM::ptr() }
  }
}
#[doc = "MSCM"]
pub mod mscm;
#[doc = "DMA"]
pub struct DMA0 {
  _marker: PhantomData<*const ()>,
}
unsafe impl Send for DMA0 {}
impl DMA0 {
  #[doc = r"Returns a pointer to the register block"]
  #[inline(always)]
  pub const fn ptr() -> *const dma0::RegisterBlock {
    0x4000_8000 as *const _
  }
}
impl Deref for DMA0 {
  type Target = dma0::RegisterBlock;
  fn deref(&self) -> &Self::Target {
    unsafe { &*DMA0::ptr() }
  }
}
#[doc = "DMA"]
pub mod dma0;
#[doc = "FB"]
pub struct FB {
  _marker: PhantomData<*const ()>,
}
unsafe impl Send for FB {}
impl FB {
  #[doc = r"Returns a pointer to the register block"]
  #[inline(always)]
  pub const fn ptr() -> *const fb::RegisterBlock {
    0x4000_c000 as *const _
  }
}
impl Deref for FB {
  type Target = fb::RegisterBlock;
  fn deref(&self) -> &Self::Target {
    unsafe { &*FB::ptr() }
  }
}
#[doc = "FB"]
pub mod fb;
#[doc = "XRDC"]
pub struct XRDC {
  _marker: PhantomData<*const ()>,
}
unsafe impl Send for XRDC {}
impl XRDC {
  #[doc = r"Returns a pointer to the register block"]
  #[inline(always)]
  pub const fn ptr() -> *const xrdc::RegisterBlock {
    0x4001_4000 as *const _
  }
}
impl Deref for XRDC {
  type Target = xrdc::RegisterBlock;
  fn deref(&self) -> &Self::Target {
    unsafe { &*XRDC::ptr() }
  }
}
#[doc = "XRDC"]
pub mod xrdc;
#[doc = "sema42_ips"]
pub struct SEMA420 {
  _marker: PhantomData<*const ()>,
}
unsafe impl Send for SEMA420 {}
impl SEMA420 {
  #[doc = r"Returns a pointer to the register block"]
  #[inline(always)]
  pub const fn ptr() -> *const sema420::RegisterBlock {
    0x4001_b000 as *const _
  }
}
impl Deref for SEMA420 {
  type Target = sema420::RegisterBlock;
  fn deref(&self) -> &Self::Target {
    unsafe { &*SEMA420::ptr() }
  }
}
#[doc = "sema42_ips"]
pub mod sema420;
#[doc = "crr_cmc0"]
pub struct SMC0 {
  _marker: PhantomData<*const ()>,
}
unsafe impl Send for SMC0 {}
impl SMC0 {
  #[doc = r"Returns a pointer to the register block"]
  #[inline(always)]
  pub const fn ptr() -> *const smc0::RegisterBlock {
    0x4002_0000 as *const _
  }
}
impl Deref for SMC0 {
  type Target = smc0::RegisterBlock;
  fn deref(&self) -> &Self::Target {
    unsafe { &*SMC0::ptr() }
  }
}
#[doc = "crr_cmc0"]
pub mod smc0;
#[doc = "DMA_CH_MUX"]
pub struct DMAMUX0 {
  _marker: PhantomData<*const ()>,
}
unsafe impl Send for DMAMUX0 {}
impl DMAMUX0 {
  #[doc = r"Returns a pointer to the register block"]
  #[inline(always)]
  pub const fn ptr() -> *const dmamux0::RegisterBlock {
    0x4002_1000 as *const _
  }
}
impl Deref for DMAMUX0 {
  type Target = dmamux0::RegisterBlock;
  fn deref(&self) -> &Self::Target {
    unsafe { &*DMAMUX0::ptr() }
  }
}
#[doc = "DMA_CH_MUX"]
pub mod dmamux0;
#[doc = "EWM"]
pub struct EWM {
  _marker: PhantomData<*const ()>,
}
unsafe impl Send for EWM {}
impl EWM {
  #[doc = r"Returns a pointer to the register block"]
  #[inline(always)]
  pub const fn ptr() -> *const ewm::RegisterBlock {
    0x4002_2000 as *const _
  }
}
impl Deref for EWM {
  type Target = ewm::RegisterBlock;
  fn deref(&self) -> &Self::Target {
    unsafe { &*EWM::ptr() }
  }
}
#[doc = "EWM"]
pub mod ewm;
#[doc = "Flash"]
pub struct FTFE {
  _marker: PhantomData<*const ()>,
}
unsafe impl Send for FTFE {}
impl FTFE {
  #[doc = r"Returns a pointer to the register block"]
  #[inline(always)]
  pub const fn ptr() -> *const ftfe::RegisterBlock {
    0x4002_3000 as *const _
  }
}
impl Deref for FTFE {
  type Target = ftfe::RegisterBlock;
  fn deref(&self) -> &Self::Target {
    unsafe { &*FTFE::ptr() }
  }
}
#[doc = "Flash"]
pub mod ftfe;
#[doc = "LLWU"]
pub struct LLWU0 {
  _marker: PhantomData<*const ()>,
}
unsafe impl Send for LLWU0 {}
impl LLWU0 {
  #[doc = r"Returns a pointer to the register block"]
  #[inline(always)]
  pub const fn ptr() -> *const llwu0::RegisterBlock {
    0x4002_4000 as *const _
  }
}
impl Deref for LLWU0 {
  type Target = llwu0::RegisterBlock;
  fn deref(&self) -> &Self::Target {
    unsafe { &*LLWU0::ptr() }
  }
}
#[doc = "LLWU"]
pub mod llwu0;
#[doc = "MUA"]
pub struct MUA {
  _marker: PhantomData<*const ()>,
}
unsafe impl Send for MUA {}
impl MUA {
  #[doc = r"Returns a pointer to the register block"]
  #[inline(always)]
  pub const fn ptr() -> *const mua::RegisterBlock {
    0x4002_5000 as *const _
  }
}
impl Deref for MUA {
  type Target = mua::RegisterBlock;
  fn deref(&self) -> &Self::Target {
    unsafe { &*MUA::ptr() }
  }
}
#[doc = "MUA"]
pub mod mua;
#[doc = "SIM"]
pub struct SIM {
  _marker: PhantomData<*const ()>,
}
unsafe impl Send for SIM {}
impl SIM {
  #[doc = r"Returns a pointer to the register block"]
  #[inline(always)]
  pub const fn ptr() -> *const sim::RegisterBlock {
    0x4002_6000 as *const _
  }
}
impl Deref for SIM {
  type Target = sim::RegisterBlock;
  fn deref(&self) -> &Self::Target {
    unsafe { &*SIM::ptr() }
  }
}
#[doc = "SIM"]
pub mod sim;
#[doc = "USBVREG"]
pub struct USBVREG {
  _marker: PhantomData<*const ()>,
}
unsafe impl Send for USBVREG {}
impl USBVREG {
  #[doc = r"Returns a pointer to the register block"]
  #[inline(always)]
  pub const fn ptr() -> *const usbvreg::RegisterBlock {
    0x4002_7000 as *const _
  }
}
impl Deref for USBVREG {
  type Target = usbvreg::RegisterBlock;
  fn deref(&self) -> &Self::Target {
    unsafe { &*USBVREG::ptr() }
  }
}
#[doc = "USBVREG"]
pub mod usbvreg;
#[doc = "SPM"]
pub struct SPM {
  _marker: PhantomData<*const ()>,
}
unsafe impl Send for SPM {}
impl SPM {
  #[doc = r"Returns a pointer to the register block"]
  #[inline(always)]
  pub const fn ptr() -> *const spm::RegisterBlock {
    0x4002_8000 as *const _
  }
}
impl Deref for SPM {
  type Target = spm::RegisterBlock;
  fn deref(&self) -> &Self::Target {
    unsafe { &*SPM::ptr() }
  }
}
#[doc = "SPM"]
pub mod spm;
#[doc = "TRGMUX"]
pub struct TRGMUX0 {
  _marker: PhantomData<*const ()>,
}
unsafe impl Send for TRGMUX0 {}
impl TRGMUX0 {
  #[doc = r"Returns a pointer to the register block"]
  #[inline(always)]
  pub const fn ptr() -> *const trgmux0::RegisterBlock {
    0x4002_9000 as *const _
  }
}
impl Deref for TRGMUX0 {
  type Target = trgmux0::RegisterBlock;
  fn deref(&self) -> &Self::Target {
    unsafe { &*TRGMUX0::ptr() }
  }
}
#[doc = "TRGMUX"]
pub mod trgmux0;
#[doc = "WDOG"]
pub struct WDOG0 {
  _marker: PhantomData<*const ()>,
}
unsafe impl Send for WDOG0 {}
impl WDOG0 {
  #[doc = r"Returns a pointer to the register block"]
  #[inline(always)]
  pub const fn ptr() -> *const wdog0::RegisterBlock {
    0x4002_a000 as *const _
  }
}
impl Deref for WDOG0 {
  type Target = wdog0::RegisterBlock;
  fn deref(&self) -> &Self::Target {
    unsafe { &*WDOG0::ptr() }
  }
}
#[doc = "WDOG"]
pub mod wdog0;
#[doc = "PCC"]
pub struct PCC0 {
  _marker: PhantomData<*const ()>,
}
unsafe impl Send for PCC0 {}
impl PCC0 {
  #[doc = r"Returns a pointer to the register block"]
  #[inline(always)]
  pub const fn ptr() -> *const pcc0::RegisterBlock {
    0x4002_b000 as *const _
  }
}
impl Deref for PCC0 {
  type Target = pcc0::RegisterBlock;
  fn deref(&self) -> &Self::Target {
    unsafe { &*PCC0::ptr() }
  }
}
#[doc = "PCC"]
pub mod pcc0;
#[doc = "SCG"]
pub struct SCG {
  _marker: PhantomData<*const ()>,
}
unsafe impl Send for SCG {}
impl SCG {
  #[doc = r"Returns a pointer to the register block"]
  #[inline(always)]
  pub const fn ptr() -> *const scg::RegisterBlock {
    0x4002_c000 as *const _
  }
}
impl Deref for SCG {
  type Target = scg::RegisterBlock;
  fn deref(&self) -> &Self::Target {
    unsafe { &*SCG::ptr() }
  }
}
#[doc = "SCG"]
pub mod scg;
#[doc = "CRC"]
pub struct CRC {
  _marker: PhantomData<*const ()>,
}
unsafe impl Send for CRC {}
impl CRC {
  #[doc = r"Returns a pointer to the register block"]
  #[inline(always)]
  pub const fn ptr() -> *const crc::RegisterBlock {
    0x4002_f000 as *const _
  }
}
impl Deref for CRC {
  type Target = crc::RegisterBlock;
  fn deref(&self) -> &Self::Target {
    unsafe { &*CRC::ptr() }
  }
}
#[doc = "CRC"]
pub mod crc;
#[doc = "LPIT"]
pub struct LPIT0 {
  _marker: PhantomData<*const ()>,
}
unsafe impl Send for LPIT0 {}
impl LPIT0 {
  #[doc = r"Returns a pointer to the register block"]
  #[inline(always)]
  pub const fn ptr() -> *const lpit0::RegisterBlock {
    0x4003_0000 as *const _
  }
}
impl Deref for LPIT0 {
  type Target = lpit0::RegisterBlock;
  fn deref(&self) -> &Self::Target {
    unsafe { &*LPIT0::ptr() }
  }
}
#[doc = "LPIT"]
pub mod lpit0;
#[doc = "RTC"]
pub struct RTC {
  _marker: PhantomData<*const ()>,
}
unsafe impl Send for RTC {}
impl RTC {
  #[doc = r"Returns a pointer to the register block"]
  #[inline(always)]
  pub const fn ptr() -> *const rtc::RegisterBlock {
    0x4003_1000 as *const _
  }
}
impl Deref for RTC {
  type Target = rtc::RegisterBlock;
  fn deref(&self) -> &Self::Target {
    unsafe { &*RTC::ptr() }
  }
}
#[doc = "RTC"]
pub mod rtc;
#[doc = "LPTMR"]
pub struct LPTMR0 {
  _marker: PhantomData<*const ()>,
}
unsafe impl Send for LPTMR0 {}
impl LPTMR0 {
  #[doc = r"Returns a pointer to the register block"]
  #[inline(always)]
  pub const fn ptr() -> *const lptmr0::RegisterBlock {
    0x4003_2000 as *const _
  }
}
impl Deref for LPTMR0 {
  type Target = lptmr0::RegisterBlock;
  fn deref(&self) -> &Self::Target {
    unsafe { &*LPTMR0::ptr() }
  }
}
#[doc = "LPTMR"]
pub mod lptmr0;
#[doc = "LPTMR"]
pub struct LPTMR1 {
  _marker: PhantomData<*const ()>,
}
unsafe impl Send for LPTMR1 {}
impl LPTMR1 {
  #[doc = r"Returns a pointer to the register block"]
  #[inline(always)]
  pub const fn ptr() -> *const lptmr1::RegisterBlock {
    0x4003_3000 as *const _
  }
}
impl Deref for LPTMR1 {
  type Target = lptmr1::RegisterBlock;
  fn deref(&self) -> &Self::Target {
    unsafe { &*LPTMR1::ptr() }
  }
}
#[doc = "LPTMR"]
pub mod lptmr1;
#[doc = "TSTMRA"]
pub struct TSTMRA {
  _marker: PhantomData<*const ()>,
}
unsafe impl Send for TSTMRA {}
impl TSTMRA {
  #[doc = r"Returns a pointer to the register block"]
  #[inline(always)]
  pub const fn ptr() -> *const tstmra::RegisterBlock {
    0x4003_4000 as *const _
  }
}
impl Deref for TSTMRA {
  type Target = tstmra::RegisterBlock;
  fn deref(&self) -> &Self::Target {
    unsafe { &*TSTMRA::ptr() }
  }
}
#[doc = "TSTMRA"]
pub mod tstmra;
#[doc = "TPM"]
pub struct TPM0 {
  _marker: PhantomData<*const ()>,
}
unsafe impl Send for TPM0 {}
impl TPM0 {
  #[doc = r"Returns a pointer to the register block"]
  #[inline(always)]
  pub const fn ptr() -> *const tpm0::RegisterBlock {
    0x4003_5000 as *const _
  }
}
impl Deref for TPM0 {
  type Target = tpm0::RegisterBlock;
  fn deref(&self) -> &Self::Target {
    unsafe { &*TPM0::ptr() }
  }
}
#[doc = "TPM"]
pub mod tpm0;
#[doc = "TPM"]
pub struct TPM1 {
  _marker: PhantomData<*const ()>,
}
unsafe impl Send for TPM1 {}
impl TPM1 {
  #[doc = r"Returns a pointer to the register block"]
  #[inline(always)]
  pub const fn ptr() -> *const tpm1::RegisterBlock {
    0x4003_6000 as *const _
  }
}
impl Deref for TPM1 {
  type Target = tpm1::RegisterBlock;
  fn deref(&self) -> &Self::Target {
    unsafe { &*TPM1::ptr() }
  }
}
#[doc = "TPM"]
pub mod tpm1;
#[doc = "TPM"]
pub struct TPM2 {
  _marker: PhantomData<*const ()>,
}
unsafe impl Send for TPM2 {}
impl TPM2 {
  #[doc = r"Returns a pointer to the register block"]
  #[inline(always)]
  pub const fn ptr() -> *const tpm2::RegisterBlock {
    0x4003_7000 as *const _
  }
}
impl Deref for TPM2 {
  type Target = tpm2::RegisterBlock;
  fn deref(&self) -> &Self::Target {
    unsafe { &*TPM2::ptr() }
  }
}
#[doc = "TPM"]
pub mod tpm2;
#[doc = "EMVSIM"]
pub struct EMVSIM0 {
  _marker: PhantomData<*const ()>,
}
unsafe impl Send for EMVSIM0 {}
impl EMVSIM0 {
  #[doc = r"Returns a pointer to the register block"]
  #[inline(always)]
  pub const fn ptr() -> *const emvsim0::RegisterBlock {
    0x4003_8000 as *const _
  }
}
impl Deref for EMVSIM0 {
  type Target = emvsim0::RegisterBlock;
  fn deref(&self) -> &Self::Target {
    unsafe { &*EMVSIM0::ptr() }
  }
}
#[doc = "EMVSIM"]
pub mod emvsim0;
#[doc = "FLEXIO"]
pub struct FLEXIO0 {
  _marker: PhantomData<*const ()>,
}
unsafe impl Send for FLEXIO0 {}
impl FLEXIO0 {
  #[doc = r"Returns a pointer to the register block"]
  #[inline(always)]
  pub const fn ptr() -> *const flexio0::RegisterBlock {
    0x4003_9000 as *const _
  }
}
impl Deref for FLEXIO0 {
  type Target = flexio0::RegisterBlock;
  fn deref(&self) -> &Self::Target {
    unsafe { &*FLEXIO0::ptr() }
  }
}
#[doc = "FLEXIO"]
pub mod flexio0;
#[doc = "LPI2C"]
pub struct LPI2C0 {
  _marker: PhantomData<*const ()>,
}
unsafe impl Send for LPI2C0 {}
impl LPI2C0 {
  #[doc = r"Returns a pointer to the register block"]
  #[inline(always)]
  pub const fn ptr() -> *const lpi2c0::RegisterBlock {
    0x4003_a000 as *const _
  }
}
impl Deref for LPI2C0 {
  type Target = lpi2c0::RegisterBlock;
  fn deref(&self) -> &Self::Target {
    unsafe { &*LPI2C0::ptr() }
  }
}
#[doc = "LPI2C"]
pub mod lpi2c0;
#[doc = "LPI2C"]
pub struct LPI2C1 {
  _marker: PhantomData<*const ()>,
}
unsafe impl Send for LPI2C1 {}
impl LPI2C1 {
  #[doc = r"Returns a pointer to the register block"]
  #[inline(always)]
  pub const fn ptr() -> *const lpi2c1::RegisterBlock {
    0x4003_b000 as *const _
  }
}
impl Deref for LPI2C1 {
  type Target = lpi2c1::RegisterBlock;
  fn deref(&self) -> &Self::Target {
    unsafe { &*LPI2C1::ptr() }
  }
}
#[doc = "LPI2C"]
pub mod lpi2c1;
#[doc = "LPI2C"]
pub struct LPI2C2 {
  _marker: PhantomData<*const ()>,
}
unsafe impl Send for LPI2C2 {}
impl LPI2C2 {
  #[doc = r"Returns a pointer to the register block"]
  #[inline(always)]
  pub const fn ptr() -> *const lpi2c2::RegisterBlock {
    0x4003_c000 as *const _
  }
}
impl Deref for LPI2C2 {
  type Target = lpi2c2::RegisterBlock;
  fn deref(&self) -> &Self::Target {
    unsafe { &*LPI2C2::ptr() }
  }
}
#[doc = "LPI2C"]
pub mod lpi2c2;
#[doc = "I2S"]
pub struct I2S0 {
  _marker: PhantomData<*const ()>,
}
unsafe impl Send for I2S0 {}
impl I2S0 {
  #[doc = r"Returns a pointer to the register block"]
  #[inline(always)]
  pub const fn ptr() -> *const i2s0::RegisterBlock {
    0x4003_d000 as *const _
  }
}
impl Deref for I2S0 {
  type Target = i2s0::RegisterBlock;
  fn deref(&self) -> &Self::Target {
    unsafe { &*I2S0::ptr() }
  }
}
#[doc = "I2S"]
pub mod i2s0;
#[doc = "uSDHC"]
pub struct USDHC0 {
  _marker: PhantomData<*const ()>,
}
unsafe impl Send for USDHC0 {}
impl USDHC0 {
  #[doc = r"Returns a pointer to the register block"]
  #[inline(always)]
  pub const fn ptr() -> *const usdhc0::RegisterBlock {
    0x4003_e000 as *const _
  }
}
impl Deref for USDHC0 {
  type Target = usdhc0::RegisterBlock;
  fn deref(&self) -> &Self::Target {
    unsafe { &*USDHC0::ptr() }
  }
}
#[doc = "uSDHC"]
pub mod usdhc0;
#[doc = "LPSPI"]
pub struct LPSPI0 {
  _marker: PhantomData<*const ()>,
}
unsafe impl Send for LPSPI0 {}
impl LPSPI0 {
  #[doc = r"Returns a pointer to the register block"]
  #[inline(always)]
  pub const fn ptr() -> *const lpspi0::RegisterBlock {
    0x4003_f000 as *const _
  }
}
impl Deref for LPSPI0 {
  type Target = lpspi0::RegisterBlock;
  fn deref(&self) -> &Self::Target {
    unsafe { &*LPSPI0::ptr() }
  }
}
#[doc = "LPSPI"]
pub mod lpspi0;
#[doc = "LPSPI"]
pub struct LPSPI1 {
  _marker: PhantomData<*const ()>,
}
unsafe impl Send for LPSPI1 {}
impl LPSPI1 {
  #[doc = r"Returns a pointer to the register block"]
  #[inline(always)]
  pub const fn ptr() -> *const lpspi1::RegisterBlock {
    0x4004_0000 as *const _
  }
}
impl Deref for LPSPI1 {
  type Target = lpspi1::RegisterBlock;
  fn deref(&self) -> &Self::Target {
    unsafe { &*LPSPI1::ptr() }
  }
}
#[doc = "LPSPI"]
pub mod lpspi1;
#[doc = "LPSPI"]
pub struct LPSPI2 {
  _marker: PhantomData<*const ()>,
}
unsafe impl Send for LPSPI2 {}
impl LPSPI2 {
  #[doc = r"Returns a pointer to the register block"]
  #[inline(always)]
  pub const fn ptr() -> *const lpspi2::RegisterBlock {
    0x4004_1000 as *const _
  }
}
impl Deref for LPSPI2 {
  type Target = lpspi2::RegisterBlock;
  fn deref(&self) -> &Self::Target {
    unsafe { &*LPSPI2::ptr() }
  }
}
#[doc = "LPSPI"]
pub mod lpspi2;
#[doc = "LPUART"]
pub struct LPUART0 {
  _marker: PhantomData<*const ()>,
}
unsafe impl Send for LPUART0 {}
impl LPUART0 {
  #[doc = r"Returns a pointer to the register block"]
  #[inline(always)]
  pub const fn ptr() -> *const lpuart0::RegisterBlock {
    0x4004_2000 as *const _
  }
}
impl Deref for LPUART0 {
  type Target = lpuart0::RegisterBlock;
  fn deref(&self) -> &Self::Target {
    unsafe { &*LPUART0::ptr() }
  }
}
#[doc = "LPUART"]
pub mod lpuart0;
#[doc = "LPUART"]
pub struct LPUART1 {
  _marker: PhantomData<*const ()>,
}
unsafe impl Send for LPUART1 {}
impl LPUART1 {
  #[doc = r"Returns a pointer to the register block"]
  #[inline(always)]
  pub const fn ptr() -> *const lpuart1::RegisterBlock {
    0x4004_3000 as *const _
  }
}
impl Deref for LPUART1 {
  type Target = lpuart1::RegisterBlock;
  fn deref(&self) -> &Self::Target {
    unsafe { &*LPUART1::ptr() }
  }
}
#[doc = "LPUART"]
pub mod lpuart1;
#[doc = "LPUART"]
pub struct LPUART2 {
  _marker: PhantomData<*const ()>,
}
unsafe impl Send for LPUART2 {}
impl LPUART2 {
  #[doc = r"Returns a pointer to the register block"]
  #[inline(always)]
  pub const fn ptr() -> *const lpuart2::RegisterBlock {
    0x4004_4000 as *const _
  }
}
impl Deref for LPUART2 {
  type Target = lpuart2::RegisterBlock;
  fn deref(&self) -> &Self::Target {
    unsafe { &*LPUART2::ptr() }
  }
}
#[doc = "LPUART"]
pub mod lpuart2;
#[doc = "USB"]
pub struct USB0 {
  _marker: PhantomData<*const ()>,
}
unsafe impl Send for USB0 {}
impl USB0 {
  #[doc = r"Returns a pointer to the register block"]
  #[inline(always)]
  pub const fn ptr() -> *const usb0::RegisterBlock {
    0x4004_5000 as *const _
  }
}
impl Deref for USB0 {
  type Target = usb0::RegisterBlock;
  fn deref(&self) -> &Self::Target {
    unsafe { &*USB0::ptr() }
  }
}
#[doc = "USB"]
pub mod usb0;
#[doc = "PORT"]
pub struct PORTA {
  _marker: PhantomData<*const ()>,
}
unsafe impl Send for PORTA {}
impl PORTA {
  #[doc = r"Returns a pointer to the register block"]
  #[inline(always)]
  pub const fn ptr() -> *const porta::RegisterBlock {
    0x4004_6000 as *const _
  }
}
impl Deref for PORTA {
  type Target = porta::RegisterBlock;
  fn deref(&self) -> &Self::Target {
    unsafe { &*PORTA::ptr() }
  }
}
#[doc = "PORT"]
pub mod porta;
#[doc = "PORT"]
pub struct PORTB {
  _marker: PhantomData<*const ()>,
}
unsafe impl Send for PORTB {}
impl PORTB {
  #[doc = r"Returns a pointer to the register block"]
  #[inline(always)]
  pub const fn ptr() -> *const portb::RegisterBlock {
    0x4004_7000 as *const _
  }
}
impl Deref for PORTB {
  type Target = portb::RegisterBlock;
  fn deref(&self) -> &Self::Target {
    unsafe { &*PORTB::ptr() }
  }
}
#[doc = "PORT"]
pub mod portb;
#[doc = "PORT"]
pub struct PORTC {
  _marker: PhantomData<*const ()>,
}
unsafe impl Send for PORTC {}
impl PORTC {
  #[doc = r"Returns a pointer to the register block"]
  #[inline(always)]
  pub const fn ptr() -> *const portc::RegisterBlock {
    0x4004_8000 as *const _
  }
}
impl Deref for PORTC {
  type Target = portc::RegisterBlock;
  fn deref(&self) -> &Self::Target {
    unsafe { &*PORTC::ptr() }
  }
}
#[doc = "PORT"]
pub mod portc;
#[doc = "PORT"]
pub struct PORTD {
  _marker: PhantomData<*const ()>,
}
unsafe impl Send for PORTD {}
impl PORTD {
  #[doc = r"Returns a pointer to the register block"]
  #[inline(always)]
  pub const fn ptr() -> *const portd::RegisterBlock {
    0x4004_9000 as *const _
  }
}
impl Deref for PORTD {
  type Target = portd::RegisterBlock;
  fn deref(&self) -> &Self::Target {
    unsafe { &*PORTD::ptr() }
  }
}
#[doc = "PORT"]
pub mod portd;
#[doc = "ADC"]
pub struct ADC0 {
  _marker: PhantomData<*const ()>,
}
unsafe impl Send for ADC0 {}
impl ADC0 {
  #[doc = r"Returns a pointer to the register block"]
  #[inline(always)]
  pub const fn ptr() -> *const adc0::RegisterBlock {
    0x4004_a000 as *const _
  }
}
impl Deref for ADC0 {
  type Target = adc0::RegisterBlock;
  fn deref(&self) -> &Self::Target {
    unsafe { &*ADC0::ptr() }
  }
}
#[doc = "ADC"]
pub mod adc0;
#[doc = "LPCMP"]
pub struct LPCMP0 {
  _marker: PhantomData<*const ()>,
}
unsafe impl Send for LPCMP0 {}
impl LPCMP0 {
  #[doc = r"Returns a pointer to the register block"]
  #[inline(always)]
  pub const fn ptr() -> *const lpcmp0::RegisterBlock {
    0x4004_b000 as *const _
  }
}
impl Deref for LPCMP0 {
  type Target = lpcmp0::RegisterBlock;
  fn deref(&self) -> &Self::Target {
    unsafe { &*LPCMP0::ptr() }
  }
}
#[doc = "LPCMP"]
pub mod lpcmp0;
#[doc = "LPDAC"]
pub struct LPDAC0 {
  _marker: PhantomData<*const ()>,
}
unsafe impl Send for LPDAC0 {}
impl LPDAC0 {
  #[doc = r"Returns a pointer to the register block"]
  #[inline(always)]
  pub const fn ptr() -> *const lpdac0::RegisterBlock {
    0x4004_c000 as *const _
  }
}
impl Deref for LPDAC0 {
  type Target = lpdac0::RegisterBlock;
  fn deref(&self) -> &Self::Target {
    unsafe { &*LPDAC0::ptr() }
  }
}
#[doc = "LPDAC"]
pub mod lpdac0;
#[doc = "VREF"]
pub struct VREF {
  _marker: PhantomData<*const ()>,
}
unsafe impl Send for VREF {}
impl VREF {
  #[doc = r"Returns a pointer to the register block"]
  #[inline(always)]
  pub const fn ptr() -> *const vref::RegisterBlock {
    0x4004_d000 as *const _
  }
}
impl Deref for VREF {
  type Target = vref::RegisterBlock;
  fn deref(&self) -> &Self::Target {
    unsafe { &*VREF::ptr() }
  }
}
#[doc = "VREF"]
pub mod vref;
#[doc = "GPIO"]
pub struct GPIOA {
  _marker: PhantomData<*const ()>,
}
unsafe impl Send for GPIOA {}
impl GPIOA {
  #[doc = r"Returns a pointer to the register block"]
  #[inline(always)]
  pub const fn ptr() -> *const gpioa::RegisterBlock {
    0x4802_0000 as *const _
  }
}
impl Deref for GPIOA {
  type Target = gpioa::RegisterBlock;
  fn deref(&self) -> &Self::Target {
    unsafe { &*GPIOA::ptr() }
  }
}
#[doc = "GPIO"]
pub mod gpioa;
#[doc = "GPIO"]
pub struct GPIOE {
  _marker: PhantomData<*const ()>,
}
unsafe impl Send for GPIOE {}
impl GPIOE {
  #[doc = r"Returns a pointer to the register block"]
  #[inline(always)]
  pub const fn ptr() -> *const gpioa::RegisterBlock {
    0x4100_f000 as *const _
  }
}
impl Deref for GPIOE {
  type Target = gpioa::RegisterBlock;
  fn deref(&self) -> &Self::Target {
    unsafe { &*GPIOE::ptr() }
  }
}
#[doc = "GPIO"]
pub struct GPIOB {
  _marker: PhantomData<*const ()>,
}
unsafe impl Send for GPIOB {}
impl GPIOB {
  #[doc = r"Returns a pointer to the register block"]
  #[inline(always)]
  pub const fn ptr() -> *const gpioa::RegisterBlock {
    0x4802_0040 as *const _
  }
}
impl Deref for GPIOB {
  type Target = gpioa::RegisterBlock;
  fn deref(&self) -> &Self::Target {
    unsafe { &*GPIOB::ptr() }
  }
}
#[doc = "GPIO"]
pub struct GPIOC {
  _marker: PhantomData<*const ()>,
}
unsafe impl Send for GPIOC {}
impl GPIOC {
  #[doc = r"Returns a pointer to the register block"]
  #[inline(always)]
  pub const fn ptr() -> *const gpioa::RegisterBlock {
    0x4802_0080 as *const _
  }
}
impl Deref for GPIOC {
  type Target = gpioa::RegisterBlock;
  fn deref(&self) -> &Self::Target {
    unsafe { &*GPIOC::ptr() }
  }
}
#[doc = "GPIO"]
pub struct GPIOD {
  _marker: PhantomData<*const ()>,
}
unsafe impl Send for GPIOD {}
impl GPIOD {
  #[doc = r"Returns a pointer to the register block"]
  #[inline(always)]
  pub const fn ptr() -> *const gpioa::RegisterBlock {
    0x4802_00c0 as *const _
  }
}
impl Deref for GPIOD {
  type Target = gpioa::RegisterBlock;
  fn deref(&self) -> &Self::Target {
    unsafe { &*GPIOD::ptr() }
  }
}
#[no_mangle]
static mut DEVICE_PERIPHERALS: bool = false;
#[doc = r"All the peripherals"]
#[allow(non_snake_case)]
pub struct Peripherals {
  #[doc = "MSCM"]
  pub MSCM: MSCM,
  #[doc = "DMA0"]
  pub DMA0: DMA0,
  #[doc = "FB"]
  pub FB: FB,
  #[doc = "XRDC"]
  pub XRDC: XRDC,
  #[doc = "SEMA420"]
  pub SEMA420: SEMA420,
  #[doc = "SMC0"]
  pub SMC0: SMC0,
  #[doc = "DMAMUX0"]
  pub DMAMUX0: DMAMUX0,
  #[doc = "EWM"]
  pub EWM: EWM,
  #[doc = "FTFE"]
  pub FTFE: FTFE,
  #[doc = "LLWU0"]
  pub LLWU0: LLWU0,
  #[doc = "MUA"]
  pub MUA: MUA,
  #[doc = "SIM"]
  pub SIM: SIM,
  #[doc = "USBVREG"]
  pub USBVREG: USBVREG,
  #[doc = "SPM"]
  pub SPM: SPM,
  #[doc = "TRGMUX0"]
  pub TRGMUX0: TRGMUX0,
  #[doc = "WDOG0"]
  pub WDOG0: WDOG0,
  #[doc = "PCC0"]
  pub PCC0: PCC0,
  #[doc = "SCG"]
  pub SCG: SCG,
  #[doc = "CRC"]
  pub CRC: CRC,
  #[doc = "LPIT0"]
  pub LPIT0: LPIT0,
  #[doc = "RTC"]
  pub RTC: RTC,
  #[doc = "LPTMR0"]
  pub LPTMR0: LPTMR0,
  #[doc = "LPTMR1"]
  pub LPTMR1: LPTMR1,
  #[doc = "TSTMRA"]
  pub TSTMRA: TSTMRA,
  #[doc = "TPM0"]
  pub TPM0: TPM0,
  #[doc = "TPM1"]
  pub TPM1: TPM1,
  #[doc = "TPM2"]
  pub TPM2: TPM2,
  #[doc = "EMVSIM0"]
  pub EMVSIM0: EMVSIM0,
  #[doc = "FLEXIO0"]
  pub FLEXIO0: FLEXIO0,
  #[doc = "LPI2C0"]
  pub LPI2C0: LPI2C0,
  #[doc = "LPI2C1"]
  pub LPI2C1: LPI2C1,
  #[doc = "LPI2C2"]
  pub LPI2C2: LPI2C2,
  #[doc = "I2S0"]
  pub I2S0: I2S0,
  #[doc = "USDHC0"]
  pub USDHC0: USDHC0,
  #[doc = "LPSPI0"]
  pub LPSPI0: LPSPI0,
  #[doc = "LPSPI1"]
  pub LPSPI1: LPSPI1,
  #[doc = "LPSPI2"]
  pub LPSPI2: LPSPI2,
  #[doc = "LPUART0"]
  pub LPUART0: LPUART0,
  #[doc = "LPUART1"]
  pub LPUART1: LPUART1,
  #[doc = "LPUART2"]
  pub LPUART2: LPUART2,
  #[doc = "USB0"]
  pub USB0: USB0,
  #[doc = "PORTA"]
  pub PORTA: PORTA,
  #[doc = "PORTB"]
  pub PORTB: PORTB,
  #[doc = "PORTC"]
  pub PORTC: PORTC,
  #[doc = "PORTD"]
  pub PORTD: PORTD,
  #[doc = "ADC0"]
  pub ADC0: ADC0,
  #[doc = "LPCMP0"]
  pub LPCMP0: LPCMP0,
  #[doc = "LPDAC0"]
  pub LPDAC0: LPDAC0,
  #[doc = "VREF"]
  pub VREF: VREF,
  #[doc = "GPIOA"]
  pub GPIOA: GPIOA,
  #[doc = "GPIOE"]
  pub GPIOE: GPIOE,
  #[doc = "GPIOB"]
  pub GPIOB: GPIOB,
  #[doc = "GPIOC"]
  pub GPIOC: GPIOC,
  #[doc = "GPIOD"]
  pub GPIOD: GPIOD,
}
impl Peripherals {
  #[doc = r"Returns all the peripherals *once*"]
  #[inline]
  pub fn take() -> Option<Self> {
    riscv::interrupt::free(|_| {
      if unsafe { DEVICE_PERIPHERALS } {
        None
      } else {
        Some(unsafe { Peripherals::steal() })
      }
    })
  }
  #[doc = r"Unchecked version of `Peripherals::take`"]
  pub unsafe fn steal() -> Self {
    DEVICE_PERIPHERALS = true;
    Peripherals {
      MSCM: MSCM {
        _marker: PhantomData,
      },
      DMA0: DMA0 {
        _marker: PhantomData,
      },
      FB: FB {
        _marker: PhantomData,
      },
      XRDC: XRDC {
        _marker: PhantomData,
      },
      SEMA420: SEMA420 {
        _marker: PhantomData,
      },
      SMC0: SMC0 {
        _marker: PhantomData,
      },
      DMAMUX0: DMAMUX0 {
        _marker: PhantomData,
      },
      EWM: EWM {
        _marker: PhantomData,
      },
      FTFE: FTFE {
        _marker: PhantomData,
      },
      LLWU0: LLWU0 {
        _marker: PhantomData,
      },
      MUA: MUA {
        _marker: PhantomData,
      },
      SIM: SIM {
        _marker: PhantomData,
      },
      USBVREG: USBVREG {
        _marker: PhantomData,
      },
      SPM: SPM {
        _marker: PhantomData,
      },
      TRGMUX0: TRGMUX0 {
        _marker: PhantomData,
      },
      WDOG0: WDOG0 {
        _marker: PhantomData,
      },
      PCC0: PCC0 {
        _marker: PhantomData,
      },
      SCG: SCG {
        _marker: PhantomData,
      },
      CRC: CRC {
        _marker: PhantomData,
      },
      LPIT0: LPIT0 {
        _marker: PhantomData,
      },
      RTC: RTC {
        _marker: PhantomData,
      },
      LPTMR0: LPTMR0 {
        _marker: PhantomData,
      },
      LPTMR1: LPTMR1 {
        _marker: PhantomData,
      },
      TSTMRA: TSTMRA {
        _marker: PhantomData,
      },
      TPM0: TPM0 {
        _marker: PhantomData,
      },
      TPM1: TPM1 {
        _marker: PhantomData,
      },
      TPM2: TPM2 {
        _marker: PhantomData,
      },
      EMVSIM0: EMVSIM0 {
        _marker: PhantomData,
      },
      FLEXIO0: FLEXIO0 {
        _marker: PhantomData,
      },
      LPI2C0: LPI2C0 {
        _marker: PhantomData,
      },
      LPI2C1: LPI2C1 {
        _marker: PhantomData,
      },
      LPI2C2: LPI2C2 {
        _marker: PhantomData,
      },
      I2S0: I2S0 {
        _marker: PhantomData,
      },
      USDHC0: USDHC0 {
        _marker: PhantomData,
      },
      LPSPI0: LPSPI0 {
        _marker: PhantomData,
      },
      LPSPI1: LPSPI1 {
        _marker: PhantomData,
      },
      LPSPI2: LPSPI2 {
        _marker: PhantomData,
      },
      LPUART0: LPUART0 {
        _marker: PhantomData,
      },
      LPUART1: LPUART1 {
        _marker: PhantomData,
      },
      LPUART2: LPUART2 {
        _marker: PhantomData,
      },
      USB0: USB0 {
        _marker: PhantomData,
      },
      PORTA: PORTA {
        _marker: PhantomData,
      },
      PORTB: PORTB {
        _marker: PhantomData,
      },
      PORTC: PORTC {
        _marker: PhantomData,
      },
      PORTD: PORTD {
        _marker: PhantomData,
      },
      ADC0: ADC0 {
        _marker: PhantomData,
      },
      LPCMP0: LPCMP0 {
        _marker: PhantomData,
      },
      LPDAC0: LPDAC0 {
        _marker: PhantomData,
      },
      VREF: VREF {
        _marker: PhantomData,
      },
      GPIOA: GPIOA {
        _marker: PhantomData,
      },
      GPIOE: GPIOE {
        _marker: PhantomData,
      },
      GPIOB: GPIOB {
        _marker: PhantomData,
      },
      GPIOC: GPIOC {
        _marker: PhantomData,
      },
      GPIOD: GPIOD {
        _marker: PhantomData,
      },
    }
  }
}