#![doc = "Peripheral access API for MCXN947_CM33_CORE0 microcontrollers (generated using svd2rust v0.31.5 ( ))\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.31.5/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)]
#![no_std]
use core::marker::PhantomData;
use core::ops::Deref;
#[doc = r"Number available in the NVIC for configuring priority"]
pub const NVIC_PRIO_BITS: u8 = 3;
#[cfg(feature = "rt")]
pub use self::Interrupt as interrupt;
pub use cortex_m::peripheral::Peripherals as CorePeripherals;
pub use cortex_m::peripheral::{CBP, CPUID, DCB, DWT, FPB, FPU, ITM, MPU, NVIC, SCB, SYST, TPIU};
#[cfg(feature = "rt")]
pub use cortex_m_rt::interrupt;
#[allow(unused_imports)]
use generic::*;
#[doc = r"Common register and bit access and modify traits"]
pub mod generic;
#[cfg(feature = "rt")]
extern "C" {
fn EDMA_0_CH0();
fn EDMA_0_CH1();
fn EDMA_0_CH2();
fn EDMA_0_CH3();
fn EDMA_0_CH4();
fn EDMA_0_CH5();
fn EDMA_0_CH6();
fn EDMA_0_CH7();
fn EDMA_0_CH8();
fn EDMA_0_CH9();
fn EDMA_0_CH10();
fn EDMA_0_CH11();
fn EDMA_0_CH12();
fn EDMA_0_CH13();
fn EDMA_0_CH14();
fn EDMA_0_CH15();
fn GPIO00();
fn GPIO01();
fn GPIO10();
fn GPIO11();
fn GPIO20();
fn GPIO21();
fn GPIO30();
fn GPIO31();
fn GPIO40();
fn GPIO41();
fn GPIO50();
fn GPIO51();
fn UTICK0();
fn MRT0();
fn CTIMER0();
fn CTIMER1();
fn SCT0();
fn CTIMER2();
fn LP_FLEXCOMM0();
fn LP_FLEXCOMM1();
fn LP_FLEXCOMM2();
fn LP_FLEXCOMM3();
fn LP_FLEXCOMM4();
fn LP_FLEXCOMM5();
fn LP_FLEXCOMM6();
fn LP_FLEXCOMM7();
fn LP_FLEXCOMM8();
fn LP_FLEXCOMM9();
fn ADC0();
fn ADC1();
fn PINT0();
fn PDM_EVENT();
fn USB0_FS();
fn USB0_DCD();
fn RTC();
fn SMARTDMA();
fn MAILBOX();
fn CTIMER3();
fn CTIMER4();
fn OS_EVENT();
fn FLEXSPI0();
fn SAI0();
fn SAI1();
fn USDHC0();
fn CAN0();
fn CAN1();
fn USB1_HS_PHY();
fn USB1_HS();
fn SEC_HYPERVISOR_CALL();
fn PLU();
fn FREQME();
fn SEC_VIO();
fn ELS();
fn PKC();
fn PUF();
fn PQ();
fn EDMA_1_CH0();
fn EDMA_1_CH1();
fn EDMA_1_CH2();
fn EDMA_1_CH3();
fn EDMA_1_CH4();
fn EDMA_1_CH5();
fn EDMA_1_CH6();
fn EDMA_1_CH7();
fn EDMA_1_CH8();
fn EDMA_1_CH9();
fn EDMA_1_CH10();
fn EDMA_1_CH11();
fn EDMA_1_CH12();
fn EDMA_1_CH13();
fn EDMA_1_CH14();
fn EDMA_1_CH15();
fn CDOG0();
fn CDOG1();
fn I3C0();
fn I3C1();
fn GDET();
fn VBAT0();
fn EWM0();
fn TSI_END_OF_SCAN();
fn TSI_OUT_OF_SCAN();
fn EMVSIM0();
fn EMVSIM1();
fn FLEXIO();
fn DAC0();
fn DAC1();
fn DAC2();
fn HSCMP0();
fn HSCMP1();
fn HSCMP2();
fn FLEXPWM0_RELOAD_ERROR();
fn FLEXPWM0_FAULT();
fn FLEXPWM0_SUBMODULE0();
fn FLEXPWM0_SUBMODULE1();
fn FLEXPWM0_SUBMODULE2();
fn FLEXPWM0_SUBMODULE3();
fn FLEXPWM1_RELOAD_ERROR();
fn FLEXPWM1_FAULT();
fn FLEXPWM1_SUBMODULE0();
fn FLEXPWM1_SUBMODULE1();
fn FLEXPWM1_SUBMODULE2();
fn FLEXPWM1_SUBMODULE3();
fn ENC0_COMPARE();
fn ENC0_HOME();
fn ENC0_WDG_SAB();
fn ENC0_IDX();
fn ENC1_COMPARE();
fn ENC1_HOME();
fn ENC1_WDG_SAB();
fn ENC1_IDX();
fn ITRC0();
fn BSP32();
fn ELS_ERR();
fn PKC_ERR();
fn ERM_SINGLE_BIT_ERROR();
fn ERM_MULTI_BIT_ERROR();
fn FMU0();
fn ETHERNET();
fn ETHERNET_PMT();
fn ETHERNET_MACLP();
fn SINC_FILTER();
fn LPTMR0();
fn LPTMR1();
fn SCG();
fn SPC();
fn WUU();
fn PORT_EFT();
fn ETB0();
fn SM3();
fn TRNG0();
fn WWDT0();
fn WWDT1();
fn CMC0();
fn CTI0();
}
#[doc(hidden)]
#[repr(C)]
pub union Vector {
_handler: unsafe extern "C" fn(),
_reserved: u32,
}
#[cfg(feature = "rt")]
#[doc(hidden)]
#[link_section = ".vector_table.interrupts"]
#[no_mangle]
pub static __INTERRUPTS: [Vector; 156] = [
Vector { _reserved: 0 },
Vector {
_handler: EDMA_0_CH0,
},
Vector {
_handler: EDMA_0_CH1,
},
Vector {
_handler: EDMA_0_CH2,
},
Vector {
_handler: EDMA_0_CH3,
},
Vector {
_handler: EDMA_0_CH4,
},
Vector {
_handler: EDMA_0_CH5,
},
Vector {
_handler: EDMA_0_CH6,
},
Vector {
_handler: EDMA_0_CH7,
},
Vector {
_handler: EDMA_0_CH8,
},
Vector {
_handler: EDMA_0_CH9,
},
Vector {
_handler: EDMA_0_CH10,
},
Vector {
_handler: EDMA_0_CH11,
},
Vector {
_handler: EDMA_0_CH12,
},
Vector {
_handler: EDMA_0_CH13,
},
Vector {
_handler: EDMA_0_CH14,
},
Vector {
_handler: EDMA_0_CH15,
},
Vector { _handler: GPIO00 },
Vector { _handler: GPIO01 },
Vector { _handler: GPIO10 },
Vector { _handler: GPIO11 },
Vector { _handler: GPIO20 },
Vector { _handler: GPIO21 },
Vector { _handler: GPIO30 },
Vector { _handler: GPIO31 },
Vector { _handler: GPIO40 },
Vector { _handler: GPIO41 },
Vector { _handler: GPIO50 },
Vector { _handler: GPIO51 },
Vector { _handler: UTICK0 },
Vector { _handler: MRT0 },
Vector { _handler: CTIMER0 },
Vector { _handler: CTIMER1 },
Vector { _handler: SCT0 },
Vector { _handler: CTIMER2 },
Vector {
_handler: LP_FLEXCOMM0,
},
Vector {
_handler: LP_FLEXCOMM1,
},
Vector {
_handler: LP_FLEXCOMM2,
},
Vector {
_handler: LP_FLEXCOMM3,
},
Vector {
_handler: LP_FLEXCOMM4,
},
Vector {
_handler: LP_FLEXCOMM5,
},
Vector {
_handler: LP_FLEXCOMM6,
},
Vector {
_handler: LP_FLEXCOMM7,
},
Vector {
_handler: LP_FLEXCOMM8,
},
Vector {
_handler: LP_FLEXCOMM9,
},
Vector { _handler: ADC0 },
Vector { _handler: ADC1 },
Vector { _handler: PINT0 },
Vector {
_handler: PDM_EVENT,
},
Vector { _reserved: 0 },
Vector { _handler: USB0_FS },
Vector { _handler: USB0_DCD },
Vector { _handler: RTC },
Vector { _handler: SMARTDMA },
Vector { _handler: MAILBOX },
Vector { _handler: CTIMER3 },
Vector { _handler: CTIMER4 },
Vector { _handler: OS_EVENT },
Vector { _handler: FLEXSPI0 },
Vector { _handler: SAI0 },
Vector { _handler: SAI1 },
Vector { _handler: USDHC0 },
Vector { _handler: CAN0 },
Vector { _handler: CAN1 },
Vector { _reserved: 0 },
Vector { _reserved: 0 },
Vector {
_handler: USB1_HS_PHY,
},
Vector { _handler: USB1_HS },
Vector {
_handler: SEC_HYPERVISOR_CALL,
},
Vector { _reserved: 0 },
Vector { _handler: PLU },
Vector { _handler: FREQME },
Vector { _handler: SEC_VIO },
Vector { _handler: ELS },
Vector { _handler: PKC },
Vector { _handler: PUF },
Vector { _handler: PQ },
Vector {
_handler: EDMA_1_CH0,
},
Vector {
_handler: EDMA_1_CH1,
},
Vector {
_handler: EDMA_1_CH2,
},
Vector {
_handler: EDMA_1_CH3,
},
Vector {
_handler: EDMA_1_CH4,
},
Vector {
_handler: EDMA_1_CH5,
},
Vector {
_handler: EDMA_1_CH6,
},
Vector {
_handler: EDMA_1_CH7,
},
Vector {
_handler: EDMA_1_CH8,
},
Vector {
_handler: EDMA_1_CH9,
},
Vector {
_handler: EDMA_1_CH10,
},
Vector {
_handler: EDMA_1_CH11,
},
Vector {
_handler: EDMA_1_CH12,
},
Vector {
_handler: EDMA_1_CH13,
},
Vector {
_handler: EDMA_1_CH14,
},
Vector {
_handler: EDMA_1_CH15,
},
Vector { _handler: CDOG0 },
Vector { _handler: CDOG1 },
Vector { _handler: I3C0 },
Vector { _handler: I3C1 },
Vector { _reserved: 0 },
Vector { _handler: GDET },
Vector { _handler: VBAT0 },
Vector { _handler: EWM0 },
Vector {
_handler: TSI_END_OF_SCAN,
},
Vector {
_handler: TSI_OUT_OF_SCAN,
},
Vector { _handler: EMVSIM0 },
Vector { _handler: EMVSIM1 },
Vector { _handler: FLEXIO },
Vector { _handler: DAC0 },
Vector { _handler: DAC1 },
Vector { _handler: DAC2 },
Vector { _handler: HSCMP0 },
Vector { _handler: HSCMP1 },
Vector { _handler: HSCMP2 },
Vector {
_handler: FLEXPWM0_RELOAD_ERROR,
},
Vector {
_handler: FLEXPWM0_FAULT,
},
Vector {
_handler: FLEXPWM0_SUBMODULE0,
},
Vector {
_handler: FLEXPWM0_SUBMODULE1,
},
Vector {
_handler: FLEXPWM0_SUBMODULE2,
},
Vector {
_handler: FLEXPWM0_SUBMODULE3,
},
Vector {
_handler: FLEXPWM1_RELOAD_ERROR,
},
Vector {
_handler: FLEXPWM1_FAULT,
},
Vector {
_handler: FLEXPWM1_SUBMODULE0,
},
Vector {
_handler: FLEXPWM1_SUBMODULE1,
},
Vector {
_handler: FLEXPWM1_SUBMODULE2,
},
Vector {
_handler: FLEXPWM1_SUBMODULE3,
},
Vector {
_handler: ENC0_COMPARE,
},
Vector {
_handler: ENC0_HOME,
},
Vector {
_handler: ENC0_WDG_SAB,
},
Vector { _handler: ENC0_IDX },
Vector {
_handler: ENC1_COMPARE,
},
Vector {
_handler: ENC1_HOME,
},
Vector {
_handler: ENC1_WDG_SAB,
},
Vector { _handler: ENC1_IDX },
Vector { _handler: ITRC0 },
Vector { _handler: BSP32 },
Vector { _handler: ELS_ERR },
Vector { _handler: PKC_ERR },
Vector {
_handler: ERM_SINGLE_BIT_ERROR,
},
Vector {
_handler: ERM_MULTI_BIT_ERROR,
},
Vector { _handler: FMU0 },
Vector { _handler: ETHERNET },
Vector {
_handler: ETHERNET_PMT,
},
Vector {
_handler: ETHERNET_MACLP,
},
Vector {
_handler: SINC_FILTER,
},
Vector { _handler: LPTMR0 },
Vector { _handler: LPTMR1 },
Vector { _handler: SCG },
Vector { _handler: SPC },
Vector { _handler: WUU },
Vector { _handler: PORT_EFT },
Vector { _handler: ETB0 },
Vector { _handler: SM3 },
Vector { _handler: TRNG0 },
Vector { _handler: WWDT0 },
Vector { _handler: WWDT1 },
Vector { _handler: CMC0 },
Vector { _handler: CTI0 },
];
#[doc = r"Enumeration of all the interrupts."]
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
#[repr(u16)]
pub enum Interrupt {
#[doc = "1 - EDMA_0_CH0"]
EDMA_0_CH0 = 1,
#[doc = "2 - EDMA_0_CH1"]
EDMA_0_CH1 = 2,
#[doc = "3 - EDMA_0_CH2"]
EDMA_0_CH2 = 3,
#[doc = "4 - EDMA_0_CH3"]
EDMA_0_CH3 = 4,
#[doc = "5 - EDMA_0_CH4"]
EDMA_0_CH4 = 5,
#[doc = "6 - EDMA_0_CH5"]
EDMA_0_CH5 = 6,
#[doc = "7 - EDMA_0_CH6"]
EDMA_0_CH6 = 7,
#[doc = "8 - EDMA_0_CH7"]
EDMA_0_CH7 = 8,
#[doc = "9 - EDMA_0_CH8"]
EDMA_0_CH8 = 9,
#[doc = "10 - EDMA_0_CH9"]
EDMA_0_CH9 = 10,
#[doc = "11 - EDMA_0_CH10"]
EDMA_0_CH10 = 11,
#[doc = "12 - EDMA_0_CH11"]
EDMA_0_CH11 = 12,
#[doc = "13 - EDMA_0_CH12"]
EDMA_0_CH12 = 13,
#[doc = "14 - EDMA_0_CH13"]
EDMA_0_CH13 = 14,
#[doc = "15 - EDMA_0_CH14"]
EDMA_0_CH14 = 15,
#[doc = "16 - EDMA_0_CH15"]
EDMA_0_CH15 = 16,
#[doc = "17 - GPIO00"]
GPIO00 = 17,
#[doc = "18 - GPIO01"]
GPIO01 = 18,
#[doc = "19 - GPIO10"]
GPIO10 = 19,
#[doc = "20 - GPIO11"]
GPIO11 = 20,
#[doc = "21 - GPIO20"]
GPIO20 = 21,
#[doc = "22 - GPIO21"]
GPIO21 = 22,
#[doc = "23 - GPIO30"]
GPIO30 = 23,
#[doc = "24 - GPIO31"]
GPIO31 = 24,
#[doc = "25 - GPIO40"]
GPIO40 = 25,
#[doc = "26 - GPIO41"]
GPIO41 = 26,
#[doc = "27 - GPIO50"]
GPIO50 = 27,
#[doc = "28 - GPIO51"]
GPIO51 = 28,
#[doc = "29 - UTICK0"]
UTICK0 = 29,
#[doc = "30 - MRT0"]
MRT0 = 30,
#[doc = "31 - CTIMER0"]
CTIMER0 = 31,
#[doc = "32 - CTIMER1"]
CTIMER1 = 32,
#[doc = "33 - SCT0"]
SCT0 = 33,
#[doc = "34 - CTIMER2"]
CTIMER2 = 34,
#[doc = "35 - LP_FLEXCOMM0"]
LP_FLEXCOMM0 = 35,
#[doc = "36 - LP_FLEXCOMM1"]
LP_FLEXCOMM1 = 36,
#[doc = "37 - LP_FLEXCOMM2"]
LP_FLEXCOMM2 = 37,
#[doc = "38 - LP_FLEXCOMM3"]
LP_FLEXCOMM3 = 38,
#[doc = "39 - LP_FLEXCOMM4"]
LP_FLEXCOMM4 = 39,
#[doc = "40 - LP_FLEXCOMM5"]
LP_FLEXCOMM5 = 40,
#[doc = "41 - LP_FLEXCOMM6"]
LP_FLEXCOMM6 = 41,
#[doc = "42 - LP_FLEXCOMM7"]
LP_FLEXCOMM7 = 42,
#[doc = "43 - LP_FLEXCOMM8"]
LP_FLEXCOMM8 = 43,
#[doc = "44 - LP_FLEXCOMM9"]
LP_FLEXCOMM9 = 44,
#[doc = "45 - ADC0"]
ADC0 = 45,
#[doc = "46 - ADC1"]
ADC1 = 46,
#[doc = "47 - PINT0"]
PINT0 = 47,
#[doc = "48 - PDM_EVENT"]
PDM_EVENT = 48,
#[doc = "50 - USB0_FS"]
USB0_FS = 50,
#[doc = "51 - USB0_DCD"]
USB0_DCD = 51,
#[doc = "52 - RTC"]
RTC = 52,
#[doc = "53 - SMARTDMA"]
SMARTDMA = 53,
#[doc = "54 - MAILBOX"]
MAILBOX = 54,
#[doc = "55 - CTIMER3"]
CTIMER3 = 55,
#[doc = "56 - CTIMER4"]
CTIMER4 = 56,
#[doc = "57 - OS_EVENT"]
OS_EVENT = 57,
#[doc = "58 - FLEXSPI0"]
FLEXSPI0 = 58,
#[doc = "59 - SAI0"]
SAI0 = 59,
#[doc = "60 - SAI1"]
SAI1 = 60,
#[doc = "61 - USDHC0"]
USDHC0 = 61,
#[doc = "62 - CAN0"]
CAN0 = 62,
#[doc = "63 - CAN1"]
CAN1 = 63,
#[doc = "66 - USB1_HS_PHY"]
USB1_HS_PHY = 66,
#[doc = "67 - USB1_HS"]
USB1_HS = 67,
#[doc = "68 - SEC_HYPERVISOR_CALL"]
SEC_HYPERVISOR_CALL = 68,
#[doc = "70 - PLU"]
PLU = 70,
#[doc = "71 - Freqme"]
FREQME = 71,
#[doc = "72 - SEC_VIO"]
SEC_VIO = 72,
#[doc = "73 - ELS"]
ELS = 73,
#[doc = "74 - PKC"]
PKC = 74,
#[doc = "75 - PUF"]
PUF = 75,
#[doc = "76 - PQ"]
PQ = 76,
#[doc = "77 - EDMA_1_CH0"]
EDMA_1_CH0 = 77,
#[doc = "78 - EDMA_1_CH1"]
EDMA_1_CH1 = 78,
#[doc = "79 - EDMA_1_CH2"]
EDMA_1_CH2 = 79,
#[doc = "80 - EDMA_1_CH3"]
EDMA_1_CH3 = 80,
#[doc = "81 - EDMA_1_CH4"]
EDMA_1_CH4 = 81,
#[doc = "82 - EDMA_1_CH5"]
EDMA_1_CH5 = 82,
#[doc = "83 - EDMA_1_CH6"]
EDMA_1_CH6 = 83,
#[doc = "84 - EDMA_1_CH7"]
EDMA_1_CH7 = 84,
#[doc = "85 - EDMA_1_CH8"]
EDMA_1_CH8 = 85,
#[doc = "86 - EDMA_1_CH9"]
EDMA_1_CH9 = 86,
#[doc = "87 - EDMA_1_CH10"]
EDMA_1_CH10 = 87,
#[doc = "88 - EDMA_1_CH11"]
EDMA_1_CH11 = 88,
#[doc = "89 - EDMA_1_CH12"]
EDMA_1_CH12 = 89,
#[doc = "90 - EDMA_1_CH13"]
EDMA_1_CH13 = 90,
#[doc = "91 - EDMA_1_CH14"]
EDMA_1_CH14 = 91,
#[doc = "92 - EDMA_1_CH15"]
EDMA_1_CH15 = 92,
#[doc = "93 - CDOG0"]
CDOG0 = 93,
#[doc = "94 - CDOG1"]
CDOG1 = 94,
#[doc = "95 - I3C0"]
I3C0 = 95,
#[doc = "96 - I3C1"]
I3C1 = 96,
#[doc = "98 - GDET"]
GDET = 98,
#[doc = "99 - VBAT0"]
VBAT0 = 99,
#[doc = "100 - EWM0"]
EWM0 = 100,
#[doc = "101 - TSI_END_OF_SCAN"]
TSI_END_OF_SCAN = 101,
#[doc = "102 - TSI_OUT_OF_SCAN"]
TSI_OUT_OF_SCAN = 102,
#[doc = "103 - EMVSIM0"]
EMVSIM0 = 103,
#[doc = "104 - EMVSIM1"]
EMVSIM1 = 104,
#[doc = "105 - FLEXIO"]
FLEXIO = 105,
#[doc = "106 - DAC0"]
DAC0 = 106,
#[doc = "107 - DAC1"]
DAC1 = 107,
#[doc = "108 - DAC2"]
DAC2 = 108,
#[doc = "109 - HSCMP0"]
HSCMP0 = 109,
#[doc = "110 - HSCMP1"]
HSCMP1 = 110,
#[doc = "111 - HSCMP2"]
HSCMP2 = 111,
#[doc = "112 - FLEXPWM0_RELOAD_ERROR"]
FLEXPWM0_RELOAD_ERROR = 112,
#[doc = "113 - FLEXPWM0_FAULT"]
FLEXPWM0_FAULT = 113,
#[doc = "114 - FLEXPWM0_SUBMODULE0"]
FLEXPWM0_SUBMODULE0 = 114,
#[doc = "115 - FLEXPWM0_SUBMODULE1"]
FLEXPWM0_SUBMODULE1 = 115,
#[doc = "116 - FLEXPWM0_SUBMODULE2"]
FLEXPWM0_SUBMODULE2 = 116,
#[doc = "117 - FLEXPWM0_SUBMODULE3"]
FLEXPWM0_SUBMODULE3 = 117,
#[doc = "118 - FLEXPWM1_RELOAD_ERROR"]
FLEXPWM1_RELOAD_ERROR = 118,
#[doc = "119 - FLEXPWM1_FAULT"]
FLEXPWM1_FAULT = 119,
#[doc = "120 - FLEXPWM1_SUBMODULE0"]
FLEXPWM1_SUBMODULE0 = 120,
#[doc = "121 - FLEXPWM1_SUBMODULE1"]
FLEXPWM1_SUBMODULE1 = 121,
#[doc = "122 - FLEXPWM1_SUBMODULE2"]
FLEXPWM1_SUBMODULE2 = 122,
#[doc = "123 - FLEXPWM1_SUBMODULE3"]
FLEXPWM1_SUBMODULE3 = 123,
#[doc = "124 - ENC0_COMPARE"]
ENC0_COMPARE = 124,
#[doc = "125 - ENC0_HOME"]
ENC0_HOME = 125,
#[doc = "126 - ENC0_WDG_SAB"]
ENC0_WDG_SAB = 126,
#[doc = "127 - ENC0_IDX"]
ENC0_IDX = 127,
#[doc = "128 - ENC1_COMPARE"]
ENC1_COMPARE = 128,
#[doc = "129 - ENC1_HOME"]
ENC1_HOME = 129,
#[doc = "130 - ENC1_WDG_SAB"]
ENC1_WDG_SAB = 130,
#[doc = "131 - ENC1_IDX"]
ENC1_IDX = 131,
#[doc = "132 - ITRC0"]
ITRC0 = 132,
#[doc = "133 - BSP32"]
BSP32 = 133,
#[doc = "134 - ELS_ERR"]
ELS_ERR = 134,
#[doc = "135 - PKC_ERR"]
PKC_ERR = 135,
#[doc = "136 - ERM_SINGLE_BIT_ERROR"]
ERM_SINGLE_BIT_ERROR = 136,
#[doc = "137 - ERM_MULTI_BIT_ERROR"]
ERM_MULTI_BIT_ERROR = 137,
#[doc = "138 - FMU0"]
FMU0 = 138,
#[doc = "139 - ETHERNET"]
ETHERNET = 139,
#[doc = "140 - ETHERNET_PMT"]
ETHERNET_PMT = 140,
#[doc = "141 - ETHERNET_MACLP"]
ETHERNET_MACLP = 141,
#[doc = "142 - SINC_FILTER"]
SINC_FILTER = 142,
#[doc = "143 - LPTMR0"]
LPTMR0 = 143,
#[doc = "144 - LPTMR1"]
LPTMR1 = 144,
#[doc = "145 - SCG"]
SCG = 145,
#[doc = "146 - SPC"]
SPC = 146,
#[doc = "147 - WUU"]
WUU = 147,
#[doc = "148 - PORT_EFT"]
PORT_EFT = 148,
#[doc = "149 - ETB0"]
ETB0 = 149,
#[doc = "150 - SM3"]
SM3 = 150,
#[doc = "151 - TRNG0"]
TRNG0 = 151,
#[doc = "152 - WWDT0"]
WWDT0 = 152,
#[doc = "153 - WWDT1"]
WWDT1 = 153,
#[doc = "154 - CMC0"]
CMC0 = 154,
#[doc = "155 - CTI0"]
CTI0 = 155,
}
unsafe impl cortex_m::interrupt::InterruptNumber for Interrupt {
#[inline(always)]
fn number(self) -> u16 {
self as u16
}
}
#[doc = "SYSCON"]
pub struct SYSCON0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SYSCON0 {}
impl SYSCON0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const syscon0::RegisterBlock = 0x4000_0000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const syscon0::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 SYSCON0 {
type Target = syscon0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for SYSCON0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("SYSCON0").finish()
}
}
#[doc = "SYSCON"]
pub mod syscon0;
#[doc = "Pin Interrupts and Pattern Match"]
pub struct PINT0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PINT0 {}
impl PINT0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const pint0::RegisterBlock = 0x4000_4000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const pint0::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 PINT0 {
type Target = pint0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for PINT0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("PINT0").finish()
}
}
#[doc = "Pin Interrupts and Pattern Match"]
pub mod pint0;
#[doc = "INPUTMUX"]
pub struct INPUTMUX0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for INPUTMUX0 {}
impl INPUTMUX0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const inputmux0::RegisterBlock = 0x4000_6000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const inputmux0::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 INPUTMUX0 {
type Target = inputmux0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for INPUTMUX0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("INPUTMUX0").finish()
}
}
#[doc = "INPUTMUX"]
pub mod inputmux0;
#[doc = "CTIMER"]
pub struct CTIMER0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for CTIMER0 {}
impl CTIMER0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const ctimer0::RegisterBlock = 0x4000_c000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const ctimer0::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 CTIMER0 {
type Target = ctimer0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for CTIMER0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("CTIMER0").finish()
}
}
#[doc = "CTIMER"]
pub mod ctimer0;
#[doc = "CTIMER"]
pub struct CTIMER1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for CTIMER1 {}
impl CTIMER1 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const ctimer0::RegisterBlock = 0x4000_d000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const ctimer0::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 CTIMER1 {
type Target = ctimer0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for CTIMER1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("CTIMER1").finish()
}
}
#[doc = "CTIMER"]
pub use self::ctimer0 as ctimer1;
#[doc = "CTIMER"]
pub struct CTIMER2 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for CTIMER2 {}
impl CTIMER2 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const ctimer0::RegisterBlock = 0x4000_e000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const ctimer0::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 CTIMER2 {
type Target = ctimer0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for CTIMER2 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("CTIMER2").finish()
}
}
#[doc = "CTIMER"]
pub use self::ctimer0 as ctimer2;
#[doc = "CTIMER"]
pub struct CTIMER3 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for CTIMER3 {}
impl CTIMER3 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const ctimer0::RegisterBlock = 0x4000_f000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const ctimer0::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 CTIMER3 {
type Target = ctimer0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for CTIMER3 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("CTIMER3").finish()
}
}
#[doc = "CTIMER"]
pub use self::ctimer0 as ctimer3;
#[doc = "CTIMER"]
pub struct CTIMER4 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for CTIMER4 {}
impl CTIMER4 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const ctimer0::RegisterBlock = 0x4001_0000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const ctimer0::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 CTIMER4 {
type Target = ctimer0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for CTIMER4 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("CTIMER4").finish()
}
}
#[doc = "CTIMER"]
pub use self::ctimer0 as ctimer4;
#[doc = "FREQME"]
pub struct FREQME0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for FREQME0 {}
impl FREQME0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const freqme0::RegisterBlock = 0x4001_1000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const freqme0::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 FREQME0 {
type Target = freqme0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for FREQME0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("FREQME0").finish()
}
}
#[doc = "FREQME"]
pub mod freqme0;
#[doc = "UTICK"]
pub struct UTICK0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for UTICK0 {}
impl UTICK0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const utick0::RegisterBlock = 0x4001_2000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const utick0::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 UTICK0 {
type Target = utick0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for UTICK0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("UTICK0").finish()
}
}
#[doc = "UTICK"]
pub mod utick0;
#[doc = "Multi-Rate Timer (MRT)"]
pub struct MRT0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for MRT0 {}
impl MRT0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const mrt0::RegisterBlock = 0x4001_3000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const mrt0::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 MRT0 {
type Target = mrt0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for MRT0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("MRT0").finish()
}
}
#[doc = "Multi-Rate Timer (MRT)"]
pub mod mrt0;
#[doc = "WWDT"]
pub struct WWDT0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for WWDT0 {}
impl WWDT0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const wwdt0::RegisterBlock = 0x4001_6000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const wwdt0::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 WWDT0 {
type Target = wwdt0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for WWDT0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("WWDT0").finish()
}
}
#[doc = "WWDT"]
pub mod wwdt0;
#[doc = "WWDT"]
pub struct WWDT1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for WWDT1 {}
impl WWDT1 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const wwdt0::RegisterBlock = 0x4001_7000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const wwdt0::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 WWDT1 {
type Target = wwdt0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for WWDT1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("WWDT1").finish()
}
}
#[doc = "WWDT"]
pub use self::wwdt0 as wwdt1;
#[doc = "CACHE64_CTRL"]
pub struct CACHE64_CTRL0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for CACHE64_CTRL0 {}
impl CACHE64_CTRL0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const cache64_ctrl0::RegisterBlock = 0x4001_b000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const cache64_ctrl0::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 CACHE64_CTRL0 {
type Target = cache64_ctrl0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for CACHE64_CTRL0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("CACHE64_CTRL0").finish()
}
}
#[doc = "CACHE64_CTRL"]
pub mod cache64_ctrl0;
#[doc = "CACHE64_POLSEL"]
pub struct CACHE64_POLSEL0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for CACHE64_POLSEL0 {}
impl CACHE64_POLSEL0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const cache64_polsel0::RegisterBlock = 0x4001_b000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const cache64_polsel0::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 CACHE64_POLSEL0 {
type Target = cache64_polsel0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for CACHE64_POLSEL0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("CACHE64_POLSEL0").finish()
}
}
#[doc = "CACHE64_POLSEL"]
pub mod cache64_polsel0;
#[doc = "I3C"]
pub struct I3C0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for I3C0 {}
impl I3C0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const i3c0::RegisterBlock = 0x4002_1000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const i3c0::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 I3C0 {
type Target = i3c0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for I3C0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("I3C0").finish()
}
}
#[doc = "I3C"]
pub mod i3c0;
#[doc = "I3C"]
pub struct I3C1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for I3C1 {}
impl I3C1 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const i3c0::RegisterBlock = 0x4002_2000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const i3c0::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 I3C1 {
type Target = i3c0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for I3C1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("I3C1").finish()
}
}
#[doc = "I3C"]
pub use self::i3c0 as i3c1;
#[doc = "no description available"]
pub struct GDET0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for GDET0 {}
impl GDET0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const gdet0::RegisterBlock = 0x4002_4000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const gdet0::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 GDET0 {
type Target = gdet0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for GDET0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("GDET0").finish()
}
}
#[doc = "no description available"]
pub mod gdet0;
#[doc = "no description available"]
pub struct GDET1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for GDET1 {}
impl GDET1 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const gdet0::RegisterBlock = 0x4002_5000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const gdet0::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 GDET1 {
type Target = gdet0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for GDET1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("GDET1").finish()
}
}
#[doc = "no description available"]
pub use self::gdet0 as gdet1;
#[doc = "Intrusion and Tamper Response Controller"]
pub struct ITRC0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for ITRC0 {}
impl ITRC0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const itrc0::RegisterBlock = 0x4002_6000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const itrc0::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 ITRC0 {
type Target = itrc0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for ITRC0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("ITRC0").finish()
}
}
#[doc = "Intrusion and Tamper Response Controller"]
pub mod itrc0;
#[doc = "no description available"]
pub struct PKC0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PKC0 {}
impl PKC0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const pkc0::RegisterBlock = 0x4002_b000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const pkc0::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 PKC0 {
type Target = pkc0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for PKC0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("PKC0").finish()
}
}
#[doc = "no description available"]
pub mod pkc0;
#[doc = "PUF"]
pub struct PUF {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PUF {}
impl PUF {
#[doc = r"Pointer to the register block"]
pub const PTR: *const puf::RegisterBlock = 0x4002_c000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const puf::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 PUF {
type Target = puf::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for PUF {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("PUF").finish()
}
}
#[doc = "PUF"]
pub mod puf;
#[doc = "PUF Key Context Management"]
pub struct PUF_CTRL {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PUF_CTRL {}
impl PUF_CTRL {
#[doc = r"Pointer to the register block"]
pub const PTR: *const puf_ctrl::RegisterBlock = 0x4002_c000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const puf_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 PUF_CTRL {
type Target = puf_ctrl::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for PUF_CTRL {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("PUF_CTRL").finish()
}
}
#[doc = "PUF Key Context Management"]
pub mod puf_ctrl;
#[doc = "SAFO_SM3_SGI"]
pub struct SM3_0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SM3_0 {}
impl SM3_0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const sm3_0::RegisterBlock = 0x4003_1000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const sm3_0::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 SM3_0 {
type Target = sm3_0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for SM3_0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("SM3_0").finish()
}
}
#[doc = "SAFO_SM3_SGI"]
pub mod sm3_0;
#[doc = "CoolFlux BSP32"]
pub struct BSP32_0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for BSP32_0 {}
impl BSP32_0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const bsp32_0::RegisterBlock = 0x4003_2000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const bsp32_0::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 BSP32_0 {
type Target = bsp32_0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for BSP32_0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("BSP32_0").finish()
}
}
#[doc = "CoolFlux BSP32"]
pub mod bsp32_0;
#[doc = "SmartDMA"]
pub struct SMARTDMA0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SMARTDMA0 {}
impl SMARTDMA0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const smartdma0::RegisterBlock = 0x4003_3000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const smartdma0::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 SMARTDMA0 {
type Target = smartdma0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for SMARTDMA0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("SMARTDMA0").finish()
}
}
#[doc = "SmartDMA"]
pub mod smartdma0;
#[doc = "Programmable Logic Unit (PLU)"]
pub struct PLU0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PLU0 {}
impl PLU0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const plu0::RegisterBlock = 0x4003_4000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const plu0::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 PLU0 {
type Target = plu0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for PLU0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("PLU0").finish()
}
}
#[doc = "Programmable Logic Unit (PLU)"]
pub mod plu0;
#[doc = "PORT"]
pub struct PORT0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PORT0 {}
impl PORT0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const port0::RegisterBlock = 0x4011_6000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const port0::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 PORT0 {
type Target = port0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for PORT0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("PORT0").finish()
}
}
#[doc = "PORT"]
pub mod port0;
#[doc = "PORT"]
pub struct PORT5 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PORT5 {}
impl PORT5 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const port0::RegisterBlock = 0x4004_2000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const port0::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 PORT5 {
type Target = port0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for PORT5 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("PORT5").finish()
}
}
#[doc = "PORT"]
pub use self::port0 as port5;
#[doc = "Flash"]
pub struct FMU0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for FMU0 {}
impl FMU0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const fmu0::RegisterBlock = 0x4004_3000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const fmu0::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 FMU0 {
type Target = fmu0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for FMU0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("FMU0").finish()
}
}
#[doc = "Flash"]
pub mod fmu0;
#[doc = "SCG"]
pub struct SCG0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SCG0 {}
impl SCG0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const scg0::RegisterBlock = 0x4004_4000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const scg0::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 SCG0 {
type Target = scg0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for SCG0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("SCG0").finish()
}
}
#[doc = "SCG"]
pub mod scg0;
#[doc = "SPC"]
pub struct SPC0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SPC0 {}
impl SPC0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const spc0::RegisterBlock = 0x4004_5000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const spc0::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 SPC0 {
type Target = spc0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for SPC0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("SPC0").finish()
}
}
#[doc = "SPC"]
pub mod spc0;
#[doc = "WUU"]
pub struct WUU0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for WUU0 {}
impl WUU0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const wuu0::RegisterBlock = 0x4004_6000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const wuu0::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 WUU0 {
type Target = wuu0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for WUU0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("WUU0").finish()
}
}
#[doc = "WUU"]
pub mod wuu0;
#[doc = "CMC"]
pub struct CMC0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for CMC0 {}
impl CMC0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const cmc0::RegisterBlock = 0x4004_8000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const cmc0::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 CMC0 {
type Target = cmc0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for CMC0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("CMC0").finish()
}
}
#[doc = "CMC"]
pub mod cmc0;
#[doc = "OSTIMER"]
pub struct OSTIMER0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for OSTIMER0 {}
impl OSTIMER0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const ostimer0::RegisterBlock = 0x4004_9000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const ostimer0::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 OSTIMER0 {
type Target = ostimer0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for OSTIMER0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("OSTIMER0").finish()
}
}
#[doc = "OSTIMER"]
pub mod ostimer0;
#[doc = "LPTMR"]
pub struct LPTMR0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for LPTMR0 {}
impl LPTMR0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const lptmr0::RegisterBlock = 0x4004_a000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const lptmr0::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 LPTMR0 {
type Target = lptmr0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for LPTMR0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("LPTMR0").finish()
}
}
#[doc = "LPTMR"]
pub mod lptmr0;
#[doc = "LPTMR"]
pub struct LPTMR1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for LPTMR1 {}
impl LPTMR1 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const lptmr0::RegisterBlock = 0x4004_b000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const lptmr0::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 LPTMR1 {
type Target = lptmr0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for LPTMR1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("LPTMR1").finish()
}
}
#[doc = "LPTMR"]
pub use self::lptmr0 as lptmr1;
#[doc = "RTC"]
pub struct RTC0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for RTC0 {}
impl RTC0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const rtc0::RegisterBlock = 0x4004_c000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const rtc0::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 RTC0 {
type Target = rtc0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for RTC0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("RTC0").finish()
}
}
#[doc = "RTC"]
pub mod rtc0;
#[doc = "RTC_SUBSYSTEM"]
pub struct RTC_SUBSYSTEM0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for RTC_SUBSYSTEM0 {}
impl RTC_SUBSYSTEM0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const rtc_subsystem0::RegisterBlock = 0x4004_c000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const rtc_subsystem0::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_SUBSYSTEM0 {
type Target = rtc_subsystem0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for RTC_SUBSYSTEM0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("RTC_SUBSYSTEM0").finish()
}
}
#[doc = "RTC_SUBSYSTEM"]
pub mod rtc_subsystem0;
#[doc = "TSI"]
pub struct TSI0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for TSI0 {}
impl TSI0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const tsi0::RegisterBlock = 0x4005_0000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const tsi0::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 TSI0 {
type Target = tsi0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for TSI0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("TSI0").finish()
}
}
#[doc = "TSI"]
pub mod tsi0;
#[doc = "LPCMP"]
pub struct CMP0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for CMP0 {}
impl CMP0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const cmp0::RegisterBlock = 0x4005_1000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const cmp0::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 CMP0 {
type Target = cmp0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for CMP0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("CMP0").finish()
}
}
#[doc = "LPCMP"]
pub mod cmp0;
#[doc = "LPCMP"]
pub struct CMP1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for CMP1 {}
impl CMP1 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const cmp0::RegisterBlock = 0x4005_2000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const cmp0::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 CMP1 {
type Target = cmp0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for CMP1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("CMP1").finish()
}
}
#[doc = "LPCMP"]
pub use self::cmp0 as cmp1;
#[doc = "LPCMP"]
pub struct CMP2 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for CMP2 {}
impl CMP2 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const cmp0::RegisterBlock = 0x4005_3000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const cmp0::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 CMP2 {
type Target = cmp0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for CMP2 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("CMP2").finish()
}
}
#[doc = "LPCMP"]
pub use self::cmp0 as cmp2;
#[doc = "no description available"]
pub struct ELS {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for ELS {}
impl ELS {
#[doc = r"Pointer to the register block"]
pub const PTR: *const els::RegisterBlock = 0x4005_4000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const els::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 ELS {
type Target = els::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for ELS {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("ELS").finish()
}
}
#[doc = "no description available"]
pub mod els;
#[doc = "TDET"]
pub struct TDET0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for TDET0 {}
impl TDET0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const tdet0::RegisterBlock = 0x4005_8000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const tdet0::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 TDET0 {
type Target = tdet0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for TDET0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("TDET0").finish()
}
}
#[doc = "TDET"]
pub mod tdet0;
#[doc = "VBAT"]
pub struct VBAT0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for VBAT0 {}
impl VBAT0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const vbat0::RegisterBlock = 0x4005_9000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const vbat0::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 VBAT0 {
type Target = vbat0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for VBAT0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("VBAT0").finish()
}
}
#[doc = "VBAT"]
pub mod vbat0;
#[doc = "TRNG0"]
pub struct TRNG0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for TRNG0 {}
impl TRNG0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const trng0::RegisterBlock = 0x4005_a000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const trng0::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 TRNG0 {
type Target = trng0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for TRNG0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("TRNG0").finish()
}
}
#[doc = "TRNG0"]
pub mod trng0;
#[doc = "EIM"]
pub struct EIM0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for EIM0 {}
impl EIM0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const eim0::RegisterBlock = 0x4005_b000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const eim0::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 EIM0 {
type Target = eim0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for EIM0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("EIM0").finish()
}
}
#[doc = "EIM"]
pub mod eim0;
#[doc = "ERM"]
pub struct ERM0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for ERM0 {}
impl ERM0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const erm0::RegisterBlock = 0x4005_c000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const erm0::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 ERM0 {
type Target = erm0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for ERM0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("ERM0").finish()
}
}
#[doc = "ERM"]
pub mod erm0;
#[doc = "INTM"]
pub struct INTM0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for INTM0 {}
impl INTM0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const intm0::RegisterBlock = 0x4005_d000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const intm0::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 INTM0 {
type Target = intm0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for INTM0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("INTM0").finish()
}
}
#[doc = "INTM"]
pub mod intm0;
#[doc = "DMA MP"]
pub struct DMA0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for DMA0 {}
impl DMA0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const dma0::RegisterBlock = 0x4008_0000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const dma0::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 DMA0 {
type Target = dma0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for DMA0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("DMA0").finish()
}
}
#[doc = "DMA MP"]
pub mod dma0;
#[doc = "DMA MP"]
pub struct DMA1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for DMA1 {}
impl DMA1 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const dma0::RegisterBlock = 0x400a_0000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const dma0::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 DMA1 {
type Target = dma0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for DMA1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("DMA1").finish()
}
}
#[doc = "DMA MP"]
pub use self::dma0 as dma1;
#[doc = "DMA TCD"]
pub struct EDMA_0_TCD {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for EDMA_0_TCD {}
impl EDMA_0_TCD {
#[doc = r"Pointer to the register block"]
pub const PTR: *const edma_0_tcd::RegisterBlock = 0x4008_1000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const edma_0_tcd::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 EDMA_0_TCD {
type Target = edma_0_tcd::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for EDMA_0_TCD {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("EDMA_0_TCD").finish()
}
}
#[doc = "DMA TCD"]
pub mod edma_0_tcd;
#[doc = "SCT"]
pub struct SCT0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SCT0 {}
impl SCT0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const sct0::RegisterBlock = 0x4009_1000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const sct0::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 SCT0 {
type Target = sct0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for SCT0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("SCT0").finish()
}
}
#[doc = "SCT"]
pub mod sct0;
#[doc = "LPSPI"]
pub struct LPSPI0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for LPSPI0 {}
impl LPSPI0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const lpspi0::RegisterBlock = 0x4009_2000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const lpspi0::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 LPSPI0 {
type Target = lpspi0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for LPSPI0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("LPSPI0").finish()
}
}
#[doc = "LPSPI"]
pub mod lpspi0;
#[doc = "LPSPI"]
pub struct LPSPI1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for LPSPI1 {}
impl LPSPI1 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const lpspi0::RegisterBlock = 0x4009_3000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const lpspi0::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 LPSPI1 {
type Target = lpspi0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for LPSPI1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("LPSPI1").finish()
}
}
#[doc = "LPSPI"]
pub use self::lpspi0 as lpspi1;
#[doc = "LPSPI"]
pub struct LPSPI2 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for LPSPI2 {}
impl LPSPI2 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const lpspi0::RegisterBlock = 0x4009_4000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const lpspi0::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 LPSPI2 {
type Target = lpspi0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for LPSPI2 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("LPSPI2").finish()
}
}
#[doc = "LPSPI"]
pub use self::lpspi0 as lpspi2;
#[doc = "LPSPI"]
pub struct LPSPI3 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for LPSPI3 {}
impl LPSPI3 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const lpspi0::RegisterBlock = 0x4009_5000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const lpspi0::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 LPSPI3 {
type Target = lpspi0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for LPSPI3 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("LPSPI3").finish()
}
}
#[doc = "LPSPI"]
pub use self::lpspi0 as lpspi3;
#[doc = "LPSPI"]
pub struct LPSPI4 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for LPSPI4 {}
impl LPSPI4 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const lpspi0::RegisterBlock = 0x400b_4000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const lpspi0::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 LPSPI4 {
type Target = lpspi0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for LPSPI4 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("LPSPI4").finish()
}
}
#[doc = "LPSPI"]
pub use self::lpspi0 as lpspi4;
#[doc = "LPSPI"]
pub struct LPSPI5 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for LPSPI5 {}
impl LPSPI5 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const lpspi0::RegisterBlock = 0x400b_5000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const lpspi0::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 LPSPI5 {
type Target = lpspi0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for LPSPI5 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("LPSPI5").finish()
}
}
#[doc = "LPSPI"]
pub use self::lpspi0 as lpspi5;
#[doc = "LPSPI"]
pub struct LPSPI6 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for LPSPI6 {}
impl LPSPI6 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const lpspi0::RegisterBlock = 0x400b_6000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const lpspi0::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 LPSPI6 {
type Target = lpspi0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for LPSPI6 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("LPSPI6").finish()
}
}
#[doc = "LPSPI"]
pub use self::lpspi0 as lpspi6;
#[doc = "LPSPI"]
pub struct LPSPI7 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for LPSPI7 {}
impl LPSPI7 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const lpspi0::RegisterBlock = 0x400b_7000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const lpspi0::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 LPSPI7 {
type Target = lpspi0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for LPSPI7 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("LPSPI7").finish()
}
}
#[doc = "LPSPI"]
pub use self::lpspi0 as lpspi7;
#[doc = "LPSPI"]
pub struct LPSPI8 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for LPSPI8 {}
impl LPSPI8 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const lpspi0::RegisterBlock = 0x400b_8000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const lpspi0::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 LPSPI8 {
type Target = lpspi0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for LPSPI8 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("LPSPI8").finish()
}
}
#[doc = "LPSPI"]
pub use self::lpspi0 as lpspi8;
#[doc = "LPSPI"]
pub struct LPSPI9 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for LPSPI9 {}
impl LPSPI9 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const lpspi0::RegisterBlock = 0x400b_9000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const lpspi0::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 LPSPI9 {
type Target = lpspi0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for LPSPI9 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("LPSPI9").finish()
}
}
#[doc = "LPSPI"]
pub use self::lpspi0 as lpspi9;
#[doc = "LPUART"]
pub struct LPUART0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for LPUART0 {}
impl LPUART0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const lpuart0::RegisterBlock = 0x4009_2000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const lpuart0::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 LPUART0 {
type Target = lpuart0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for LPUART0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("LPUART0").finish()
}
}
#[doc = "LPUART"]
pub mod lpuart0;
#[doc = "LPUART"]
pub struct LPUART1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for LPUART1 {}
impl LPUART1 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const lpuart0::RegisterBlock = 0x4009_3000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const lpuart0::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 LPUART1 {
type Target = lpuart0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for LPUART1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("LPUART1").finish()
}
}
#[doc = "LPUART"]
pub use self::lpuart0 as lpuart1;
#[doc = "LPUART"]
pub struct LPUART2 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for LPUART2 {}
impl LPUART2 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const lpuart0::RegisterBlock = 0x4009_4000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const lpuart0::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 LPUART2 {
type Target = lpuart0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for LPUART2 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("LPUART2").finish()
}
}
#[doc = "LPUART"]
pub use self::lpuart0 as lpuart2;
#[doc = "LPUART"]
pub struct LPUART3 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for LPUART3 {}
impl LPUART3 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const lpuart0::RegisterBlock = 0x4009_5000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const lpuart0::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 LPUART3 {
type Target = lpuart0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for LPUART3 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("LPUART3").finish()
}
}
#[doc = "LPUART"]
pub use self::lpuart0 as lpuart3;
#[doc = "LPUART"]
pub struct LPUART4 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for LPUART4 {}
impl LPUART4 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const lpuart0::RegisterBlock = 0x400b_4000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const lpuart0::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 LPUART4 {
type Target = lpuart0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for LPUART4 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("LPUART4").finish()
}
}
#[doc = "LPUART"]
pub use self::lpuart0 as lpuart4;
#[doc = "LPUART"]
pub struct LPUART5 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for LPUART5 {}
impl LPUART5 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const lpuart0::RegisterBlock = 0x400b_5000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const lpuart0::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 LPUART5 {
type Target = lpuart0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for LPUART5 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("LPUART5").finish()
}
}
#[doc = "LPUART"]
pub use self::lpuart0 as lpuart5;
#[doc = "LPUART"]
pub struct LPUART6 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for LPUART6 {}
impl LPUART6 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const lpuart0::RegisterBlock = 0x400b_6000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const lpuart0::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 LPUART6 {
type Target = lpuart0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for LPUART6 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("LPUART6").finish()
}
}
#[doc = "LPUART"]
pub use self::lpuart0 as lpuart6;
#[doc = "LPUART"]
pub struct LPUART7 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for LPUART7 {}
impl LPUART7 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const lpuart0::RegisterBlock = 0x400b_7000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const lpuart0::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 LPUART7 {
type Target = lpuart0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for LPUART7 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("LPUART7").finish()
}
}
#[doc = "LPUART"]
pub use self::lpuart0 as lpuart7;
#[doc = "LPUART"]
pub struct LPUART8 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for LPUART8 {}
impl LPUART8 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const lpuart0::RegisterBlock = 0x400b_8000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const lpuart0::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 LPUART8 {
type Target = lpuart0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for LPUART8 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("LPUART8").finish()
}
}
#[doc = "LPUART"]
pub use self::lpuart0 as lpuart8;
#[doc = "LPUART"]
pub struct LPUART9 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for LPUART9 {}
impl LPUART9 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const lpuart0::RegisterBlock = 0x400b_9000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const lpuart0::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 LPUART9 {
type Target = lpuart0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for LPUART9 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("LPUART9").finish()
}
}
#[doc = "LPUART"]
pub use self::lpuart0 as lpuart9;
#[doc = "LP_FLEXCOMM"]
pub struct LP_FLEXCOMM0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for LP_FLEXCOMM0 {}
impl LP_FLEXCOMM0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const lp_flexcomm0::RegisterBlock = 0x4009_2000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const lp_flexcomm0::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 LP_FLEXCOMM0 {
type Target = lp_flexcomm0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for LP_FLEXCOMM0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("LP_FLEXCOMM0").finish()
}
}
#[doc = "LP_FLEXCOMM"]
pub mod lp_flexcomm0;
#[doc = "LP_FLEXCOMM"]
pub struct LP_FLEXCOMM1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for LP_FLEXCOMM1 {}
impl LP_FLEXCOMM1 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const lp_flexcomm0::RegisterBlock = 0x4009_3000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const lp_flexcomm0::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 LP_FLEXCOMM1 {
type Target = lp_flexcomm0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for LP_FLEXCOMM1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("LP_FLEXCOMM1").finish()
}
}
#[doc = "LP_FLEXCOMM"]
pub use self::lp_flexcomm0 as lp_flexcomm1;
#[doc = "LP_FLEXCOMM"]
pub struct LP_FLEXCOMM2 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for LP_FLEXCOMM2 {}
impl LP_FLEXCOMM2 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const lp_flexcomm0::RegisterBlock = 0x4009_4000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const lp_flexcomm0::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 LP_FLEXCOMM2 {
type Target = lp_flexcomm0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for LP_FLEXCOMM2 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("LP_FLEXCOMM2").finish()
}
}
#[doc = "LP_FLEXCOMM"]
pub use self::lp_flexcomm0 as lp_flexcomm2;
#[doc = "LP_FLEXCOMM"]
pub struct LP_FLEXCOMM3 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for LP_FLEXCOMM3 {}
impl LP_FLEXCOMM3 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const lp_flexcomm0::RegisterBlock = 0x4009_5000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const lp_flexcomm0::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 LP_FLEXCOMM3 {
type Target = lp_flexcomm0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for LP_FLEXCOMM3 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("LP_FLEXCOMM3").finish()
}
}
#[doc = "LP_FLEXCOMM"]
pub use self::lp_flexcomm0 as lp_flexcomm3;
#[doc = "LP_FLEXCOMM"]
pub struct LP_FLEXCOMM4 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for LP_FLEXCOMM4 {}
impl LP_FLEXCOMM4 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const lp_flexcomm0::RegisterBlock = 0x400b_4000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const lp_flexcomm0::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 LP_FLEXCOMM4 {
type Target = lp_flexcomm0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for LP_FLEXCOMM4 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("LP_FLEXCOMM4").finish()
}
}
#[doc = "LP_FLEXCOMM"]
pub use self::lp_flexcomm0 as lp_flexcomm4;
#[doc = "LP_FLEXCOMM"]
pub struct LP_FLEXCOMM5 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for LP_FLEXCOMM5 {}
impl LP_FLEXCOMM5 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const lp_flexcomm0::RegisterBlock = 0x400b_5000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const lp_flexcomm0::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 LP_FLEXCOMM5 {
type Target = lp_flexcomm0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for LP_FLEXCOMM5 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("LP_FLEXCOMM5").finish()
}
}
#[doc = "LP_FLEXCOMM"]
pub use self::lp_flexcomm0 as lp_flexcomm5;
#[doc = "LP_FLEXCOMM"]
pub struct LP_FLEXCOMM6 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for LP_FLEXCOMM6 {}
impl LP_FLEXCOMM6 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const lp_flexcomm0::RegisterBlock = 0x400b_6000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const lp_flexcomm0::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 LP_FLEXCOMM6 {
type Target = lp_flexcomm0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for LP_FLEXCOMM6 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("LP_FLEXCOMM6").finish()
}
}
#[doc = "LP_FLEXCOMM"]
pub use self::lp_flexcomm0 as lp_flexcomm6;
#[doc = "LP_FLEXCOMM"]
pub struct LP_FLEXCOMM7 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for LP_FLEXCOMM7 {}
impl LP_FLEXCOMM7 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const lp_flexcomm0::RegisterBlock = 0x400b_7000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const lp_flexcomm0::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 LP_FLEXCOMM7 {
type Target = lp_flexcomm0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for LP_FLEXCOMM7 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("LP_FLEXCOMM7").finish()
}
}
#[doc = "LP_FLEXCOMM"]
pub use self::lp_flexcomm0 as lp_flexcomm7;
#[doc = "LP_FLEXCOMM"]
pub struct LP_FLEXCOMM8 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for LP_FLEXCOMM8 {}
impl LP_FLEXCOMM8 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const lp_flexcomm0::RegisterBlock = 0x400b_8000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const lp_flexcomm0::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 LP_FLEXCOMM8 {
type Target = lp_flexcomm0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for LP_FLEXCOMM8 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("LP_FLEXCOMM8").finish()
}
}
#[doc = "LP_FLEXCOMM"]
pub use self::lp_flexcomm0 as lp_flexcomm8;
#[doc = "LP_FLEXCOMM"]
pub struct LP_FLEXCOMM9 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for LP_FLEXCOMM9 {}
impl LP_FLEXCOMM9 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const lp_flexcomm0::RegisterBlock = 0x400b_9000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const lp_flexcomm0::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 LP_FLEXCOMM9 {
type Target = lp_flexcomm0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for LP_FLEXCOMM9 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("LP_FLEXCOMM9").finish()
}
}
#[doc = "LP_FLEXCOMM"]
pub use self::lp_flexcomm0 as lp_flexcomm9;
#[doc = "LPI2C"]
pub struct LPI2C0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for LPI2C0 {}
impl LPI2C0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const lpi2c0::RegisterBlock = 0x4009_2800 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const lpi2c0::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 LPI2C0 {
type Target = lpi2c0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for LPI2C0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("LPI2C0").finish()
}
}
#[doc = "LPI2C"]
pub mod lpi2c0;
#[doc = "LPI2C"]
pub struct LPI2C1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for LPI2C1 {}
impl LPI2C1 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const lpi2c0::RegisterBlock = 0x4009_3800 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const lpi2c0::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 LPI2C1 {
type Target = lpi2c0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for LPI2C1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("LPI2C1").finish()
}
}
#[doc = "LPI2C"]
pub use self::lpi2c0 as lpi2c1;
#[doc = "LPI2C"]
pub struct LPI2C2 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for LPI2C2 {}
impl LPI2C2 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const lpi2c0::RegisterBlock = 0x4009_4800 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const lpi2c0::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 LPI2C2 {
type Target = lpi2c0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for LPI2C2 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("LPI2C2").finish()
}
}
#[doc = "LPI2C"]
pub use self::lpi2c0 as lpi2c2;
#[doc = "LPI2C"]
pub struct LPI2C3 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for LPI2C3 {}
impl LPI2C3 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const lpi2c0::RegisterBlock = 0x4009_5800 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const lpi2c0::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 LPI2C3 {
type Target = lpi2c0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for LPI2C3 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("LPI2C3").finish()
}
}
#[doc = "LPI2C"]
pub use self::lpi2c0 as lpi2c3;
#[doc = "LPI2C"]
pub struct LPI2C4 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for LPI2C4 {}
impl LPI2C4 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const lpi2c0::RegisterBlock = 0x400b_4800 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const lpi2c0::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 LPI2C4 {
type Target = lpi2c0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for LPI2C4 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("LPI2C4").finish()
}
}
#[doc = "LPI2C"]
pub use self::lpi2c0 as lpi2c4;
#[doc = "LPI2C"]
pub struct LPI2C5 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for LPI2C5 {}
impl LPI2C5 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const lpi2c0::RegisterBlock = 0x400b_5800 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const lpi2c0::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 LPI2C5 {
type Target = lpi2c0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for LPI2C5 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("LPI2C5").finish()
}
}
#[doc = "LPI2C"]
pub use self::lpi2c0 as lpi2c5;
#[doc = "LPI2C"]
pub struct LPI2C6 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for LPI2C6 {}
impl LPI2C6 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const lpi2c0::RegisterBlock = 0x400b_6800 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const lpi2c0::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 LPI2C6 {
type Target = lpi2c0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for LPI2C6 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("LPI2C6").finish()
}
}
#[doc = "LPI2C"]
pub use self::lpi2c0 as lpi2c6;
#[doc = "LPI2C"]
pub struct LPI2C7 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for LPI2C7 {}
impl LPI2C7 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const lpi2c0::RegisterBlock = 0x400b_7800 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const lpi2c0::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 LPI2C7 {
type Target = lpi2c0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for LPI2C7 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("LPI2C7").finish()
}
}
#[doc = "LPI2C"]
pub use self::lpi2c0 as lpi2c7;
#[doc = "LPI2C"]
pub struct LPI2C8 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for LPI2C8 {}
impl LPI2C8 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const lpi2c0::RegisterBlock = 0x400b_8800 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const lpi2c0::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 LPI2C8 {
type Target = lpi2c0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for LPI2C8 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("LPI2C8").finish()
}
}
#[doc = "LPI2C"]
pub use self::lpi2c0 as lpi2c8;
#[doc = "LPI2C"]
pub struct LPI2C9 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for LPI2C9 {}
impl LPI2C9 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const lpi2c0::RegisterBlock = 0x400b_9800 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const lpi2c0::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 LPI2C9 {
type Target = lpi2c0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for LPI2C9 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("LPI2C9").finish()
}
}
#[doc = "LPI2C"]
pub use self::lpi2c0 as lpi2c9;
#[doc = "GPIO"]
pub struct GPIO0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for GPIO0 {}
impl GPIO0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const gpio0::RegisterBlock = 0x4009_6000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const gpio0::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 GPIO0 {
type Target = gpio0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for GPIO0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("GPIO0").finish()
}
}
#[doc = "GPIO"]
pub mod gpio0;
#[doc = "GPIO"]
pub struct GPIO5 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for GPIO5 {}
impl GPIO5 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const gpio0::RegisterBlock = 0x4004_0000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const gpio0::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 GPIO5 {
type Target = gpio0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for GPIO5 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("GPIO5").finish()
}
}
#[doc = "GPIO"]
pub use self::gpio0 as gpio5;
#[doc = "GPIO"]
pub struct GPIO1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for GPIO1 {}
impl GPIO1 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const gpio0::RegisterBlock = 0x4009_8000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const gpio0::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 GPIO1 {
type Target = gpio0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for GPIO1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("GPIO1").finish()
}
}
#[doc = "GPIO"]
pub use self::gpio0 as gpio1;
#[doc = "GPIO"]
pub struct GPIO2 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for GPIO2 {}
impl GPIO2 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const gpio0::RegisterBlock = 0x4009_a000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const gpio0::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 GPIO2 {
type Target = gpio0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for GPIO2 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("GPIO2").finish()
}
}
#[doc = "GPIO"]
pub use self::gpio0 as gpio2;
#[doc = "GPIO"]
pub struct GPIO3 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for GPIO3 {}
impl GPIO3 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const gpio0::RegisterBlock = 0x4009_c000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const gpio0::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 GPIO3 {
type Target = gpio0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for GPIO3 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("GPIO3").finish()
}
}
#[doc = "GPIO"]
pub use self::gpio0 as gpio3;
#[doc = "GPIO"]
pub struct GPIO4 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for GPIO4 {}
impl GPIO4 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const gpio0::RegisterBlock = 0x4009_e000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const gpio0::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 GPIO4 {
type Target = gpio0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for GPIO4 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("GPIO4").finish()
}
}
#[doc = "GPIO"]
pub use self::gpio0 as gpio4;
#[doc = "DMA TCD"]
pub struct EDMA_1_TCD {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for EDMA_1_TCD {}
impl EDMA_1_TCD {
#[doc = r"Pointer to the register block"]
pub const PTR: *const edma_0_tcd::RegisterBlock = 0x400a_1000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const edma_0_tcd::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 EDMA_1_TCD {
type Target = edma_0_tcd::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for EDMA_1_TCD {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("EDMA_1_TCD").finish()
}
}
#[doc = "DMA TCD"]
pub use self::edma_0_tcd as edma_1_tcd;
#[doc = "SEMA42"]
pub struct SEMA42_0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SEMA42_0 {}
impl SEMA42_0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const sema42_0::RegisterBlock = 0x400b_1000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const sema42_0::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 SEMA42_0 {
type Target = sema42_0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for SEMA42_0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("SEMA42_0").finish()
}
}
#[doc = "SEMA42"]
pub mod sema42_0;
#[doc = "MAILBOX"]
pub struct MAILBOX {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for MAILBOX {}
impl MAILBOX {
#[doc = r"Pointer to the register block"]
pub const PTR: *const mailbox::RegisterBlock = 0x400b_2000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const mailbox::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 MAILBOX {
type Target = mailbox::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for MAILBOX {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("MAILBOX").finish()
}
}
#[doc = "MAILBOX"]
pub mod mailbox;
#[doc = "CDOG"]
pub struct CDOG0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for CDOG0 {}
impl CDOG0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const cdog0::RegisterBlock = 0x400b_b000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const cdog0::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 CDOG0 {
type Target = cdog0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for CDOG0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("CDOG0").finish()
}
}
#[doc = "CDOG"]
pub mod cdog0;
#[doc = "CDOG"]
pub struct CDOG1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for CDOG1 {}
impl CDOG1 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const cdog0::RegisterBlock = 0x400b_c000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const cdog0::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 CDOG1 {
type Target = cdog0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for CDOG1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("CDOG1").finish()
}
}
#[doc = "CDOG"]
pub use self::cdog0 as cdog1;
#[doc = "DBGMB"]
pub struct DM0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for DM0 {}
impl DM0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const dm0::RegisterBlock = 0x400b_d000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const dm0::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 DM0 {
type Target = dm0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for DM0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("DM0").finish()
}
}
#[doc = "DBGMB"]
pub mod dm0;
#[doc = "PowerQuad"]
pub struct POWERQUAD {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for POWERQUAD {}
impl POWERQUAD {
#[doc = r"Pointer to the register block"]
pub const PTR: *const powerquad::RegisterBlock = 0x400b_f000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const powerquad::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 POWERQUAD {
type Target = powerquad::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for POWERQUAD {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("POWERQUAD").finish()
}
}
#[doc = "PowerQuad"]
pub mod powerquad;
#[doc = "EWM"]
pub struct EWM0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for EWM0 {}
impl EWM0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const ewm0::RegisterBlock = 0x400c_0000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const ewm0::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 EWM0 {
type Target = ewm0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for EWM0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("EWM0").finish()
}
}
#[doc = "EWM"]
pub mod ewm0;
#[doc = "CMX_PERFMON"]
pub struct CMX_PERFMON0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for CMX_PERFMON0 {}
impl CMX_PERFMON0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const cmx_perfmon0::RegisterBlock = 0x400c_1000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const cmx_perfmon0::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 CMX_PERFMON0 {
type Target = cmx_perfmon0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for CMX_PERFMON0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("CMX_PERFMON0").finish()
}
}
#[doc = "CMX_PERFMON"]
pub mod cmx_perfmon0;
#[doc = "CMX_PERFMON"]
pub struct CMX_PERFMON1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for CMX_PERFMON1 {}
impl CMX_PERFMON1 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const cmx_perfmon0::RegisterBlock = 0x400c_2000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const cmx_perfmon0::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 CMX_PERFMON1 {
type Target = cmx_perfmon0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for CMX_PERFMON1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("CMX_PERFMON1").finish()
}
}
#[doc = "CMX_PERFMON"]
pub use self::cmx_perfmon0 as cmx_perfmon1;
#[doc = "TRDC"]
pub struct TRDC {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for TRDC {}
impl TRDC {
#[doc = r"Pointer to the register block"]
pub const PTR: *const trdc::RegisterBlock = 0x400c_6000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const trdc::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 TRDC {
type Target = trdc::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for TRDC {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("TRDC").finish()
}
}
#[doc = "TRDC"]
pub mod trdc;
#[doc = "FlexSPI"]
pub struct FLEXSPI0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for FLEXSPI0 {}
impl FLEXSPI0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const flexspi0::RegisterBlock = 0x400c_8000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const flexspi0::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 FLEXSPI0 {
type Target = flexspi0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for FLEXSPI0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("FLEXSPI0").finish()
}
}
#[doc = "FlexSPI"]
pub mod flexspi0;
#[doc = "OTPC"]
pub struct OTPC0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for OTPC0 {}
impl OTPC0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const otpc0::RegisterBlock = 0x400c_9000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const otpc0::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 OTPC0 {
type Target = otpc0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for OTPC0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("OTPC0").finish()
}
}
#[doc = "OTPC"]
pub mod otpc0;
#[doc = "CRC"]
pub struct CRC0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for CRC0 {}
impl CRC0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const crc0::RegisterBlock = 0x400c_b000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const crc0::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 CRC0 {
type Target = crc0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for CRC0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("CRC0").finish()
}
}
#[doc = "CRC"]
pub mod crc0;
#[doc = "FMC"]
pub struct NPX0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for NPX0 {}
impl NPX0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const npx0::RegisterBlock = 0x400c_c000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const npx0::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 NPX0 {
type Target = npx0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for NPX0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("NPX0").finish()
}
}
#[doc = "FMC"]
pub mod npx0;
#[doc = "PWM"]
pub struct PWM0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PWM0 {}
impl PWM0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const pwm0::RegisterBlock = 0x400c_e000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const pwm0::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 PWM0 {
type Target = pwm0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for PWM0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("PWM0").finish()
}
}
#[doc = "PWM"]
pub mod pwm0;
#[doc = "PWM"]
pub struct PWM1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PWM1 {}
impl PWM1 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const pwm0::RegisterBlock = 0x400d_0000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const pwm0::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 PWM1 {
type Target = pwm0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for PWM1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("PWM1").finish()
}
}
#[doc = "PWM"]
pub use self::pwm0 as pwm1;
#[doc = "ENC"]
pub struct ENC0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for ENC0 {}
impl ENC0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const enc0::RegisterBlock = 0x400c_f000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const enc0::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 ENC0 {
type Target = enc0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for ENC0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("ENC0").finish()
}
}
#[doc = "ENC"]
pub mod enc0;
#[doc = "ENC"]
pub struct ENC1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for ENC1 {}
impl ENC1 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const enc0::RegisterBlock = 0x400d_1000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const enc0::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 ENC1 {
type Target = enc0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for ENC1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("ENC1").finish()
}
}
#[doc = "ENC"]
pub use self::enc0 as enc1;
#[doc = "EVTG"]
pub struct EVTG0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for EVTG0 {}
impl EVTG0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const evtg0::RegisterBlock = 0x400d_2000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const evtg0::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 EVTG0 {
type Target = evtg0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for EVTG0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("EVTG0").finish()
}
}
#[doc = "EVTG"]
pub mod evtg0;
#[doc = "CAN"]
pub struct CAN0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for CAN0 {}
impl CAN0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const can0::RegisterBlock = 0x400d_4000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const can0::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 CAN0 {
type Target = can0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for CAN0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("CAN0").finish()
}
}
#[doc = "CAN"]
pub mod can0;
#[doc = "CAN"]
pub struct CAN1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for CAN1 {}
impl CAN1 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const can0::RegisterBlock = 0x400d_8000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const can0::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 CAN1 {
type Target = can0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for CAN1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("CAN1").finish()
}
}
#[doc = "CAN"]
pub use self::can0 as can1;
#[doc = "USBDCD"]
pub struct USBDCD0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for USBDCD0 {}
impl USBDCD0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const usbdcd0::RegisterBlock = 0x400d_c000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const usbdcd0::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 USBDCD0 {
type Target = usbdcd0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for USBDCD0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("USBDCD0").finish()
}
}
#[doc = "USBDCD"]
pub mod usbdcd0;
#[doc = "USBFS"]
pub struct USBFS0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for USBFS0 {}
impl USBFS0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const usbfs0::RegisterBlock = 0x400d_d000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const usbfs0::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 USBFS0 {
type Target = usbfs0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for USBFS0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("USBFS0").finish()
}
}
#[doc = "USBFS"]
pub mod usbfs0;
#[doc = "ENET"]
pub struct ENET0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for ENET0 {}
impl ENET0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const enet0::RegisterBlock = 0x4010_0000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const enet0::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 ENET0 {
type Target = enet0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for ENET0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("ENET0").finish()
}
}
#[doc = "ENET"]
pub mod enet0;
#[doc = "EMVSIM"]
pub struct EMVSIM0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for EMVSIM0 {}
impl EMVSIM0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const emvsim0::RegisterBlock = 0x4010_3000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const emvsim0::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 EMVSIM0 {
type Target = emvsim0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for EMVSIM0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("EMVSIM0").finish()
}
}
#[doc = "EMVSIM"]
pub mod emvsim0;
#[doc = "EMVSIM"]
pub struct EMVSIM1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for EMVSIM1 {}
impl EMVSIM1 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const emvsim0::RegisterBlock = 0x4010_4000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const emvsim0::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 EMVSIM1 {
type Target = emvsim0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for EMVSIM1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("EMVSIM1").finish()
}
}
#[doc = "EMVSIM"]
pub use self::emvsim0 as emvsim1;
#[doc = "FLEXIO"]
pub struct FLEXIO0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for FLEXIO0 {}
impl FLEXIO0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const flexio0::RegisterBlock = 0x4010_5000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const flexio0::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 FLEXIO0 {
type Target = flexio0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for FLEXIO0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("FLEXIO0").finish()
}
}
#[doc = "FLEXIO"]
pub mod flexio0;
#[doc = "SAI"]
pub struct SAI0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SAI0 {}
impl SAI0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const sai0::RegisterBlock = 0x4010_6000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const sai0::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 SAI0 {
type Target = sai0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for SAI0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("SAI0").finish()
}
}
#[doc = "SAI"]
pub mod sai0;
#[doc = "SAI"]
pub struct SAI1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SAI1 {}
impl SAI1 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const sai0::RegisterBlock = 0x4010_7000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const sai0::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 SAI1 {
type Target = sai0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for SAI1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("SAI1").finish()
}
}
#[doc = "SAI"]
pub use self::sai0 as sai1;
#[doc = "SINC"]
pub struct SINC0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SINC0 {}
impl SINC0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const sinc0::RegisterBlock = 0x4010_8000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const sinc0::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 SINC0 {
type Target = sinc0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for SINC0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("SINC0").finish()
}
}
#[doc = "SINC"]
pub mod sinc0;
#[doc = "uSDHC"]
pub struct USDHC0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for USDHC0 {}
impl USDHC0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const usdhc0::RegisterBlock = 0x4010_9000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const usdhc0::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 USDHC0 {
type Target = usdhc0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for USDHC0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("USDHC0").finish()
}
}
#[doc = "uSDHC"]
pub mod usdhc0;
#[doc = "USBPHY"]
pub struct USBPHY {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for USBPHY {}
impl USBPHY {
#[doc = r"Pointer to the register block"]
pub const PTR: *const usbphy::RegisterBlock = 0x4010_a000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const usbphy::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 USBPHY {
type Target = usbphy::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for USBPHY {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("USBPHY").finish()
}
}
#[doc = "USBPHY"]
pub mod usbphy;
#[doc = "USBDCD"]
pub struct USBHS1_PHY_DCD {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for USBHS1_PHY_DCD {}
impl USBHS1_PHY_DCD {
#[doc = r"Pointer to the register block"]
pub const PTR: *const usbhs1_phy_dcd::RegisterBlock = 0x4010_a800 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const usbhs1_phy_dcd::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 USBHS1_PHY_DCD {
type Target = usbhs1_phy_dcd::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for USBHS1_PHY_DCD {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("USBHS1_PHY_DCD").finish()
}
}
#[doc = "USBDCD"]
pub mod usbhs1_phy_dcd;
#[doc = "USB"]
pub struct USBHS1__USBC {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for USBHS1__USBC {}
impl USBHS1__USBC {
#[doc = r"Pointer to the register block"]
pub const PTR: *const usbhs1__usbc::RegisterBlock = 0x4010_b000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const usbhs1__usbc::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 USBHS1__USBC {
type Target = usbhs1__usbc::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for USBHS1__USBC {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("USBHS1__USBC").finish()
}
}
#[doc = "USB"]
pub mod usbhs1__usbc;
#[doc = "USBNC"]
pub struct USBHS1__USBNC {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for USBHS1__USBNC {}
impl USBHS1__USBNC {
#[doc = r"Pointer to the register block"]
pub const PTR: *const usbhs1__usbnc::RegisterBlock = 0x4010_b200 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const usbhs1__usbnc::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 USBHS1__USBNC {
type Target = usbhs1__usbnc::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for USBHS1__USBNC {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("USBHS1__USBNC").finish()
}
}
#[doc = "USBNC"]
pub mod usbhs1__usbnc;
#[doc = "MICFIL"]
pub struct PDM {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PDM {}
impl PDM {
#[doc = r"Pointer to the register block"]
pub const PTR: *const pdm::RegisterBlock = 0x4010_c000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const pdm::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 PDM {
type Target = pdm::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for PDM {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("PDM").finish()
}
}
#[doc = "MICFIL"]
pub mod pdm;
#[doc = "ADC"]
pub struct ADC0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for ADC0 {}
impl ADC0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const adc0::RegisterBlock = 0x4010_d000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const adc0::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 ADC0 {
type Target = adc0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for ADC0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("ADC0").finish()
}
}
#[doc = "ADC"]
pub mod adc0;
#[doc = "ADC"]
pub struct ADC1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for ADC1 {}
impl ADC1 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const adc0::RegisterBlock = 0x4010_e000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const adc0::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 ADC1 {
type Target = adc0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for ADC1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("ADC1").finish()
}
}
#[doc = "ADC"]
pub use self::adc0 as adc1;
#[doc = "12-bit DAC"]
pub struct DAC0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for DAC0 {}
impl DAC0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const dac0::RegisterBlock = 0x4010_f000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const dac0::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 DAC0 {
type Target = dac0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for DAC0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("DAC0").finish()
}
}
#[doc = "12-bit DAC"]
pub mod dac0;
#[doc = "12-bit DAC"]
pub struct DAC1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for DAC1 {}
impl DAC1 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const dac0::RegisterBlock = 0x4011_2000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const dac0::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 DAC1 {
type Target = dac0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for DAC1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("DAC1").finish()
}
}
#[doc = "12-bit DAC"]
pub use self::dac0 as dac1;
#[doc = "OPAMP"]
pub struct OPAMP0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for OPAMP0 {}
impl OPAMP0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const opamp0::RegisterBlock = 0x4011_0000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const opamp0::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 OPAMP0 {
type Target = opamp0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for OPAMP0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("OPAMP0").finish()
}
}
#[doc = "OPAMP"]
pub mod opamp0;
#[doc = "OPAMP"]
pub struct OPAMP1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for OPAMP1 {}
impl OPAMP1 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const opamp0::RegisterBlock = 0x4011_3000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const opamp0::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 OPAMP1 {
type Target = opamp0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for OPAMP1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("OPAMP1").finish()
}
}
#[doc = "OPAMP"]
pub use self::opamp0 as opamp1;
#[doc = "OPAMP"]
pub struct OPAMP2 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for OPAMP2 {}
impl OPAMP2 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const opamp0::RegisterBlock = 0x4011_5000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const opamp0::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 OPAMP2 {
type Target = opamp0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for OPAMP2 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("OPAMP2").finish()
}
}
#[doc = "OPAMP"]
pub use self::opamp0 as opamp2;
#[doc = "VREF"]
pub struct VREF0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for VREF0 {}
impl VREF0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const vref0::RegisterBlock = 0x4011_1000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const vref0::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 VREF0 {
type Target = vref0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for VREF0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("VREF0").finish()
}
}
#[doc = "VREF"]
pub mod vref0;
#[doc = "14-bit DAC"]
pub struct DAC2 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for DAC2 {}
impl DAC2 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const dac2::RegisterBlock = 0x4011_4000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const dac2::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 DAC2 {
type Target = dac2::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for DAC2 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("DAC2").finish()
}
}
#[doc = "14-bit DAC"]
pub mod dac2;
#[doc = "PORT"]
pub struct PORT1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PORT1 {}
impl PORT1 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const port0::RegisterBlock = 0x4011_7000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const port0::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 PORT1 {
type Target = port0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for PORT1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("PORT1").finish()
}
}
#[doc = "PORT"]
pub use self::port0 as port1;
#[doc = "PORT"]
pub struct PORT2 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PORT2 {}
impl PORT2 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const port0::RegisterBlock = 0x4011_8000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const port0::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 PORT2 {
type Target = port0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for PORT2 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("PORT2").finish()
}
}
#[doc = "PORT"]
pub use self::port0 as port2;
#[doc = "PORT"]
pub struct PORT3 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PORT3 {}
impl PORT3 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const port0::RegisterBlock = 0x4011_9000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const port0::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 PORT3 {
type Target = port0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for PORT3 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("PORT3").finish()
}
}
#[doc = "PORT"]
pub use self::port0 as port3;
#[doc = "PORT"]
pub struct PORT4 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PORT4 {}
impl PORT4 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const port0::RegisterBlock = 0x4011_a000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const port0::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 PORT4 {
type Target = port0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for PORT4 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("PORT4").finish()
}
}
#[doc = "PORT"]
pub use self::port0 as port4;
#[doc = "AHBSC"]
pub struct AHBSC {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for AHBSC {}
impl AHBSC {
#[doc = r"Pointer to the register block"]
pub const PTR: *const ahbsc::RegisterBlock = 0x4012_0000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const ahbsc::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 AHBSC {
type Target = ahbsc::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for AHBSC {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("AHBSC").finish()
}
}
#[doc = "AHBSC"]
pub mod ahbsc;
#[doc = "no description available"]
pub struct SCN_SCB {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SCN_SCB {}
impl SCN_SCB {
#[doc = r"Pointer to the register block"]
pub const PTR: *const scn_scb::RegisterBlock = 0xe000_e000 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const scn_scb::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 SCN_SCB {
type Target = scn_scb::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for SCN_SCB {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("SCN_SCB").finish()
}
}
#[doc = "no description available"]
pub mod scn_scb;
#[doc = "M33 Systick module"]
pub struct SYS_TICK0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SYS_TICK0 {}
impl SYS_TICK0 {
#[doc = r"Pointer to the register block"]
pub const PTR: *const sys_tick0::RegisterBlock = 0xe000_e010 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const sys_tick0::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 SYS_TICK0 {
type Target = sys_tick0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for SYS_TICK0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("SYS_TICK0").finish()
}
}
#[doc = "M33 Systick module"]
pub mod sys_tick0;
#[doc = "no description available"]
pub struct SAU {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SAU {}
impl SAU {
#[doc = r"Pointer to the register block"]
pub const PTR: *const sau::RegisterBlock = 0xe000_edd0 as *const _;
#[doc = r"Return the pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const sau::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 SAU {
type Target = sau::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*Self::PTR }
}
}
impl core::fmt::Debug for SAU {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("SAU").finish()
}
}
#[doc = "no description available"]
pub mod sau;
#[no_mangle]
static mut DEVICE_PERIPHERALS: bool = false;
#[doc = r" All the peripherals."]
#[allow(non_snake_case)]
pub struct Peripherals {
#[doc = "SYSCON0"]
pub SYSCON0: SYSCON0,
#[doc = "PINT0"]
pub PINT0: PINT0,
#[doc = "INPUTMUX0"]
pub INPUTMUX0: INPUTMUX0,
#[doc = "CTIMER0"]
pub CTIMER0: CTIMER0,
#[doc = "CTIMER1"]
pub CTIMER1: CTIMER1,
#[doc = "CTIMER2"]
pub CTIMER2: CTIMER2,
#[doc = "CTIMER3"]
pub CTIMER3: CTIMER3,
#[doc = "CTIMER4"]
pub CTIMER4: CTIMER4,
#[doc = "FREQME0"]
pub FREQME0: FREQME0,
#[doc = "UTICK0"]
pub UTICK0: UTICK0,
#[doc = "MRT0"]
pub MRT0: MRT0,
#[doc = "WWDT0"]
pub WWDT0: WWDT0,
#[doc = "WWDT1"]
pub WWDT1: WWDT1,
#[doc = "CACHE64_CTRL0"]
pub CACHE64_CTRL0: CACHE64_CTRL0,
#[doc = "CACHE64_POLSEL0"]
pub CACHE64_POLSEL0: CACHE64_POLSEL0,
#[doc = "I3C0"]
pub I3C0: I3C0,
#[doc = "I3C1"]
pub I3C1: I3C1,
#[doc = "GDET0"]
pub GDET0: GDET0,
#[doc = "GDET1"]
pub GDET1: GDET1,
#[doc = "ITRC0"]
pub ITRC0: ITRC0,
#[doc = "PKC0"]
pub PKC0: PKC0,
#[doc = "PUF"]
pub PUF: PUF,
#[doc = "PUF_CTRL"]
pub PUF_CTRL: PUF_CTRL,
#[doc = "SM3_0"]
pub SM3_0: SM3_0,
#[doc = "BSP32_0"]
pub BSP32_0: BSP32_0,
#[doc = "SMARTDMA0"]
pub SMARTDMA0: SMARTDMA0,
#[doc = "PLU0"]
pub PLU0: PLU0,
#[doc = "PORT0"]
pub PORT0: PORT0,
#[doc = "PORT5"]
pub PORT5: PORT5,
#[doc = "FMU0"]
pub FMU0: FMU0,
#[doc = "SCG0"]
pub SCG0: SCG0,
#[doc = "SPC0"]
pub SPC0: SPC0,
#[doc = "WUU0"]
pub WUU0: WUU0,
#[doc = "CMC0"]
pub CMC0: CMC0,
#[doc = "OSTIMER0"]
pub OSTIMER0: OSTIMER0,
#[doc = "LPTMR0"]
pub LPTMR0: LPTMR0,
#[doc = "LPTMR1"]
pub LPTMR1: LPTMR1,
#[doc = "RTC0"]
pub RTC0: RTC0,
#[doc = "RTC_SUBSYSTEM0"]
pub RTC_SUBSYSTEM0: RTC_SUBSYSTEM0,
#[doc = "TSI0"]
pub TSI0: TSI0,
#[doc = "CMP0"]
pub CMP0: CMP0,
#[doc = "CMP1"]
pub CMP1: CMP1,
#[doc = "CMP2"]
pub CMP2: CMP2,
#[doc = "ELS"]
pub ELS: ELS,
#[doc = "TDET0"]
pub TDET0: TDET0,
#[doc = "VBAT0"]
pub VBAT0: VBAT0,
#[doc = "TRNG0"]
pub TRNG0: TRNG0,
#[doc = "EIM0"]
pub EIM0: EIM0,
#[doc = "ERM0"]
pub ERM0: ERM0,
#[doc = "INTM0"]
pub INTM0: INTM0,
#[doc = "DMA0"]
pub DMA0: DMA0,
#[doc = "DMA1"]
pub DMA1: DMA1,
#[doc = "EDMA_0_TCD"]
pub EDMA_0_TCD: EDMA_0_TCD,
#[doc = "SCT0"]
pub SCT0: SCT0,
#[doc = "LPSPI0"]
pub LPSPI0: LPSPI0,
#[doc = "LPSPI1"]
pub LPSPI1: LPSPI1,
#[doc = "LPSPI2"]
pub LPSPI2: LPSPI2,
#[doc = "LPSPI3"]
pub LPSPI3: LPSPI3,
#[doc = "LPSPI4"]
pub LPSPI4: LPSPI4,
#[doc = "LPSPI5"]
pub LPSPI5: LPSPI5,
#[doc = "LPSPI6"]
pub LPSPI6: LPSPI6,
#[doc = "LPSPI7"]
pub LPSPI7: LPSPI7,
#[doc = "LPSPI8"]
pub LPSPI8: LPSPI8,
#[doc = "LPSPI9"]
pub LPSPI9: LPSPI9,
#[doc = "LPUART0"]
pub LPUART0: LPUART0,
#[doc = "LPUART1"]
pub LPUART1: LPUART1,
#[doc = "LPUART2"]
pub LPUART2: LPUART2,
#[doc = "LPUART3"]
pub LPUART3: LPUART3,
#[doc = "LPUART4"]
pub LPUART4: LPUART4,
#[doc = "LPUART5"]
pub LPUART5: LPUART5,
#[doc = "LPUART6"]
pub LPUART6: LPUART6,
#[doc = "LPUART7"]
pub LPUART7: LPUART7,
#[doc = "LPUART8"]
pub LPUART8: LPUART8,
#[doc = "LPUART9"]
pub LPUART9: LPUART9,
#[doc = "LP_FLEXCOMM0"]
pub LP_FLEXCOMM0: LP_FLEXCOMM0,
#[doc = "LP_FLEXCOMM1"]
pub LP_FLEXCOMM1: LP_FLEXCOMM1,
#[doc = "LP_FLEXCOMM2"]
pub LP_FLEXCOMM2: LP_FLEXCOMM2,
#[doc = "LP_FLEXCOMM3"]
pub LP_FLEXCOMM3: LP_FLEXCOMM3,
#[doc = "LP_FLEXCOMM4"]
pub LP_FLEXCOMM4: LP_FLEXCOMM4,
#[doc = "LP_FLEXCOMM5"]
pub LP_FLEXCOMM5: LP_FLEXCOMM5,
#[doc = "LP_FLEXCOMM6"]
pub LP_FLEXCOMM6: LP_FLEXCOMM6,
#[doc = "LP_FLEXCOMM7"]
pub LP_FLEXCOMM7: LP_FLEXCOMM7,
#[doc = "LP_FLEXCOMM8"]
pub LP_FLEXCOMM8: LP_FLEXCOMM8,
#[doc = "LP_FLEXCOMM9"]
pub LP_FLEXCOMM9: LP_FLEXCOMM9,
#[doc = "LPI2C0"]
pub LPI2C0: LPI2C0,
#[doc = "LPI2C1"]
pub LPI2C1: LPI2C1,
#[doc = "LPI2C2"]
pub LPI2C2: LPI2C2,
#[doc = "LPI2C3"]
pub LPI2C3: LPI2C3,
#[doc = "LPI2C4"]
pub LPI2C4: LPI2C4,
#[doc = "LPI2C5"]
pub LPI2C5: LPI2C5,
#[doc = "LPI2C6"]
pub LPI2C6: LPI2C6,
#[doc = "LPI2C7"]
pub LPI2C7: LPI2C7,
#[doc = "LPI2C8"]
pub LPI2C8: LPI2C8,
#[doc = "LPI2C9"]
pub LPI2C9: LPI2C9,
#[doc = "GPIO0"]
pub GPIO0: GPIO0,
#[doc = "GPIO5"]
pub GPIO5: GPIO5,
#[doc = "GPIO1"]
pub GPIO1: GPIO1,
#[doc = "GPIO2"]
pub GPIO2: GPIO2,
#[doc = "GPIO3"]
pub GPIO3: GPIO3,
#[doc = "GPIO4"]
pub GPIO4: GPIO4,
#[doc = "EDMA_1_TCD"]
pub EDMA_1_TCD: EDMA_1_TCD,
#[doc = "SEMA42_0"]
pub SEMA42_0: SEMA42_0,
#[doc = "MAILBOX"]
pub MAILBOX: MAILBOX,
#[doc = "CDOG0"]
pub CDOG0: CDOG0,
#[doc = "CDOG1"]
pub CDOG1: CDOG1,
#[doc = "DM0"]
pub DM0: DM0,
#[doc = "POWERQUAD"]
pub POWERQUAD: POWERQUAD,
#[doc = "EWM0"]
pub EWM0: EWM0,
#[doc = "CMX_PERFMON0"]
pub CMX_PERFMON0: CMX_PERFMON0,
#[doc = "CMX_PERFMON1"]
pub CMX_PERFMON1: CMX_PERFMON1,
#[doc = "TRDC"]
pub TRDC: TRDC,
#[doc = "FLEXSPI0"]
pub FLEXSPI0: FLEXSPI0,
#[doc = "OTPC0"]
pub OTPC0: OTPC0,
#[doc = "CRC0"]
pub CRC0: CRC0,
#[doc = "NPX0"]
pub NPX0: NPX0,
#[doc = "PWM0"]
pub PWM0: PWM0,
#[doc = "PWM1"]
pub PWM1: PWM1,
#[doc = "ENC0"]
pub ENC0: ENC0,
#[doc = "ENC1"]
pub ENC1: ENC1,
#[doc = "EVTG0"]
pub EVTG0: EVTG0,
#[doc = "CAN0"]
pub CAN0: CAN0,
#[doc = "CAN1"]
pub CAN1: CAN1,
#[doc = "USBDCD0"]
pub USBDCD0: USBDCD0,
#[doc = "USBFS0"]
pub USBFS0: USBFS0,
#[doc = "ENET0"]
pub ENET0: ENET0,
#[doc = "EMVSIM0"]
pub EMVSIM0: EMVSIM0,
#[doc = "EMVSIM1"]
pub EMVSIM1: EMVSIM1,
#[doc = "FLEXIO0"]
pub FLEXIO0: FLEXIO0,
#[doc = "SAI0"]
pub SAI0: SAI0,
#[doc = "SAI1"]
pub SAI1: SAI1,
#[doc = "SINC0"]
pub SINC0: SINC0,
#[doc = "USDHC0"]
pub USDHC0: USDHC0,
#[doc = "USBPHY"]
pub USBPHY: USBPHY,
#[doc = "USBHS1_PHY_DCD"]
pub USBHS1_PHY_DCD: USBHS1_PHY_DCD,
#[doc = "USBHS1__USBC"]
pub USBHS1__USBC: USBHS1__USBC,
#[doc = "USBHS1__USBNC"]
pub USBHS1__USBNC: USBHS1__USBNC,
#[doc = "PDM"]
pub PDM: PDM,
#[doc = "ADC0"]
pub ADC0: ADC0,
#[doc = "ADC1"]
pub ADC1: ADC1,
#[doc = "DAC0"]
pub DAC0: DAC0,
#[doc = "DAC1"]
pub DAC1: DAC1,
#[doc = "OPAMP0"]
pub OPAMP0: OPAMP0,
#[doc = "OPAMP1"]
pub OPAMP1: OPAMP1,
#[doc = "OPAMP2"]
pub OPAMP2: OPAMP2,
#[doc = "VREF0"]
pub VREF0: VREF0,
#[doc = "DAC2"]
pub DAC2: DAC2,
#[doc = "PORT1"]
pub PORT1: PORT1,
#[doc = "PORT2"]
pub PORT2: PORT2,
#[doc = "PORT3"]
pub PORT3: PORT3,
#[doc = "PORT4"]
pub PORT4: PORT4,
#[doc = "AHBSC"]
pub AHBSC: AHBSC,
#[doc = "SCnSCB"]
pub SCN_SCB: SCN_SCB,
#[doc = "SysTick0"]
pub SYS_TICK0: SYS_TICK0,
#[doc = "SAU"]
pub SAU: SAU,
}
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 {
SYSCON0: SYSCON0 {
_marker: PhantomData,
},
PINT0: PINT0 {
_marker: PhantomData,
},
INPUTMUX0: INPUTMUX0 {
_marker: PhantomData,
},
CTIMER0: CTIMER0 {
_marker: PhantomData,
},
CTIMER1: CTIMER1 {
_marker: PhantomData,
},
CTIMER2: CTIMER2 {
_marker: PhantomData,
},
CTIMER3: CTIMER3 {
_marker: PhantomData,
},
CTIMER4: CTIMER4 {
_marker: PhantomData,
},
FREQME0: FREQME0 {
_marker: PhantomData,
},
UTICK0: UTICK0 {
_marker: PhantomData,
},
MRT0: MRT0 {
_marker: PhantomData,
},
WWDT0: WWDT0 {
_marker: PhantomData,
},
WWDT1: WWDT1 {
_marker: PhantomData,
},
CACHE64_CTRL0: CACHE64_CTRL0 {
_marker: PhantomData,
},
CACHE64_POLSEL0: CACHE64_POLSEL0 {
_marker: PhantomData,
},
I3C0: I3C0 {
_marker: PhantomData,
},
I3C1: I3C1 {
_marker: PhantomData,
},
GDET0: GDET0 {
_marker: PhantomData,
},
GDET1: GDET1 {
_marker: PhantomData,
},
ITRC0: ITRC0 {
_marker: PhantomData,
},
PKC0: PKC0 {
_marker: PhantomData,
},
PUF: PUF {
_marker: PhantomData,
},
PUF_CTRL: PUF_CTRL {
_marker: PhantomData,
},
SM3_0: SM3_0 {
_marker: PhantomData,
},
BSP32_0: BSP32_0 {
_marker: PhantomData,
},
SMARTDMA0: SMARTDMA0 {
_marker: PhantomData,
},
PLU0: PLU0 {
_marker: PhantomData,
},
PORT0: PORT0 {
_marker: PhantomData,
},
PORT5: PORT5 {
_marker: PhantomData,
},
FMU0: FMU0 {
_marker: PhantomData,
},
SCG0: SCG0 {
_marker: PhantomData,
},
SPC0: SPC0 {
_marker: PhantomData,
},
WUU0: WUU0 {
_marker: PhantomData,
},
CMC0: CMC0 {
_marker: PhantomData,
},
OSTIMER0: OSTIMER0 {
_marker: PhantomData,
},
LPTMR0: LPTMR0 {
_marker: PhantomData,
},
LPTMR1: LPTMR1 {
_marker: PhantomData,
},
RTC0: RTC0 {
_marker: PhantomData,
},
RTC_SUBSYSTEM0: RTC_SUBSYSTEM0 {
_marker: PhantomData,
},
TSI0: TSI0 {
_marker: PhantomData,
},
CMP0: CMP0 {
_marker: PhantomData,
},
CMP1: CMP1 {
_marker: PhantomData,
},
CMP2: CMP2 {
_marker: PhantomData,
},
ELS: ELS {
_marker: PhantomData,
},
TDET0: TDET0 {
_marker: PhantomData,
},
VBAT0: VBAT0 {
_marker: PhantomData,
},
TRNG0: TRNG0 {
_marker: PhantomData,
},
EIM0: EIM0 {
_marker: PhantomData,
},
ERM0: ERM0 {
_marker: PhantomData,
},
INTM0: INTM0 {
_marker: PhantomData,
},
DMA0: DMA0 {
_marker: PhantomData,
},
DMA1: DMA1 {
_marker: PhantomData,
},
EDMA_0_TCD: EDMA_0_TCD {
_marker: PhantomData,
},
SCT0: SCT0 {
_marker: PhantomData,
},
LPSPI0: LPSPI0 {
_marker: PhantomData,
},
LPSPI1: LPSPI1 {
_marker: PhantomData,
},
LPSPI2: LPSPI2 {
_marker: PhantomData,
},
LPSPI3: LPSPI3 {
_marker: PhantomData,
},
LPSPI4: LPSPI4 {
_marker: PhantomData,
},
LPSPI5: LPSPI5 {
_marker: PhantomData,
},
LPSPI6: LPSPI6 {
_marker: PhantomData,
},
LPSPI7: LPSPI7 {
_marker: PhantomData,
},
LPSPI8: LPSPI8 {
_marker: PhantomData,
},
LPSPI9: LPSPI9 {
_marker: PhantomData,
},
LPUART0: LPUART0 {
_marker: PhantomData,
},
LPUART1: LPUART1 {
_marker: PhantomData,
},
LPUART2: LPUART2 {
_marker: PhantomData,
},
LPUART3: LPUART3 {
_marker: PhantomData,
},
LPUART4: LPUART4 {
_marker: PhantomData,
},
LPUART5: LPUART5 {
_marker: PhantomData,
},
LPUART6: LPUART6 {
_marker: PhantomData,
},
LPUART7: LPUART7 {
_marker: PhantomData,
},
LPUART8: LPUART8 {
_marker: PhantomData,
},
LPUART9: LPUART9 {
_marker: PhantomData,
},
LP_FLEXCOMM0: LP_FLEXCOMM0 {
_marker: PhantomData,
},
LP_FLEXCOMM1: LP_FLEXCOMM1 {
_marker: PhantomData,
},
LP_FLEXCOMM2: LP_FLEXCOMM2 {
_marker: PhantomData,
},
LP_FLEXCOMM3: LP_FLEXCOMM3 {
_marker: PhantomData,
},
LP_FLEXCOMM4: LP_FLEXCOMM4 {
_marker: PhantomData,
},
LP_FLEXCOMM5: LP_FLEXCOMM5 {
_marker: PhantomData,
},
LP_FLEXCOMM6: LP_FLEXCOMM6 {
_marker: PhantomData,
},
LP_FLEXCOMM7: LP_FLEXCOMM7 {
_marker: PhantomData,
},
LP_FLEXCOMM8: LP_FLEXCOMM8 {
_marker: PhantomData,
},
LP_FLEXCOMM9: LP_FLEXCOMM9 {
_marker: PhantomData,
},
LPI2C0: LPI2C0 {
_marker: PhantomData,
},
LPI2C1: LPI2C1 {
_marker: PhantomData,
},
LPI2C2: LPI2C2 {
_marker: PhantomData,
},
LPI2C3: LPI2C3 {
_marker: PhantomData,
},
LPI2C4: LPI2C4 {
_marker: PhantomData,
},
LPI2C5: LPI2C5 {
_marker: PhantomData,
},
LPI2C6: LPI2C6 {
_marker: PhantomData,
},
LPI2C7: LPI2C7 {
_marker: PhantomData,
},
LPI2C8: LPI2C8 {
_marker: PhantomData,
},
LPI2C9: LPI2C9 {
_marker: PhantomData,
},
GPIO0: GPIO0 {
_marker: PhantomData,
},
GPIO5: GPIO5 {
_marker: PhantomData,
},
GPIO1: GPIO1 {
_marker: PhantomData,
},
GPIO2: GPIO2 {
_marker: PhantomData,
},
GPIO3: GPIO3 {
_marker: PhantomData,
},
GPIO4: GPIO4 {
_marker: PhantomData,
},
EDMA_1_TCD: EDMA_1_TCD {
_marker: PhantomData,
},
SEMA42_0: SEMA42_0 {
_marker: PhantomData,
},
MAILBOX: MAILBOX {
_marker: PhantomData,
},
CDOG0: CDOG0 {
_marker: PhantomData,
},
CDOG1: CDOG1 {
_marker: PhantomData,
},
DM0: DM0 {
_marker: PhantomData,
},
POWERQUAD: POWERQUAD {
_marker: PhantomData,
},
EWM0: EWM0 {
_marker: PhantomData,
},
CMX_PERFMON0: CMX_PERFMON0 {
_marker: PhantomData,
},
CMX_PERFMON1: CMX_PERFMON1 {
_marker: PhantomData,
},
TRDC: TRDC {
_marker: PhantomData,
},
FLEXSPI0: FLEXSPI0 {
_marker: PhantomData,
},
OTPC0: OTPC0 {
_marker: PhantomData,
},
CRC0: CRC0 {
_marker: PhantomData,
},
NPX0: NPX0 {
_marker: PhantomData,
},
PWM0: PWM0 {
_marker: PhantomData,
},
PWM1: PWM1 {
_marker: PhantomData,
},
ENC0: ENC0 {
_marker: PhantomData,
},
ENC1: ENC1 {
_marker: PhantomData,
},
EVTG0: EVTG0 {
_marker: PhantomData,
},
CAN0: CAN0 {
_marker: PhantomData,
},
CAN1: CAN1 {
_marker: PhantomData,
},
USBDCD0: USBDCD0 {
_marker: PhantomData,
},
USBFS0: USBFS0 {
_marker: PhantomData,
},
ENET0: ENET0 {
_marker: PhantomData,
},
EMVSIM0: EMVSIM0 {
_marker: PhantomData,
},
EMVSIM1: EMVSIM1 {
_marker: PhantomData,
},
FLEXIO0: FLEXIO0 {
_marker: PhantomData,
},
SAI0: SAI0 {
_marker: PhantomData,
},
SAI1: SAI1 {
_marker: PhantomData,
},
SINC0: SINC0 {
_marker: PhantomData,
},
USDHC0: USDHC0 {
_marker: PhantomData,
},
USBPHY: USBPHY {
_marker: PhantomData,
},
USBHS1_PHY_DCD: USBHS1_PHY_DCD {
_marker: PhantomData,
},
USBHS1__USBC: USBHS1__USBC {
_marker: PhantomData,
},
USBHS1__USBNC: USBHS1__USBNC {
_marker: PhantomData,
},
PDM: PDM {
_marker: PhantomData,
},
ADC0: ADC0 {
_marker: PhantomData,
},
ADC1: ADC1 {
_marker: PhantomData,
},
DAC0: DAC0 {
_marker: PhantomData,
},
DAC1: DAC1 {
_marker: PhantomData,
},
OPAMP0: OPAMP0 {
_marker: PhantomData,
},
OPAMP1: OPAMP1 {
_marker: PhantomData,
},
OPAMP2: OPAMP2 {
_marker: PhantomData,
},
VREF0: VREF0 {
_marker: PhantomData,
},
DAC2: DAC2 {
_marker: PhantomData,
},
PORT1: PORT1 {
_marker: PhantomData,
},
PORT2: PORT2 {
_marker: PhantomData,
},
PORT3: PORT3 {
_marker: PhantomData,
},
PORT4: PORT4 {
_marker: PhantomData,
},
AHBSC: AHBSC {
_marker: PhantomData,
},
SCN_SCB: SCN_SCB {
_marker: PhantomData,
},
SYS_TICK0: SYS_TICK0 {
_marker: PhantomData,
},
SAU: SAU {
_marker: PhantomData,
},
}
}
}