1#![doc = "Peripheral access API for ESP32-P4 microcontrollers (generated using svd2rust v0.33.0 ( ))\n\nYou can find an overview of the generated API [here].\n\nAPI features to be included in the [next] svd2rust release can be generated by cloning the svd2rust [repository], checking out the above commit, and running `cargo doc --open`.\n\n[here]: https://docs.rs/svd2rust/0.33.0/svd2rust/#peripheral-api\n[next]: https://github.com/rust-embedded/svd2rust/blob/master/CHANGELOG.md#unreleased\n[repository]: https://github.com/rust-embedded/svd2rust"]
2#![allow(non_camel_case_types)]
3#![allow(non_snake_case)]
4#![doc(html_logo_url = "https://avatars.githubusercontent.com/u/46717278")]
5#![no_std]
6use core::marker::PhantomData;
7use core::ops::Deref;
8#[doc = r"Number available in the NVIC for configuring priority"]
9pub const NVIC_PRIO_BITS: u8 = 0;
10#[allow(unused_imports)]
11use generic::*;
12#[doc = r"Common register and bit access and modify traits"]
13pub mod generic;
14#[cfg(feature = "rt")]
15extern "C" {
16 fn LP_WDT();
17 fn LP_TIMER0();
18 fn LP_TIMER1();
19 fn PMU0();
20 fn PMU1();
21 fn LP_ANA();
22 fn LP_ADC();
23 fn LP_GPIO();
24 fn LP_I2C0();
25 fn LP_I2S0();
26 fn LP_TOUCH();
27 fn LP_TSENS();
28 fn LP_UART();
29 fn LP_SYS();
30 fn LP_HUK();
31 fn USB_DEVICE();
32 fn DMA();
33 fn SPI2();
34 fn SPI3();
35 fn I2S0();
36 fn I2S1();
37 fn I2S2();
38 fn UHCI0();
39 fn UART0();
40 fn UART1();
41 fn UART2();
42 fn UART3();
43 fn UART4();
44 fn PWM0();
45 fn PWM1();
46 fn TWAI0();
47 fn TWAI1();
48 fn TWAI2();
49 fn RMT();
50 fn I2C0();
51 fn I2C1();
52 fn TG0_T0();
53 fn TG0_T1();
54 fn TG0_WDT();
55 fn TG1_T0();
56 fn TG1_T1();
57 fn TG1_WDT();
58 fn LEDC();
59 fn SYSTIMER_TARGET0();
60 fn SYSTIMER_TARGET1();
61 fn SYSTIMER_TARGET2();
62 fn AHB_PDMA_IN_CH0();
63 fn AHB_PDMA_IN_CH1();
64 fn AHB_PDMA_IN_CH2();
65 fn AHB_PDMA_OUT_CH0();
66 fn AHB_PDMA_OUT_CH1();
67 fn AHB_PDMA_OUT_CH2();
68 fn AXI_PDMA_IN_CH0();
69 fn AXI_PDMA_IN_CH1();
70 fn AXI_PDMA_IN_CH2();
71 fn AXI_PDMA_OUT_CH0();
72 fn AXI_PDMA_OUT_CH1();
73 fn AXI_PDMA_OUT_CH2();
74 fn RSA();
75 fn AES();
76 fn SHA();
77 fn ECC();
78 fn GPIO();
79 fn GPIO_INT1();
80 fn GPIO_INT2();
81 fn GPIO_INT3();
82 fn GPIO_PAD_COMP();
83 fn CACHE();
84 fn CSI_BRIDGE();
85 fn DSI_BRIDGE();
86 fn CSI();
87 fn DSI();
88 fn JPEG();
89 fn PPA();
90 fn ISP();
91 fn I3C();
92 fn I3C_SLV();
93 fn HP_SYS();
94 fn PCNT();
95 fn PAU();
96 fn PARLIO_RX();
97 fn PARLIO_TX();
98 fn H264_DMA2D_OUT_CH0();
99 fn H264_DMA2D_OUT_CH1();
100 fn H264_DMA2D_OUT_CH2();
101 fn H264_DMA2D_OUT_CH3();
102 fn H264_DMA2D_OUT_CH4();
103 fn H264_DMA2D_IN_CH0();
104 fn H264_DMA2D_IN_CH1();
105 fn H264_DMA2D_IN_CH2();
106 fn H264_DMA2D_IN_CH3();
107 fn H264_DMA2D_IN_CH4();
108 fn H264_DMA2D_IN_CH5();
109 fn H264_REG();
110 fn ASSIST_DEBUG();
111}
112#[doc(hidden)]
113#[repr(C)]
114pub union Vector {
115 pub _handler: unsafe extern "C" fn(),
116 pub _reserved: usize,
117}
118#[cfg(feature = "rt")]
119#[doc(hidden)]
120#[link_section = ".rwtext"]
121#[no_mangle]
122pub static __EXTERNAL_INTERRUPTS: [Vector; 128] = [
123 Vector { _reserved: 0 },
124 Vector { _handler: LP_WDT },
125 Vector {
126 _handler: LP_TIMER0,
127 },
128 Vector {
129 _handler: LP_TIMER1,
130 },
131 Vector { _reserved: 0 },
132 Vector { _reserved: 0 },
133 Vector { _handler: PMU0 },
134 Vector { _handler: PMU1 },
135 Vector { _handler: LP_ANA },
136 Vector { _handler: LP_ADC },
137 Vector { _handler: LP_GPIO },
138 Vector { _handler: LP_I2C0 },
139 Vector { _handler: LP_I2S0 },
140 Vector { _reserved: 0 },
141 Vector { _handler: LP_TOUCH },
142 Vector { _handler: LP_TSENS },
143 Vector { _handler: LP_UART },
144 Vector { _reserved: 0 },
145 Vector { _reserved: 0 },
146 Vector { _handler: LP_SYS },
147 Vector { _handler: LP_HUK },
148 Vector { _reserved: 0 },
149 Vector {
150 _handler: USB_DEVICE,
151 },
152 Vector { _reserved: 0 },
153 Vector { _handler: DMA },
154 Vector { _handler: SPI2 },
155 Vector { _handler: SPI3 },
156 Vector { _handler: I2S0 },
157 Vector { _handler: I2S1 },
158 Vector { _handler: I2S2 },
159 Vector { _handler: UHCI0 },
160 Vector { _handler: UART0 },
161 Vector { _handler: UART1 },
162 Vector { _handler: UART2 },
163 Vector { _handler: UART3 },
164 Vector { _handler: UART4 },
165 Vector { _reserved: 0 },
166 Vector { _reserved: 0 },
167 Vector { _handler: PWM0 },
168 Vector { _handler: PWM1 },
169 Vector { _handler: TWAI0 },
170 Vector { _handler: TWAI1 },
171 Vector { _handler: TWAI2 },
172 Vector { _handler: RMT },
173 Vector { _handler: I2C0 },
174 Vector { _handler: I2C1 },
175 Vector { _handler: TG0_T0 },
176 Vector { _handler: TG0_T1 },
177 Vector { _handler: TG0_WDT },
178 Vector { _handler: TG1_T0 },
179 Vector { _handler: TG1_T1 },
180 Vector { _handler: TG1_WDT },
181 Vector { _handler: LEDC },
182 Vector {
183 _handler: SYSTIMER_TARGET0,
184 },
185 Vector {
186 _handler: SYSTIMER_TARGET1,
187 },
188 Vector {
189 _handler: SYSTIMER_TARGET2,
190 },
191 Vector {
192 _handler: AHB_PDMA_IN_CH0,
193 },
194 Vector {
195 _handler: AHB_PDMA_IN_CH1,
196 },
197 Vector {
198 _handler: AHB_PDMA_IN_CH2,
199 },
200 Vector {
201 _handler: AHB_PDMA_OUT_CH0,
202 },
203 Vector {
204 _handler: AHB_PDMA_OUT_CH1,
205 },
206 Vector {
207 _handler: AHB_PDMA_OUT_CH2,
208 },
209 Vector {
210 _handler: AXI_PDMA_IN_CH0,
211 },
212 Vector {
213 _handler: AXI_PDMA_IN_CH1,
214 },
215 Vector {
216 _handler: AXI_PDMA_IN_CH2,
217 },
218 Vector {
219 _handler: AXI_PDMA_OUT_CH0,
220 },
221 Vector {
222 _handler: AXI_PDMA_OUT_CH1,
223 },
224 Vector {
225 _handler: AXI_PDMA_OUT_CH2,
226 },
227 Vector { _handler: RSA },
228 Vector { _handler: AES },
229 Vector { _handler: SHA },
230 Vector { _handler: ECC },
231 Vector { _reserved: 0 },
232 Vector { _reserved: 0 },
233 Vector { _handler: GPIO },
234 Vector {
235 _handler: GPIO_INT1,
236 },
237 Vector {
238 _handler: GPIO_INT2,
239 },
240 Vector {
241 _handler: GPIO_INT3,
242 },
243 Vector {
244 _handler: GPIO_PAD_COMP,
245 },
246 Vector { _reserved: 0 },
247 Vector { _reserved: 0 },
248 Vector { _reserved: 0 },
249 Vector { _reserved: 0 },
250 Vector { _handler: CACHE },
251 Vector { _reserved: 0 },
252 Vector {
253 _handler: CSI_BRIDGE,
254 },
255 Vector {
256 _handler: DSI_BRIDGE,
257 },
258 Vector { _handler: CSI },
259 Vector { _handler: DSI },
260 Vector { _reserved: 0 },
261 Vector { _reserved: 0 },
262 Vector { _reserved: 0 },
263 Vector { _reserved: 0 },
264 Vector { _reserved: 0 },
265 Vector { _reserved: 0 },
266 Vector { _handler: JPEG },
267 Vector { _handler: PPA },
268 Vector { _reserved: 0 },
269 Vector { _reserved: 0 },
270 Vector { _reserved: 0 },
271 Vector { _handler: ISP },
272 Vector { _handler: I3C },
273 Vector { _handler: I3C_SLV },
274 Vector { _reserved: 0 },
275 Vector { _reserved: 0 },
276 Vector { _reserved: 0 },
277 Vector { _reserved: 0 },
278 Vector { _reserved: 0 },
279 Vector { _reserved: 0 },
280 Vector { _reserved: 0 },
281 Vector { _handler: HP_SYS },
282 Vector { _handler: PCNT },
283 Vector { _handler: PAU },
284 Vector {
285 _handler: PARLIO_RX,
286 },
287 Vector {
288 _handler: PARLIO_TX,
289 },
290 Vector {
291 _handler: H264_DMA2D_OUT_CH0,
292 },
293 Vector {
294 _handler: H264_DMA2D_OUT_CH1,
295 },
296 Vector {
297 _handler: H264_DMA2D_OUT_CH2,
298 },
299 Vector {
300 _handler: H264_DMA2D_OUT_CH3,
301 },
302 Vector {
303 _handler: H264_DMA2D_OUT_CH4,
304 },
305 Vector {
306 _handler: H264_DMA2D_IN_CH0,
307 },
308 Vector {
309 _handler: H264_DMA2D_IN_CH1,
310 },
311 Vector {
312 _handler: H264_DMA2D_IN_CH2,
313 },
314 Vector {
315 _handler: H264_DMA2D_IN_CH3,
316 },
317 Vector {
318 _handler: H264_DMA2D_IN_CH4,
319 },
320 Vector {
321 _handler: H264_DMA2D_IN_CH5,
322 },
323 Vector { _handler: H264_REG },
324 Vector {
325 _handler: ASSIST_DEBUG,
326 },
327];
328#[doc(hidden)]
329pub mod interrupt;
330pub use self::interrupt::Interrupt;
331#[doc = "ADC (Analog to Digital Converter)"]
332pub struct ADC {
333 _marker: PhantomData<*const ()>,
334}
335unsafe impl Send for ADC {}
336impl ADC {
337 #[doc = r"Pointer to the register block"]
338 pub const PTR: *const adc::RegisterBlock = 0x500d_e000 as *const _;
339 #[doc = r"Return the pointer to the register block"]
340 #[inline(always)]
341 pub const fn ptr() -> *const adc::RegisterBlock {
342 Self::PTR
343 }
344 #[doc = r" Steal an instance of this peripheral"]
345 #[doc = r""]
346 #[doc = r" # Safety"]
347 #[doc = r""]
348 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
349 #[doc = r" that may race with any existing instances, for example by only"]
350 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
351 #[doc = r" original peripheral and using critical sections to coordinate"]
352 #[doc = r" access between multiple new instances."]
353 #[doc = r""]
354 #[doc = r" Additionally, other software such as HALs may rely on only one"]
355 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
356 #[doc = r" no stolen instances are passed to such software."]
357 pub unsafe fn steal() -> Self {
358 Self {
359 _marker: PhantomData,
360 }
361 }
362}
363impl Deref for ADC {
364 type Target = adc::RegisterBlock;
365 #[inline(always)]
366 fn deref(&self) -> &Self::Target {
367 unsafe { &*Self::PTR }
368 }
369}
370impl core::fmt::Debug for ADC {
371 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
372 f.debug_struct("ADC").finish()
373 }
374}
375#[doc = "ADC (Analog to Digital Converter)"]
376pub mod adc;
377#[doc = "AES (Advanced Encryption Standard) Accelerator"]
378pub struct AES {
379 _marker: PhantomData<*const ()>,
380}
381unsafe impl Send for AES {}
382impl AES {
383 #[doc = r"Pointer to the register block"]
384 pub const PTR: *const aes::RegisterBlock = 0x5009_0000 as *const _;
385 #[doc = r"Return the pointer to the register block"]
386 #[inline(always)]
387 pub const fn ptr() -> *const aes::RegisterBlock {
388 Self::PTR
389 }
390 #[doc = r" Steal an instance of this peripheral"]
391 #[doc = r""]
392 #[doc = r" # Safety"]
393 #[doc = r""]
394 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
395 #[doc = r" that may race with any existing instances, for example by only"]
396 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
397 #[doc = r" original peripheral and using critical sections to coordinate"]
398 #[doc = r" access between multiple new instances."]
399 #[doc = r""]
400 #[doc = r" Additionally, other software such as HALs may rely on only one"]
401 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
402 #[doc = r" no stolen instances are passed to such software."]
403 pub unsafe fn steal() -> Self {
404 Self {
405 _marker: PhantomData,
406 }
407 }
408}
409impl Deref for AES {
410 type Target = aes::RegisterBlock;
411 #[inline(always)]
412 fn deref(&self) -> &Self::Target {
413 unsafe { &*Self::PTR }
414 }
415}
416impl core::fmt::Debug for AES {
417 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
418 f.debug_struct("AES").finish()
419 }
420}
421#[doc = "AES (Advanced Encryption Standard) Accelerator"]
422pub mod aes;
423#[doc = "AHB_DMA Peripheral"]
424pub struct AHB_DMA {
425 _marker: PhantomData<*const ()>,
426}
427unsafe impl Send for AHB_DMA {}
428impl AHB_DMA {
429 #[doc = r"Pointer to the register block"]
430 pub const PTR: *const ahb_dma::RegisterBlock = 0x5008_5000 as *const _;
431 #[doc = r"Return the pointer to the register block"]
432 #[inline(always)]
433 pub const fn ptr() -> *const ahb_dma::RegisterBlock {
434 Self::PTR
435 }
436 #[doc = r" Steal an instance of this peripheral"]
437 #[doc = r""]
438 #[doc = r" # Safety"]
439 #[doc = r""]
440 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
441 #[doc = r" that may race with any existing instances, for example by only"]
442 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
443 #[doc = r" original peripheral and using critical sections to coordinate"]
444 #[doc = r" access between multiple new instances."]
445 #[doc = r""]
446 #[doc = r" Additionally, other software such as HALs may rely on only one"]
447 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
448 #[doc = r" no stolen instances are passed to such software."]
449 pub unsafe fn steal() -> Self {
450 Self {
451 _marker: PhantomData,
452 }
453 }
454}
455impl Deref for AHB_DMA {
456 type Target = ahb_dma::RegisterBlock;
457 #[inline(always)]
458 fn deref(&self) -> &Self::Target {
459 unsafe { &*Self::PTR }
460 }
461}
462impl core::fmt::Debug for AHB_DMA {
463 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
464 f.debug_struct("AHB_DMA").finish()
465 }
466}
467#[doc = "AHB_DMA Peripheral"]
468pub mod ahb_dma;
469#[doc = "LP_I2C_ANA_MST Peripheral"]
470pub struct LP_I2C_ANA_MST {
471 _marker: PhantomData<*const ()>,
472}
473unsafe impl Send for LP_I2C_ANA_MST {}
474impl LP_I2C_ANA_MST {
475 #[doc = r"Pointer to the register block"]
476 pub const PTR: *const lp_i2c_ana_mst::RegisterBlock = 0x5012_4000 as *const _;
477 #[doc = r"Return the pointer to the register block"]
478 #[inline(always)]
479 pub const fn ptr() -> *const lp_i2c_ana_mst::RegisterBlock {
480 Self::PTR
481 }
482 #[doc = r" Steal an instance of this peripheral"]
483 #[doc = r""]
484 #[doc = r" # Safety"]
485 #[doc = r""]
486 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
487 #[doc = r" that may race with any existing instances, for example by only"]
488 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
489 #[doc = r" original peripheral and using critical sections to coordinate"]
490 #[doc = r" access between multiple new instances."]
491 #[doc = r""]
492 #[doc = r" Additionally, other software such as HALs may rely on only one"]
493 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
494 #[doc = r" no stolen instances are passed to such software."]
495 pub unsafe fn steal() -> Self {
496 Self {
497 _marker: PhantomData,
498 }
499 }
500}
501impl Deref for LP_I2C_ANA_MST {
502 type Target = lp_i2c_ana_mst::RegisterBlock;
503 #[inline(always)]
504 fn deref(&self) -> &Self::Target {
505 unsafe { &*Self::PTR }
506 }
507}
508impl core::fmt::Debug for LP_I2C_ANA_MST {
509 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
510 f.debug_struct("LP_I2C_ANA_MST").finish()
511 }
512}
513#[doc = "LP_I2C_ANA_MST Peripheral"]
514pub mod lp_i2c_ana_mst;
515#[doc = "Debug Assist"]
516pub struct ASSIST_DEBUG {
517 _marker: PhantomData<*const ()>,
518}
519unsafe impl Send for ASSIST_DEBUG {}
520impl ASSIST_DEBUG {
521 #[doc = r"Pointer to the register block"]
522 pub const PTR: *const assist_debug::RegisterBlock = 0x3ff0_6000 as *const _;
523 #[doc = r"Return the pointer to the register block"]
524 #[inline(always)]
525 pub const fn ptr() -> *const assist_debug::RegisterBlock {
526 Self::PTR
527 }
528 #[doc = r" Steal an instance of this peripheral"]
529 #[doc = r""]
530 #[doc = r" # Safety"]
531 #[doc = r""]
532 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
533 #[doc = r" that may race with any existing instances, for example by only"]
534 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
535 #[doc = r" original peripheral and using critical sections to coordinate"]
536 #[doc = r" access between multiple new instances."]
537 #[doc = r""]
538 #[doc = r" Additionally, other software such as HALs may rely on only one"]
539 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
540 #[doc = r" no stolen instances are passed to such software."]
541 pub unsafe fn steal() -> Self {
542 Self {
543 _marker: PhantomData,
544 }
545 }
546}
547impl Deref for ASSIST_DEBUG {
548 type Target = assist_debug::RegisterBlock;
549 #[inline(always)]
550 fn deref(&self) -> &Self::Target {
551 unsafe { &*Self::PTR }
552 }
553}
554impl core::fmt::Debug for ASSIST_DEBUG {
555 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
556 f.debug_struct("ASSIST_DEBUG").finish()
557 }
558}
559#[doc = "Debug Assist"]
560pub mod assist_debug;
561#[doc = "AXI_DMA Peripheral"]
562pub struct AXI_DMA {
563 _marker: PhantomData<*const ()>,
564}
565unsafe impl Send for AXI_DMA {}
566impl AXI_DMA {
567 #[doc = r"Pointer to the register block"]
568 pub const PTR: *const axi_dma::RegisterBlock = 0x5008_a000 as *const _;
569 #[doc = r"Return the pointer to the register block"]
570 #[inline(always)]
571 pub const fn ptr() -> *const axi_dma::RegisterBlock {
572 Self::PTR
573 }
574 #[doc = r" Steal an instance of this peripheral"]
575 #[doc = r""]
576 #[doc = r" # Safety"]
577 #[doc = r""]
578 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
579 #[doc = r" that may race with any existing instances, for example by only"]
580 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
581 #[doc = r" original peripheral and using critical sections to coordinate"]
582 #[doc = r" access between multiple new instances."]
583 #[doc = r""]
584 #[doc = r" Additionally, other software such as HALs may rely on only one"]
585 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
586 #[doc = r" no stolen instances are passed to such software."]
587 pub unsafe fn steal() -> Self {
588 Self {
589 _marker: PhantomData,
590 }
591 }
592}
593impl Deref for AXI_DMA {
594 type Target = axi_dma::RegisterBlock;
595 #[inline(always)]
596 fn deref(&self) -> &Self::Target {
597 unsafe { &*Self::PTR }
598 }
599}
600impl core::fmt::Debug for AXI_DMA {
601 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
602 f.debug_struct("AXI_DMA").finish()
603 }
604}
605#[doc = "AXI_DMA Peripheral"]
606pub mod axi_dma;
607#[doc = "BITSCRAMBLER Peripheral"]
608pub struct BITSCRAMBLER {
609 _marker: PhantomData<*const ()>,
610}
611unsafe impl Send for BITSCRAMBLER {}
612impl BITSCRAMBLER {
613 #[doc = r"Pointer to the register block"]
614 pub const PTR: *const bitscrambler::RegisterBlock = 0x500a_3000 as *const _;
615 #[doc = r"Return the pointer to the register block"]
616 #[inline(always)]
617 pub const fn ptr() -> *const bitscrambler::RegisterBlock {
618 Self::PTR
619 }
620 #[doc = r" Steal an instance of this peripheral"]
621 #[doc = r""]
622 #[doc = r" # Safety"]
623 #[doc = r""]
624 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
625 #[doc = r" that may race with any existing instances, for example by only"]
626 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
627 #[doc = r" original peripheral and using critical sections to coordinate"]
628 #[doc = r" access between multiple new instances."]
629 #[doc = r""]
630 #[doc = r" Additionally, other software such as HALs may rely on only one"]
631 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
632 #[doc = r" no stolen instances are passed to such software."]
633 pub unsafe fn steal() -> Self {
634 Self {
635 _marker: PhantomData,
636 }
637 }
638}
639impl Deref for BITSCRAMBLER {
640 type Target = bitscrambler::RegisterBlock;
641 #[inline(always)]
642 fn deref(&self) -> &Self::Target {
643 unsafe { &*Self::PTR }
644 }
645}
646impl core::fmt::Debug for BITSCRAMBLER {
647 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
648 f.debug_struct("BITSCRAMBLER").finish()
649 }
650}
651#[doc = "BITSCRAMBLER Peripheral"]
652pub mod bitscrambler;
653#[doc = "CACHE Peripheral"]
654pub struct CACHE {
655 _marker: PhantomData<*const ()>,
656}
657unsafe impl Send for CACHE {}
658impl CACHE {
659 #[doc = r"Pointer to the register block"]
660 pub const PTR: *const cache::RegisterBlock = 0x3ff1_0000 as *const _;
661 #[doc = r"Return the pointer to the register block"]
662 #[inline(always)]
663 pub const fn ptr() -> *const cache::RegisterBlock {
664 Self::PTR
665 }
666 #[doc = r" Steal an instance of this peripheral"]
667 #[doc = r""]
668 #[doc = r" # Safety"]
669 #[doc = r""]
670 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
671 #[doc = r" that may race with any existing instances, for example by only"]
672 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
673 #[doc = r" original peripheral and using critical sections to coordinate"]
674 #[doc = r" access between multiple new instances."]
675 #[doc = r""]
676 #[doc = r" Additionally, other software such as HALs may rely on only one"]
677 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
678 #[doc = r" no stolen instances are passed to such software."]
679 pub unsafe fn steal() -> Self {
680 Self {
681 _marker: PhantomData,
682 }
683 }
684}
685impl Deref for CACHE {
686 type Target = cache::RegisterBlock;
687 #[inline(always)]
688 fn deref(&self) -> &Self::Target {
689 unsafe { &*Self::PTR }
690 }
691}
692impl core::fmt::Debug for CACHE {
693 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
694 f.debug_struct("CACHE").finish()
695 }
696}
697#[doc = "CACHE Peripheral"]
698pub mod cache;
699#[doc = "Interrupt Controller (Core 0)"]
700pub struct INTERRUPT_CORE0 {
701 _marker: PhantomData<*const ()>,
702}
703unsafe impl Send for INTERRUPT_CORE0 {}
704impl INTERRUPT_CORE0 {
705 #[doc = r"Pointer to the register block"]
706 pub const PTR: *const interrupt_core0::RegisterBlock = 0x500d_6000 as *const _;
707 #[doc = r"Return the pointer to the register block"]
708 #[inline(always)]
709 pub const fn ptr() -> *const interrupt_core0::RegisterBlock {
710 Self::PTR
711 }
712 #[doc = r" Steal an instance of this peripheral"]
713 #[doc = r""]
714 #[doc = r" # Safety"]
715 #[doc = r""]
716 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
717 #[doc = r" that may race with any existing instances, for example by only"]
718 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
719 #[doc = r" original peripheral and using critical sections to coordinate"]
720 #[doc = r" access between multiple new instances."]
721 #[doc = r""]
722 #[doc = r" Additionally, other software such as HALs may rely on only one"]
723 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
724 #[doc = r" no stolen instances are passed to such software."]
725 pub unsafe fn steal() -> Self {
726 Self {
727 _marker: PhantomData,
728 }
729 }
730}
731impl Deref for INTERRUPT_CORE0 {
732 type Target = interrupt_core0::RegisterBlock;
733 #[inline(always)]
734 fn deref(&self) -> &Self::Target {
735 unsafe { &*Self::PTR }
736 }
737}
738impl core::fmt::Debug for INTERRUPT_CORE0 {
739 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
740 f.debug_struct("INTERRUPT_CORE0").finish()
741 }
742}
743#[doc = "Interrupt Controller (Core 0)"]
744pub mod interrupt_core0;
745#[doc = "Interrupt Controller (Core 1)"]
746pub struct INTERRUPT_CORE1 {
747 _marker: PhantomData<*const ()>,
748}
749unsafe impl Send for INTERRUPT_CORE1 {}
750impl INTERRUPT_CORE1 {
751 #[doc = r"Pointer to the register block"]
752 pub const PTR: *const interrupt_core1::RegisterBlock = 0x500d_6800 as *const _;
753 #[doc = r"Return the pointer to the register block"]
754 #[inline(always)]
755 pub const fn ptr() -> *const interrupt_core1::RegisterBlock {
756 Self::PTR
757 }
758 #[doc = r" Steal an instance of this peripheral"]
759 #[doc = r""]
760 #[doc = r" # Safety"]
761 #[doc = r""]
762 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
763 #[doc = r" that may race with any existing instances, for example by only"]
764 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
765 #[doc = r" original peripheral and using critical sections to coordinate"]
766 #[doc = r" access between multiple new instances."]
767 #[doc = r""]
768 #[doc = r" Additionally, other software such as HALs may rely on only one"]
769 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
770 #[doc = r" no stolen instances are passed to such software."]
771 pub unsafe fn steal() -> Self {
772 Self {
773 _marker: PhantomData,
774 }
775 }
776}
777impl Deref for INTERRUPT_CORE1 {
778 type Target = interrupt_core1::RegisterBlock;
779 #[inline(always)]
780 fn deref(&self) -> &Self::Target {
781 unsafe { &*Self::PTR }
782 }
783}
784impl core::fmt::Debug for INTERRUPT_CORE1 {
785 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
786 f.debug_struct("INTERRUPT_CORE1").finish()
787 }
788}
789#[doc = "Interrupt Controller (Core 1)"]
790pub mod interrupt_core1;
791#[doc = "MIPI Camera Interface Bridge"]
792pub struct MIPI_CSI_BRIDGE {
793 _marker: PhantomData<*const ()>,
794}
795unsafe impl Send for MIPI_CSI_BRIDGE {}
796impl MIPI_CSI_BRIDGE {
797 #[doc = r"Pointer to the register block"]
798 pub const PTR: *const mipi_csi_bridge::RegisterBlock = 0x5009_f800 as *const _;
799 #[doc = r"Return the pointer to the register block"]
800 #[inline(always)]
801 pub const fn ptr() -> *const mipi_csi_bridge::RegisterBlock {
802 Self::PTR
803 }
804 #[doc = r" Steal an instance of this peripheral"]
805 #[doc = r""]
806 #[doc = r" # Safety"]
807 #[doc = r""]
808 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
809 #[doc = r" that may race with any existing instances, for example by only"]
810 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
811 #[doc = r" original peripheral and using critical sections to coordinate"]
812 #[doc = r" access between multiple new instances."]
813 #[doc = r""]
814 #[doc = r" Additionally, other software such as HALs may rely on only one"]
815 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
816 #[doc = r" no stolen instances are passed to such software."]
817 pub unsafe fn steal() -> Self {
818 Self {
819 _marker: PhantomData,
820 }
821 }
822}
823impl Deref for MIPI_CSI_BRIDGE {
824 type Target = mipi_csi_bridge::RegisterBlock;
825 #[inline(always)]
826 fn deref(&self) -> &Self::Target {
827 unsafe { &*Self::PTR }
828 }
829}
830impl core::fmt::Debug for MIPI_CSI_BRIDGE {
831 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
832 f.debug_struct("MIPI_CSI_BRIDGE").finish()
833 }
834}
835#[doc = "MIPI Camera Interface Bridge"]
836pub mod mipi_csi_bridge;
837#[doc = "MIPI Camera Interface Host"]
838pub struct MIPI_CSI_HOST {
839 _marker: PhantomData<*const ()>,
840}
841unsafe impl Send for MIPI_CSI_HOST {}
842impl MIPI_CSI_HOST {
843 #[doc = r"Pointer to the register block"]
844 pub const PTR: *const mipi_csi_host::RegisterBlock = 0x5009_f000 as *const _;
845 #[doc = r"Return the pointer to the register block"]
846 #[inline(always)]
847 pub const fn ptr() -> *const mipi_csi_host::RegisterBlock {
848 Self::PTR
849 }
850 #[doc = r" Steal an instance of this peripheral"]
851 #[doc = r""]
852 #[doc = r" # Safety"]
853 #[doc = r""]
854 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
855 #[doc = r" that may race with any existing instances, for example by only"]
856 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
857 #[doc = r" original peripheral and using critical sections to coordinate"]
858 #[doc = r" access between multiple new instances."]
859 #[doc = r""]
860 #[doc = r" Additionally, other software such as HALs may rely on only one"]
861 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
862 #[doc = r" no stolen instances are passed to such software."]
863 pub unsafe fn steal() -> Self {
864 Self {
865 _marker: PhantomData,
866 }
867 }
868}
869impl Deref for MIPI_CSI_HOST {
870 type Target = mipi_csi_host::RegisterBlock;
871 #[inline(always)]
872 fn deref(&self) -> &Self::Target {
873 unsafe { &*Self::PTR }
874 }
875}
876impl core::fmt::Debug for MIPI_CSI_HOST {
877 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
878 f.debug_struct("MIPI_CSI_HOST").finish()
879 }
880}
881#[doc = "MIPI Camera Interface Host"]
882pub mod mipi_csi_host;
883#[doc = "DMA (Direct Memory Access) Controller"]
884pub struct DMA {
885 _marker: PhantomData<*const ()>,
886}
887unsafe impl Send for DMA {}
888impl DMA {
889 #[doc = r"Pointer to the register block"]
890 pub const PTR: *const dma::RegisterBlock = 0x5008_1000 as *const _;
891 #[doc = r"Return the pointer to the register block"]
892 #[inline(always)]
893 pub const fn ptr() -> *const dma::RegisterBlock {
894 Self::PTR
895 }
896 #[doc = r" Steal an instance of this peripheral"]
897 #[doc = r""]
898 #[doc = r" # Safety"]
899 #[doc = r""]
900 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
901 #[doc = r" that may race with any existing instances, for example by only"]
902 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
903 #[doc = r" original peripheral and using critical sections to coordinate"]
904 #[doc = r" access between multiple new instances."]
905 #[doc = r""]
906 #[doc = r" Additionally, other software such as HALs may rely on only one"]
907 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
908 #[doc = r" no stolen instances are passed to such software."]
909 pub unsafe fn steal() -> Self {
910 Self {
911 _marker: PhantomData,
912 }
913 }
914}
915impl Deref for DMA {
916 type Target = dma::RegisterBlock;
917 #[inline(always)]
918 fn deref(&self) -> &Self::Target {
919 unsafe { &*Self::PTR }
920 }
921}
922impl core::fmt::Debug for DMA {
923 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
924 f.debug_struct("DMA").finish()
925 }
926}
927#[doc = "DMA (Direct Memory Access) Controller"]
928pub mod dma;
929#[doc = "Digital Signature"]
930pub struct DS {
931 _marker: PhantomData<*const ()>,
932}
933unsafe impl Send for DS {}
934impl DS {
935 #[doc = r"Pointer to the register block"]
936 pub const PTR: *const ds::RegisterBlock = 0x5009_4000 as *const _;
937 #[doc = r"Return the pointer to the register block"]
938 #[inline(always)]
939 pub const fn ptr() -> *const ds::RegisterBlock {
940 Self::PTR
941 }
942 #[doc = r" Steal an instance of this peripheral"]
943 #[doc = r""]
944 #[doc = r" # Safety"]
945 #[doc = r""]
946 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
947 #[doc = r" that may race with any existing instances, for example by only"]
948 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
949 #[doc = r" original peripheral and using critical sections to coordinate"]
950 #[doc = r" access between multiple new instances."]
951 #[doc = r""]
952 #[doc = r" Additionally, other software such as HALs may rely on only one"]
953 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
954 #[doc = r" no stolen instances are passed to such software."]
955 pub unsafe fn steal() -> Self {
956 Self {
957 _marker: PhantomData,
958 }
959 }
960}
961impl Deref for DS {
962 type Target = ds::RegisterBlock;
963 #[inline(always)]
964 fn deref(&self) -> &Self::Target {
965 unsafe { &*Self::PTR }
966 }
967}
968impl core::fmt::Debug for DS {
969 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
970 f.debug_struct("DS").finish()
971 }
972}
973#[doc = "Digital Signature"]
974pub mod ds;
975#[doc = "MIPI Camera Interface Bridge"]
976pub struct MIPI_DSI_BRIDGE {
977 _marker: PhantomData<*const ()>,
978}
979unsafe impl Send for MIPI_DSI_BRIDGE {}
980impl MIPI_DSI_BRIDGE {
981 #[doc = r"Pointer to the register block"]
982 pub const PTR: *const mipi_dsi_bridge::RegisterBlock = 0x500a_0800 as *const _;
983 #[doc = r"Return the pointer to the register block"]
984 #[inline(always)]
985 pub const fn ptr() -> *const mipi_dsi_bridge::RegisterBlock {
986 Self::PTR
987 }
988 #[doc = r" Steal an instance of this peripheral"]
989 #[doc = r""]
990 #[doc = r" # Safety"]
991 #[doc = r""]
992 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
993 #[doc = r" that may race with any existing instances, for example by only"]
994 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
995 #[doc = r" original peripheral and using critical sections to coordinate"]
996 #[doc = r" access between multiple new instances."]
997 #[doc = r""]
998 #[doc = r" Additionally, other software such as HALs may rely on only one"]
999 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1000 #[doc = r" no stolen instances are passed to such software."]
1001 pub unsafe fn steal() -> Self {
1002 Self {
1003 _marker: PhantomData,
1004 }
1005 }
1006}
1007impl Deref for MIPI_DSI_BRIDGE {
1008 type Target = mipi_dsi_bridge::RegisterBlock;
1009 #[inline(always)]
1010 fn deref(&self) -> &Self::Target {
1011 unsafe { &*Self::PTR }
1012 }
1013}
1014impl core::fmt::Debug for MIPI_DSI_BRIDGE {
1015 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1016 f.debug_struct("MIPI_DSI_BRIDGE").finish()
1017 }
1018}
1019#[doc = "MIPI Camera Interface Bridge"]
1020pub mod mipi_dsi_bridge;
1021#[doc = "MIPI Display Interface Host"]
1022pub struct MIPI_DSI_HOST {
1023 _marker: PhantomData<*const ()>,
1024}
1025unsafe impl Send for MIPI_DSI_HOST {}
1026impl MIPI_DSI_HOST {
1027 #[doc = r"Pointer to the register block"]
1028 pub const PTR: *const mipi_dsi_host::RegisterBlock = 0x500a_0000 as *const _;
1029 #[doc = r"Return the pointer to the register block"]
1030 #[inline(always)]
1031 pub const fn ptr() -> *const mipi_dsi_host::RegisterBlock {
1032 Self::PTR
1033 }
1034 #[doc = r" Steal an instance of this peripheral"]
1035 #[doc = r""]
1036 #[doc = r" # Safety"]
1037 #[doc = r""]
1038 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1039 #[doc = r" that may race with any existing instances, for example by only"]
1040 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1041 #[doc = r" original peripheral and using critical sections to coordinate"]
1042 #[doc = r" access between multiple new instances."]
1043 #[doc = r""]
1044 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1045 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1046 #[doc = r" no stolen instances are passed to such software."]
1047 pub unsafe fn steal() -> Self {
1048 Self {
1049 _marker: PhantomData,
1050 }
1051 }
1052}
1053impl Deref for MIPI_DSI_HOST {
1054 type Target = mipi_dsi_host::RegisterBlock;
1055 #[inline(always)]
1056 fn deref(&self) -> &Self::Target {
1057 unsafe { &*Self::PTR }
1058 }
1059}
1060impl core::fmt::Debug for MIPI_DSI_HOST {
1061 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1062 f.debug_struct("MIPI_DSI_HOST").finish()
1063 }
1064}
1065#[doc = "MIPI Display Interface Host"]
1066pub mod mipi_dsi_host;
1067#[doc = "ECC (ECC Hardware Accelerator)"]
1068pub struct ECC {
1069 _marker: PhantomData<*const ()>,
1070}
1071unsafe impl Send for ECC {}
1072impl ECC {
1073 #[doc = r"Pointer to the register block"]
1074 pub const PTR: *const ecc::RegisterBlock = 0x5009_3000 as *const _;
1075 #[doc = r"Return the pointer to the register block"]
1076 #[inline(always)]
1077 pub const fn ptr() -> *const ecc::RegisterBlock {
1078 Self::PTR
1079 }
1080 #[doc = r" Steal an instance of this peripheral"]
1081 #[doc = r""]
1082 #[doc = r" # Safety"]
1083 #[doc = r""]
1084 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1085 #[doc = r" that may race with any existing instances, for example by only"]
1086 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1087 #[doc = r" original peripheral and using critical sections to coordinate"]
1088 #[doc = r" access between multiple new instances."]
1089 #[doc = r""]
1090 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1091 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1092 #[doc = r" no stolen instances are passed to such software."]
1093 pub unsafe fn steal() -> Self {
1094 Self {
1095 _marker: PhantomData,
1096 }
1097 }
1098}
1099impl Deref for ECC {
1100 type Target = ecc::RegisterBlock;
1101 #[inline(always)]
1102 fn deref(&self) -> &Self::Target {
1103 unsafe { &*Self::PTR }
1104 }
1105}
1106impl core::fmt::Debug for ECC {
1107 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1108 f.debug_struct("ECC").finish()
1109 }
1110}
1111#[doc = "ECC (ECC Hardware Accelerator)"]
1112pub mod ecc;
1113#[doc = "ECDSA (Elliptic Curve Digital Signature Algorithm) Accelerator"]
1114pub struct ECDSA {
1115 _marker: PhantomData<*const ()>,
1116}
1117unsafe impl Send for ECDSA {}
1118impl ECDSA {
1119 #[doc = r"Pointer to the register block"]
1120 pub const PTR: *const ecdsa::RegisterBlock = 0x5009_6000 as *const _;
1121 #[doc = r"Return the pointer to the register block"]
1122 #[inline(always)]
1123 pub const fn ptr() -> *const ecdsa::RegisterBlock {
1124 Self::PTR
1125 }
1126 #[doc = r" Steal an instance of this peripheral"]
1127 #[doc = r""]
1128 #[doc = r" # Safety"]
1129 #[doc = r""]
1130 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1131 #[doc = r" that may race with any existing instances, for example by only"]
1132 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1133 #[doc = r" original peripheral and using critical sections to coordinate"]
1134 #[doc = r" access between multiple new instances."]
1135 #[doc = r""]
1136 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1137 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1138 #[doc = r" no stolen instances are passed to such software."]
1139 pub unsafe fn steal() -> Self {
1140 Self {
1141 _marker: PhantomData,
1142 }
1143 }
1144}
1145impl Deref for ECDSA {
1146 type Target = ecdsa::RegisterBlock;
1147 #[inline(always)]
1148 fn deref(&self) -> &Self::Target {
1149 unsafe { &*Self::PTR }
1150 }
1151}
1152impl core::fmt::Debug for ECDSA {
1153 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1154 f.debug_struct("ECDSA").finish()
1155 }
1156}
1157#[doc = "ECDSA (Elliptic Curve Digital Signature Algorithm) Accelerator"]
1158pub mod ecdsa;
1159#[doc = "eFuse Controller"]
1160pub struct EFUSE {
1161 _marker: PhantomData<*const ()>,
1162}
1163unsafe impl Send for EFUSE {}
1164impl EFUSE {
1165 #[doc = r"Pointer to the register block"]
1166 pub const PTR: *const efuse::RegisterBlock = 0x5012_d000 as *const _;
1167 #[doc = r"Return the pointer to the register block"]
1168 #[inline(always)]
1169 pub const fn ptr() -> *const efuse::RegisterBlock {
1170 Self::PTR
1171 }
1172 #[doc = r" Steal an instance of this peripheral"]
1173 #[doc = r""]
1174 #[doc = r" # Safety"]
1175 #[doc = r""]
1176 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1177 #[doc = r" that may race with any existing instances, for example by only"]
1178 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1179 #[doc = r" original peripheral and using critical sections to coordinate"]
1180 #[doc = r" access between multiple new instances."]
1181 #[doc = r""]
1182 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1183 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1184 #[doc = r" no stolen instances are passed to such software."]
1185 pub unsafe fn steal() -> Self {
1186 Self {
1187 _marker: PhantomData,
1188 }
1189 }
1190}
1191impl Deref for EFUSE {
1192 type Target = efuse::RegisterBlock;
1193 #[inline(always)]
1194 fn deref(&self) -> &Self::Target {
1195 unsafe { &*Self::PTR }
1196 }
1197}
1198impl core::fmt::Debug for EFUSE {
1199 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1200 f.debug_struct("EFUSE").finish()
1201 }
1202}
1203#[doc = "eFuse Controller"]
1204pub mod efuse;
1205#[doc = "General Purpose Input/Output"]
1206pub struct GPIO {
1207 _marker: PhantomData<*const ()>,
1208}
1209unsafe impl Send for GPIO {}
1210impl GPIO {
1211 #[doc = r"Pointer to the register block"]
1212 pub const PTR: *const gpio::RegisterBlock = 0x500e_0000 as *const _;
1213 #[doc = r"Return the pointer to the register block"]
1214 #[inline(always)]
1215 pub const fn ptr() -> *const gpio::RegisterBlock {
1216 Self::PTR
1217 }
1218 #[doc = r" Steal an instance of this peripheral"]
1219 #[doc = r""]
1220 #[doc = r" # Safety"]
1221 #[doc = r""]
1222 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1223 #[doc = r" that may race with any existing instances, for example by only"]
1224 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1225 #[doc = r" original peripheral and using critical sections to coordinate"]
1226 #[doc = r" access between multiple new instances."]
1227 #[doc = r""]
1228 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1229 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1230 #[doc = r" no stolen instances are passed to such software."]
1231 pub unsafe fn steal() -> Self {
1232 Self {
1233 _marker: PhantomData,
1234 }
1235 }
1236}
1237impl Deref for GPIO {
1238 type Target = gpio::RegisterBlock;
1239 #[inline(always)]
1240 fn deref(&self) -> &Self::Target {
1241 unsafe { &*Self::PTR }
1242 }
1243}
1244impl core::fmt::Debug for GPIO {
1245 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1246 f.debug_struct("GPIO").finish()
1247 }
1248}
1249#[doc = "General Purpose Input/Output"]
1250pub mod gpio;
1251#[doc = "Sigma-Delta Modulation"]
1252pub struct GPIO_SD {
1253 _marker: PhantomData<*const ()>,
1254}
1255unsafe impl Send for GPIO_SD {}
1256impl GPIO_SD {
1257 #[doc = r"Pointer to the register block"]
1258 pub const PTR: *const gpio_sd::RegisterBlock = 0x500e_0f00 as *const _;
1259 #[doc = r"Return the pointer to the register block"]
1260 #[inline(always)]
1261 pub const fn ptr() -> *const gpio_sd::RegisterBlock {
1262 Self::PTR
1263 }
1264 #[doc = r" Steal an instance of this peripheral"]
1265 #[doc = r""]
1266 #[doc = r" # Safety"]
1267 #[doc = r""]
1268 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1269 #[doc = r" that may race with any existing instances, for example by only"]
1270 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1271 #[doc = r" original peripheral and using critical sections to coordinate"]
1272 #[doc = r" access between multiple new instances."]
1273 #[doc = r""]
1274 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1275 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1276 #[doc = r" no stolen instances are passed to such software."]
1277 pub unsafe fn steal() -> Self {
1278 Self {
1279 _marker: PhantomData,
1280 }
1281 }
1282}
1283impl Deref for GPIO_SD {
1284 type Target = gpio_sd::RegisterBlock;
1285 #[inline(always)]
1286 fn deref(&self) -> &Self::Target {
1287 unsafe { &*Self::PTR }
1288 }
1289}
1290impl core::fmt::Debug for GPIO_SD {
1291 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1292 f.debug_struct("GPIO_SD").finish()
1293 }
1294}
1295#[doc = "Sigma-Delta Modulation"]
1296pub mod gpio_sd;
1297#[doc = "H264 Encoder (Core)"]
1298pub struct H264 {
1299 _marker: PhantomData<*const ()>,
1300}
1301unsafe impl Send for H264 {}
1302impl H264 {
1303 #[doc = r"Pointer to the register block"]
1304 pub const PTR: *const h264::RegisterBlock = 0x5008_4000 as *const _;
1305 #[doc = r"Return the pointer to the register block"]
1306 #[inline(always)]
1307 pub const fn ptr() -> *const h264::RegisterBlock {
1308 Self::PTR
1309 }
1310 #[doc = r" Steal an instance of this peripheral"]
1311 #[doc = r""]
1312 #[doc = r" # Safety"]
1313 #[doc = r""]
1314 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1315 #[doc = r" that may race with any existing instances, for example by only"]
1316 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1317 #[doc = r" original peripheral and using critical sections to coordinate"]
1318 #[doc = r" access between multiple new instances."]
1319 #[doc = r""]
1320 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1321 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1322 #[doc = r" no stolen instances are passed to such software."]
1323 pub unsafe fn steal() -> Self {
1324 Self {
1325 _marker: PhantomData,
1326 }
1327 }
1328}
1329impl Deref for H264 {
1330 type Target = h264::RegisterBlock;
1331 #[inline(always)]
1332 fn deref(&self) -> &Self::Target {
1333 unsafe { &*Self::PTR }
1334 }
1335}
1336impl core::fmt::Debug for H264 {
1337 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1338 f.debug_struct("H264").finish()
1339 }
1340}
1341#[doc = "H264 Encoder (Core)"]
1342pub mod h264;
1343#[doc = "H264 Encoder (DMA)"]
1344pub struct H264_DMA {
1345 _marker: PhantomData<*const ()>,
1346}
1347unsafe impl Send for H264_DMA {}
1348impl H264_DMA {
1349 #[doc = r"Pointer to the register block"]
1350 pub const PTR: *const h264_dma::RegisterBlock = 0x500a_7000 as *const _;
1351 #[doc = r"Return the pointer to the register block"]
1352 #[inline(always)]
1353 pub const fn ptr() -> *const h264_dma::RegisterBlock {
1354 Self::PTR
1355 }
1356 #[doc = r" Steal an instance of this peripheral"]
1357 #[doc = r""]
1358 #[doc = r" # Safety"]
1359 #[doc = r""]
1360 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1361 #[doc = r" that may race with any existing instances, for example by only"]
1362 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1363 #[doc = r" original peripheral and using critical sections to coordinate"]
1364 #[doc = r" access between multiple new instances."]
1365 #[doc = r""]
1366 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1367 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1368 #[doc = r" no stolen instances are passed to such software."]
1369 pub unsafe fn steal() -> Self {
1370 Self {
1371 _marker: PhantomData,
1372 }
1373 }
1374}
1375impl Deref for H264_DMA {
1376 type Target = h264_dma::RegisterBlock;
1377 #[inline(always)]
1378 fn deref(&self) -> &Self::Target {
1379 unsafe { &*Self::PTR }
1380 }
1381}
1382impl core::fmt::Debug for H264_DMA {
1383 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1384 f.debug_struct("H264_DMA").finish()
1385 }
1386}
1387#[doc = "H264 Encoder (DMA)"]
1388pub mod h264_dma;
1389#[doc = "HMAC (Hash-based Message Authentication Code) Accelerator"]
1390pub struct HMAC {
1391 _marker: PhantomData<*const ()>,
1392}
1393unsafe impl Send for HMAC {}
1394impl HMAC {
1395 #[doc = r"Pointer to the register block"]
1396 pub const PTR: *const hmac::RegisterBlock = 0x5009_5000 as *const _;
1397 #[doc = r"Return the pointer to the register block"]
1398 #[inline(always)]
1399 pub const fn ptr() -> *const hmac::RegisterBlock {
1400 Self::PTR
1401 }
1402 #[doc = r" Steal an instance of this peripheral"]
1403 #[doc = r""]
1404 #[doc = r" # Safety"]
1405 #[doc = r""]
1406 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1407 #[doc = r" that may race with any existing instances, for example by only"]
1408 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1409 #[doc = r" original peripheral and using critical sections to coordinate"]
1410 #[doc = r" access between multiple new instances."]
1411 #[doc = r""]
1412 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1413 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1414 #[doc = r" no stolen instances are passed to such software."]
1415 pub unsafe fn steal() -> Self {
1416 Self {
1417 _marker: PhantomData,
1418 }
1419 }
1420}
1421impl Deref for HMAC {
1422 type Target = hmac::RegisterBlock;
1423 #[inline(always)]
1424 fn deref(&self) -> &Self::Target {
1425 unsafe { &*Self::PTR }
1426 }
1427}
1428impl core::fmt::Debug for HMAC {
1429 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1430 f.debug_struct("HMAC").finish()
1431 }
1432}
1433#[doc = "HMAC (Hash-based Message Authentication Code) Accelerator"]
1434pub mod hmac;
1435#[doc = "High-Power System"]
1436pub struct HP_SYS {
1437 _marker: PhantomData<*const ()>,
1438}
1439unsafe impl Send for HP_SYS {}
1440impl HP_SYS {
1441 #[doc = r"Pointer to the register block"]
1442 pub const PTR: *const hp_sys::RegisterBlock = 0x500e_5000 as *const _;
1443 #[doc = r"Return the pointer to the register block"]
1444 #[inline(always)]
1445 pub const fn ptr() -> *const hp_sys::RegisterBlock {
1446 Self::PTR
1447 }
1448 #[doc = r" Steal an instance of this peripheral"]
1449 #[doc = r""]
1450 #[doc = r" # Safety"]
1451 #[doc = r""]
1452 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1453 #[doc = r" that may race with any existing instances, for example by only"]
1454 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1455 #[doc = r" original peripheral and using critical sections to coordinate"]
1456 #[doc = r" access between multiple new instances."]
1457 #[doc = r""]
1458 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1459 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1460 #[doc = r" no stolen instances are passed to such software."]
1461 pub unsafe fn steal() -> Self {
1462 Self {
1463 _marker: PhantomData,
1464 }
1465 }
1466}
1467impl Deref for HP_SYS {
1468 type Target = hp_sys::RegisterBlock;
1469 #[inline(always)]
1470 fn deref(&self) -> &Self::Target {
1471 unsafe { &*Self::PTR }
1472 }
1473}
1474impl core::fmt::Debug for HP_SYS {
1475 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1476 f.debug_struct("HP_SYS").finish()
1477 }
1478}
1479#[doc = "High-Power System"]
1480pub mod hp_sys;
1481#[doc = "HP_SYS_CLKRST Peripheral"]
1482pub struct HP_SYS_CLKRST {
1483 _marker: PhantomData<*const ()>,
1484}
1485unsafe impl Send for HP_SYS_CLKRST {}
1486impl HP_SYS_CLKRST {
1487 #[doc = r"Pointer to the register block"]
1488 pub const PTR: *const hp_sys_clkrst::RegisterBlock = 0x500e_6000 as *const _;
1489 #[doc = r"Return the pointer to the register block"]
1490 #[inline(always)]
1491 pub const fn ptr() -> *const hp_sys_clkrst::RegisterBlock {
1492 Self::PTR
1493 }
1494 #[doc = r" Steal an instance of this peripheral"]
1495 #[doc = r""]
1496 #[doc = r" # Safety"]
1497 #[doc = r""]
1498 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1499 #[doc = r" that may race with any existing instances, for example by only"]
1500 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1501 #[doc = r" original peripheral and using critical sections to coordinate"]
1502 #[doc = r" access between multiple new instances."]
1503 #[doc = r""]
1504 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1505 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1506 #[doc = r" no stolen instances are passed to such software."]
1507 pub unsafe fn steal() -> Self {
1508 Self {
1509 _marker: PhantomData,
1510 }
1511 }
1512}
1513impl Deref for HP_SYS_CLKRST {
1514 type Target = hp_sys_clkrst::RegisterBlock;
1515 #[inline(always)]
1516 fn deref(&self) -> &Self::Target {
1517 unsafe { &*Self::PTR }
1518 }
1519}
1520impl core::fmt::Debug for HP_SYS_CLKRST {
1521 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1522 f.debug_struct("HP_SYS_CLKRST").finish()
1523 }
1524}
1525#[doc = "HP_SYS_CLKRST Peripheral"]
1526pub mod hp_sys_clkrst;
1527#[doc = "LP_HUK Peripheral"]
1528pub struct LP_HUK {
1529 _marker: PhantomData<*const ()>,
1530}
1531unsafe impl Send for LP_HUK {}
1532impl LP_HUK {
1533 #[doc = r"Pointer to the register block"]
1534 pub const PTR: *const lp_huk::RegisterBlock = 0x5011_4000 as *const _;
1535 #[doc = r"Return the pointer to the register block"]
1536 #[inline(always)]
1537 pub const fn ptr() -> *const lp_huk::RegisterBlock {
1538 Self::PTR
1539 }
1540 #[doc = r" Steal an instance of this peripheral"]
1541 #[doc = r""]
1542 #[doc = r" # Safety"]
1543 #[doc = r""]
1544 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1545 #[doc = r" that may race with any existing instances, for example by only"]
1546 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1547 #[doc = r" original peripheral and using critical sections to coordinate"]
1548 #[doc = r" access between multiple new instances."]
1549 #[doc = r""]
1550 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1551 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1552 #[doc = r" no stolen instances are passed to such software."]
1553 pub unsafe fn steal() -> Self {
1554 Self {
1555 _marker: PhantomData,
1556 }
1557 }
1558}
1559impl Deref for LP_HUK {
1560 type Target = lp_huk::RegisterBlock;
1561 #[inline(always)]
1562 fn deref(&self) -> &Self::Target {
1563 unsafe { &*Self::PTR }
1564 }
1565}
1566impl core::fmt::Debug for LP_HUK {
1567 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1568 f.debug_struct("LP_HUK").finish()
1569 }
1570}
1571#[doc = "LP_HUK Peripheral"]
1572pub mod lp_huk;
1573#[doc = "I2C (Inter-Integrated Circuit) Controller 0"]
1574pub struct I2C0 {
1575 _marker: PhantomData<*const ()>,
1576}
1577unsafe impl Send for I2C0 {}
1578impl I2C0 {
1579 #[doc = r"Pointer to the register block"]
1580 pub const PTR: *const i2c0::RegisterBlock = 0x500c_4000 as *const _;
1581 #[doc = r"Return the pointer to the register block"]
1582 #[inline(always)]
1583 pub const fn ptr() -> *const i2c0::RegisterBlock {
1584 Self::PTR
1585 }
1586 #[doc = r" Steal an instance of this peripheral"]
1587 #[doc = r""]
1588 #[doc = r" # Safety"]
1589 #[doc = r""]
1590 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1591 #[doc = r" that may race with any existing instances, for example by only"]
1592 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1593 #[doc = r" original peripheral and using critical sections to coordinate"]
1594 #[doc = r" access between multiple new instances."]
1595 #[doc = r""]
1596 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1597 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1598 #[doc = r" no stolen instances are passed to such software."]
1599 pub unsafe fn steal() -> Self {
1600 Self {
1601 _marker: PhantomData,
1602 }
1603 }
1604}
1605impl Deref for I2C0 {
1606 type Target = i2c0::RegisterBlock;
1607 #[inline(always)]
1608 fn deref(&self) -> &Self::Target {
1609 unsafe { &*Self::PTR }
1610 }
1611}
1612impl core::fmt::Debug for I2C0 {
1613 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1614 f.debug_struct("I2C0").finish()
1615 }
1616}
1617#[doc = "I2C (Inter-Integrated Circuit) Controller 0"]
1618pub mod i2c0;
1619#[doc = "I2C (Inter-Integrated Circuit) Controller 1"]
1620pub struct I2C1 {
1621 _marker: PhantomData<*const ()>,
1622}
1623unsafe impl Send for I2C1 {}
1624impl I2C1 {
1625 #[doc = r"Pointer to the register block"]
1626 pub const PTR: *const i2c0::RegisterBlock = 0x500c_5000 as *const _;
1627 #[doc = r"Return the pointer to the register block"]
1628 #[inline(always)]
1629 pub const fn ptr() -> *const i2c0::RegisterBlock {
1630 Self::PTR
1631 }
1632 #[doc = r" Steal an instance of this peripheral"]
1633 #[doc = r""]
1634 #[doc = r" # Safety"]
1635 #[doc = r""]
1636 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1637 #[doc = r" that may race with any existing instances, for example by only"]
1638 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1639 #[doc = r" original peripheral and using critical sections to coordinate"]
1640 #[doc = r" access between multiple new instances."]
1641 #[doc = r""]
1642 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1643 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1644 #[doc = r" no stolen instances are passed to such software."]
1645 pub unsafe fn steal() -> Self {
1646 Self {
1647 _marker: PhantomData,
1648 }
1649 }
1650}
1651impl Deref for I2C1 {
1652 type Target = i2c0::RegisterBlock;
1653 #[inline(always)]
1654 fn deref(&self) -> &Self::Target {
1655 unsafe { &*Self::PTR }
1656 }
1657}
1658impl core::fmt::Debug for I2C1 {
1659 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1660 f.debug_struct("I2C1").finish()
1661 }
1662}
1663#[doc = "I2C (Inter-Integrated Circuit) Controller 1"]
1664pub use self::i2c0 as i2c1;
1665#[doc = "I2S (Inter-IC Sound) Controller 0"]
1666pub struct I2S0 {
1667 _marker: PhantomData<*const ()>,
1668}
1669unsafe impl Send for I2S0 {}
1670impl I2S0 {
1671 #[doc = r"Pointer to the register block"]
1672 pub const PTR: *const i2s0::RegisterBlock = 0x500c_6000 as *const _;
1673 #[doc = r"Return the pointer to the register block"]
1674 #[inline(always)]
1675 pub const fn ptr() -> *const i2s0::RegisterBlock {
1676 Self::PTR
1677 }
1678 #[doc = r" Steal an instance of this peripheral"]
1679 #[doc = r""]
1680 #[doc = r" # Safety"]
1681 #[doc = r""]
1682 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1683 #[doc = r" that may race with any existing instances, for example by only"]
1684 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1685 #[doc = r" original peripheral and using critical sections to coordinate"]
1686 #[doc = r" access between multiple new instances."]
1687 #[doc = r""]
1688 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1689 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1690 #[doc = r" no stolen instances are passed to such software."]
1691 pub unsafe fn steal() -> Self {
1692 Self {
1693 _marker: PhantomData,
1694 }
1695 }
1696}
1697impl Deref for I2S0 {
1698 type Target = i2s0::RegisterBlock;
1699 #[inline(always)]
1700 fn deref(&self) -> &Self::Target {
1701 unsafe { &*Self::PTR }
1702 }
1703}
1704impl core::fmt::Debug for I2S0 {
1705 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1706 f.debug_struct("I2S0").finish()
1707 }
1708}
1709#[doc = "I2S (Inter-IC Sound) Controller 0"]
1710pub mod i2s0;
1711#[doc = "I2S (Inter-IC Sound) Controller 1"]
1712pub struct I2S1 {
1713 _marker: PhantomData<*const ()>,
1714}
1715unsafe impl Send for I2S1 {}
1716impl I2S1 {
1717 #[doc = r"Pointer to the register block"]
1718 pub const PTR: *const i2s0::RegisterBlock = 0x500c_7000 as *const _;
1719 #[doc = r"Return the pointer to the register block"]
1720 #[inline(always)]
1721 pub const fn ptr() -> *const i2s0::RegisterBlock {
1722 Self::PTR
1723 }
1724 #[doc = r" Steal an instance of this peripheral"]
1725 #[doc = r""]
1726 #[doc = r" # Safety"]
1727 #[doc = r""]
1728 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1729 #[doc = r" that may race with any existing instances, for example by only"]
1730 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1731 #[doc = r" original peripheral and using critical sections to coordinate"]
1732 #[doc = r" access between multiple new instances."]
1733 #[doc = r""]
1734 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1735 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1736 #[doc = r" no stolen instances are passed to such software."]
1737 pub unsafe fn steal() -> Self {
1738 Self {
1739 _marker: PhantomData,
1740 }
1741 }
1742}
1743impl Deref for I2S1 {
1744 type Target = i2s0::RegisterBlock;
1745 #[inline(always)]
1746 fn deref(&self) -> &Self::Target {
1747 unsafe { &*Self::PTR }
1748 }
1749}
1750impl core::fmt::Debug for I2S1 {
1751 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1752 f.debug_struct("I2S1").finish()
1753 }
1754}
1755#[doc = "I2S (Inter-IC Sound) Controller 1"]
1756pub use self::i2s0 as i2s1;
1757#[doc = "I2S (Inter-IC Sound) Controller 2"]
1758pub struct I2S2 {
1759 _marker: PhantomData<*const ()>,
1760}
1761unsafe impl Send for I2S2 {}
1762impl I2S2 {
1763 #[doc = r"Pointer to the register block"]
1764 pub const PTR: *const i2s0::RegisterBlock = 0x500c_8000 as *const _;
1765 #[doc = r"Return the pointer to the register block"]
1766 #[inline(always)]
1767 pub const fn ptr() -> *const i2s0::RegisterBlock {
1768 Self::PTR
1769 }
1770 #[doc = r" Steal an instance of this peripheral"]
1771 #[doc = r""]
1772 #[doc = r" # Safety"]
1773 #[doc = r""]
1774 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1775 #[doc = r" that may race with any existing instances, for example by only"]
1776 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1777 #[doc = r" original peripheral and using critical sections to coordinate"]
1778 #[doc = r" access between multiple new instances."]
1779 #[doc = r""]
1780 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1781 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1782 #[doc = r" no stolen instances are passed to such software."]
1783 pub unsafe fn steal() -> Self {
1784 Self {
1785 _marker: PhantomData,
1786 }
1787 }
1788}
1789impl Deref for I2S2 {
1790 type Target = i2s0::RegisterBlock;
1791 #[inline(always)]
1792 fn deref(&self) -> &Self::Target {
1793 unsafe { &*Self::PTR }
1794 }
1795}
1796impl core::fmt::Debug for I2S2 {
1797 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1798 f.debug_struct("I2S2").finish()
1799 }
1800}
1801#[doc = "I2S (Inter-IC Sound) Controller 2"]
1802pub use self::i2s0 as i2s2;
1803#[doc = "I3C Controller (Master)"]
1804pub struct I3C_MST {
1805 _marker: PhantomData<*const ()>,
1806}
1807unsafe impl Send for I3C_MST {}
1808impl I3C_MST {
1809 #[doc = r"Pointer to the register block"]
1810 pub const PTR: *const i3c_mst::RegisterBlock = 0x500d_a000 as *const _;
1811 #[doc = r"Return the pointer to the register block"]
1812 #[inline(always)]
1813 pub const fn ptr() -> *const i3c_mst::RegisterBlock {
1814 Self::PTR
1815 }
1816 #[doc = r" Steal an instance of this peripheral"]
1817 #[doc = r""]
1818 #[doc = r" # Safety"]
1819 #[doc = r""]
1820 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1821 #[doc = r" that may race with any existing instances, for example by only"]
1822 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1823 #[doc = r" original peripheral and using critical sections to coordinate"]
1824 #[doc = r" access between multiple new instances."]
1825 #[doc = r""]
1826 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1827 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1828 #[doc = r" no stolen instances are passed to such software."]
1829 pub unsafe fn steal() -> Self {
1830 Self {
1831 _marker: PhantomData,
1832 }
1833 }
1834}
1835impl Deref for I3C_MST {
1836 type Target = i3c_mst::RegisterBlock;
1837 #[inline(always)]
1838 fn deref(&self) -> &Self::Target {
1839 unsafe { &*Self::PTR }
1840 }
1841}
1842impl core::fmt::Debug for I3C_MST {
1843 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1844 f.debug_struct("I3C_MST").finish()
1845 }
1846}
1847#[doc = "I3C Controller (Master)"]
1848pub mod i3c_mst;
1849#[doc = "I3C_MST_MEM Peripheral"]
1850pub struct I3C_MST_MEM {
1851 _marker: PhantomData<*const ()>,
1852}
1853unsafe impl Send for I3C_MST_MEM {}
1854impl I3C_MST_MEM {
1855 #[doc = r"Pointer to the register block"]
1856 pub const PTR: *const i3c_mst_mem::RegisterBlock = 0x500d_a000 as *const _;
1857 #[doc = r"Return the pointer to the register block"]
1858 #[inline(always)]
1859 pub const fn ptr() -> *const i3c_mst_mem::RegisterBlock {
1860 Self::PTR
1861 }
1862 #[doc = r" Steal an instance of this peripheral"]
1863 #[doc = r""]
1864 #[doc = r" # Safety"]
1865 #[doc = r""]
1866 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1867 #[doc = r" that may race with any existing instances, for example by only"]
1868 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1869 #[doc = r" original peripheral and using critical sections to coordinate"]
1870 #[doc = r" access between multiple new instances."]
1871 #[doc = r""]
1872 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1873 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1874 #[doc = r" no stolen instances are passed to such software."]
1875 pub unsafe fn steal() -> Self {
1876 Self {
1877 _marker: PhantomData,
1878 }
1879 }
1880}
1881impl Deref for I3C_MST_MEM {
1882 type Target = i3c_mst_mem::RegisterBlock;
1883 #[inline(always)]
1884 fn deref(&self) -> &Self::Target {
1885 unsafe { &*Self::PTR }
1886 }
1887}
1888impl core::fmt::Debug for I3C_MST_MEM {
1889 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1890 f.debug_struct("I3C_MST_MEM").finish()
1891 }
1892}
1893#[doc = "I3C_MST_MEM Peripheral"]
1894pub mod i3c_mst_mem;
1895#[doc = "I3C Controller (Slave)"]
1896pub struct I3C_SLV {
1897 _marker: PhantomData<*const ()>,
1898}
1899unsafe impl Send for I3C_SLV {}
1900impl I3C_SLV {
1901 #[doc = r"Pointer to the register block"]
1902 pub const PTR: *const i3c_slv::RegisterBlock = 0x500d_b000 as *const _;
1903 #[doc = r"Return the pointer to the register block"]
1904 #[inline(always)]
1905 pub const fn ptr() -> *const i3c_slv::RegisterBlock {
1906 Self::PTR
1907 }
1908 #[doc = r" Steal an instance of this peripheral"]
1909 #[doc = r""]
1910 #[doc = r" # Safety"]
1911 #[doc = r""]
1912 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1913 #[doc = r" that may race with any existing instances, for example by only"]
1914 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1915 #[doc = r" original peripheral and using critical sections to coordinate"]
1916 #[doc = r" access between multiple new instances."]
1917 #[doc = r""]
1918 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1919 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1920 #[doc = r" no stolen instances are passed to such software."]
1921 pub unsafe fn steal() -> Self {
1922 Self {
1923 _marker: PhantomData,
1924 }
1925 }
1926}
1927impl Deref for I3C_SLV {
1928 type Target = i3c_slv::RegisterBlock;
1929 #[inline(always)]
1930 fn deref(&self) -> &Self::Target {
1931 unsafe { &*Self::PTR }
1932 }
1933}
1934impl core::fmt::Debug for I3C_SLV {
1935 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1936 f.debug_struct("I3C_SLV").finish()
1937 }
1938}
1939#[doc = "I3C Controller (Slave)"]
1940pub mod i3c_slv;
1941#[doc = "AXI_ICM Peripheral"]
1942pub struct AXI_ICM {
1943 _marker: PhantomData<*const ()>,
1944}
1945unsafe impl Send for AXI_ICM {}
1946impl AXI_ICM {
1947 #[doc = r"Pointer to the register block"]
1948 pub const PTR: *const axi_icm::RegisterBlock = 0x500a_4000 as *const _;
1949 #[doc = r"Return the pointer to the register block"]
1950 #[inline(always)]
1951 pub const fn ptr() -> *const axi_icm::RegisterBlock {
1952 Self::PTR
1953 }
1954 #[doc = r" Steal an instance of this peripheral"]
1955 #[doc = r""]
1956 #[doc = r" # Safety"]
1957 #[doc = r""]
1958 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1959 #[doc = r" that may race with any existing instances, for example by only"]
1960 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1961 #[doc = r" original peripheral and using critical sections to coordinate"]
1962 #[doc = r" access between multiple new instances."]
1963 #[doc = r""]
1964 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1965 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1966 #[doc = r" no stolen instances are passed to such software."]
1967 pub unsafe fn steal() -> Self {
1968 Self {
1969 _marker: PhantomData,
1970 }
1971 }
1972}
1973impl Deref for AXI_ICM {
1974 type Target = axi_icm::RegisterBlock;
1975 #[inline(always)]
1976 fn deref(&self) -> &Self::Target {
1977 unsafe { &*Self::PTR }
1978 }
1979}
1980impl core::fmt::Debug for AXI_ICM {
1981 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1982 f.debug_struct("AXI_ICM").finish()
1983 }
1984}
1985#[doc = "AXI_ICM Peripheral"]
1986pub mod axi_icm;
1987#[doc = "Input/Output Multiplexer"]
1988pub struct IO_MUX {
1989 _marker: PhantomData<*const ()>,
1990}
1991unsafe impl Send for IO_MUX {}
1992impl IO_MUX {
1993 #[doc = r"Pointer to the register block"]
1994 pub const PTR: *const io_mux::RegisterBlock = 0x500e_1000 as *const _;
1995 #[doc = r"Return the pointer to the register block"]
1996 #[inline(always)]
1997 pub const fn ptr() -> *const io_mux::RegisterBlock {
1998 Self::PTR
1999 }
2000 #[doc = r" Steal an instance of this peripheral"]
2001 #[doc = r""]
2002 #[doc = r" # Safety"]
2003 #[doc = r""]
2004 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2005 #[doc = r" that may race with any existing instances, for example by only"]
2006 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2007 #[doc = r" original peripheral and using critical sections to coordinate"]
2008 #[doc = r" access between multiple new instances."]
2009 #[doc = r""]
2010 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2011 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2012 #[doc = r" no stolen instances are passed to such software."]
2013 pub unsafe fn steal() -> Self {
2014 Self {
2015 _marker: PhantomData,
2016 }
2017 }
2018}
2019impl Deref for IO_MUX {
2020 type Target = io_mux::RegisterBlock;
2021 #[inline(always)]
2022 fn deref(&self) -> &Self::Target {
2023 unsafe { &*Self::PTR }
2024 }
2025}
2026impl core::fmt::Debug for IO_MUX {
2027 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2028 f.debug_struct("IO_MUX").finish()
2029 }
2030}
2031#[doc = "Input/Output Multiplexer"]
2032pub mod io_mux;
2033#[doc = "ISP Peripheral"]
2034pub struct ISP {
2035 _marker: PhantomData<*const ()>,
2036}
2037unsafe impl Send for ISP {}
2038impl ISP {
2039 #[doc = r"Pointer to the register block"]
2040 pub const PTR: *const isp::RegisterBlock = 0x500a_1000 as *const _;
2041 #[doc = r"Return the pointer to the register block"]
2042 #[inline(always)]
2043 pub const fn ptr() -> *const isp::RegisterBlock {
2044 Self::PTR
2045 }
2046 #[doc = r" Steal an instance of this peripheral"]
2047 #[doc = r""]
2048 #[doc = r" # Safety"]
2049 #[doc = r""]
2050 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2051 #[doc = r" that may race with any existing instances, for example by only"]
2052 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2053 #[doc = r" original peripheral and using critical sections to coordinate"]
2054 #[doc = r" access between multiple new instances."]
2055 #[doc = r""]
2056 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2057 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2058 #[doc = r" no stolen instances are passed to such software."]
2059 pub unsafe fn steal() -> Self {
2060 Self {
2061 _marker: PhantomData,
2062 }
2063 }
2064}
2065impl Deref for ISP {
2066 type Target = isp::RegisterBlock;
2067 #[inline(always)]
2068 fn deref(&self) -> &Self::Target {
2069 unsafe { &*Self::PTR }
2070 }
2071}
2072impl core::fmt::Debug for ISP {
2073 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2074 f.debug_struct("ISP").finish()
2075 }
2076}
2077#[doc = "ISP Peripheral"]
2078pub mod isp;
2079#[doc = "JPEG Codec"]
2080pub struct JPEG {
2081 _marker: PhantomData<*const ()>,
2082}
2083unsafe impl Send for JPEG {}
2084impl JPEG {
2085 #[doc = r"Pointer to the register block"]
2086 pub const PTR: *const jpeg::RegisterBlock = 0x5008_6000 as *const _;
2087 #[doc = r"Return the pointer to the register block"]
2088 #[inline(always)]
2089 pub const fn ptr() -> *const jpeg::RegisterBlock {
2090 Self::PTR
2091 }
2092 #[doc = r" Steal an instance of this peripheral"]
2093 #[doc = r""]
2094 #[doc = r" # Safety"]
2095 #[doc = r""]
2096 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2097 #[doc = r" that may race with any existing instances, for example by only"]
2098 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2099 #[doc = r" original peripheral and using critical sections to coordinate"]
2100 #[doc = r" access between multiple new instances."]
2101 #[doc = r""]
2102 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2103 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2104 #[doc = r" no stolen instances are passed to such software."]
2105 pub unsafe fn steal() -> Self {
2106 Self {
2107 _marker: PhantomData,
2108 }
2109 }
2110}
2111impl Deref for JPEG {
2112 type Target = jpeg::RegisterBlock;
2113 #[inline(always)]
2114 fn deref(&self) -> &Self::Target {
2115 unsafe { &*Self::PTR }
2116 }
2117}
2118impl core::fmt::Debug for JPEG {
2119 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2120 f.debug_struct("JPEG").finish()
2121 }
2122}
2123#[doc = "JPEG Codec"]
2124pub mod jpeg;
2125#[doc = "Camera/LCD Controller"]
2126pub struct LCD_CAM {
2127 _marker: PhantomData<*const ()>,
2128}
2129unsafe impl Send for LCD_CAM {}
2130impl LCD_CAM {
2131 #[doc = r"Pointer to the register block"]
2132 pub const PTR: *const lcd_cam::RegisterBlock = 0x500d_c000 as *const _;
2133 #[doc = r"Return the pointer to the register block"]
2134 #[inline(always)]
2135 pub const fn ptr() -> *const lcd_cam::RegisterBlock {
2136 Self::PTR
2137 }
2138 #[doc = r" Steal an instance of this peripheral"]
2139 #[doc = r""]
2140 #[doc = r" # Safety"]
2141 #[doc = r""]
2142 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2143 #[doc = r" that may race with any existing instances, for example by only"]
2144 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2145 #[doc = r" original peripheral and using critical sections to coordinate"]
2146 #[doc = r" access between multiple new instances."]
2147 #[doc = r""]
2148 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2149 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2150 #[doc = r" no stolen instances are passed to such software."]
2151 pub unsafe fn steal() -> Self {
2152 Self {
2153 _marker: PhantomData,
2154 }
2155 }
2156}
2157impl Deref for LCD_CAM {
2158 type Target = lcd_cam::RegisterBlock;
2159 #[inline(always)]
2160 fn deref(&self) -> &Self::Target {
2161 unsafe { &*Self::PTR }
2162 }
2163}
2164impl core::fmt::Debug for LCD_CAM {
2165 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2166 f.debug_struct("LCD_CAM").finish()
2167 }
2168}
2169#[doc = "Camera/LCD Controller"]
2170pub mod lcd_cam;
2171#[doc = "LED Control PWM (Pulse Width Modulation)"]
2172pub struct LEDC {
2173 _marker: PhantomData<*const ()>,
2174}
2175unsafe impl Send for LEDC {}
2176impl LEDC {
2177 #[doc = r"Pointer to the register block"]
2178 pub const PTR: *const ledc::RegisterBlock = 0x500d_3000 as *const _;
2179 #[doc = r"Return the pointer to the register block"]
2180 #[inline(always)]
2181 pub const fn ptr() -> *const ledc::RegisterBlock {
2182 Self::PTR
2183 }
2184 #[doc = r" Steal an instance of this peripheral"]
2185 #[doc = r""]
2186 #[doc = r" # Safety"]
2187 #[doc = r""]
2188 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2189 #[doc = r" that may race with any existing instances, for example by only"]
2190 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2191 #[doc = r" original peripheral and using critical sections to coordinate"]
2192 #[doc = r" access between multiple new instances."]
2193 #[doc = r""]
2194 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2195 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2196 #[doc = r" no stolen instances are passed to such software."]
2197 pub unsafe fn steal() -> Self {
2198 Self {
2199 _marker: PhantomData,
2200 }
2201 }
2202}
2203impl Deref for LEDC {
2204 type Target = ledc::RegisterBlock;
2205 #[inline(always)]
2206 fn deref(&self) -> &Self::Target {
2207 unsafe { &*Self::PTR }
2208 }
2209}
2210impl core::fmt::Debug for LEDC {
2211 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2212 f.debug_struct("LEDC").finish()
2213 }
2214}
2215#[doc = "LED Control PWM (Pulse Width Modulation)"]
2216pub mod ledc;
2217#[doc = "Low-power Interrupt Controller"]
2218pub struct LP_INTR {
2219 _marker: PhantomData<*const ()>,
2220}
2221unsafe impl Send for LP_INTR {}
2222impl LP_INTR {
2223 #[doc = r"Pointer to the register block"]
2224 pub const PTR: *const lp_intr::RegisterBlock = 0x5012_c000 as *const _;
2225 #[doc = r"Return the pointer to the register block"]
2226 #[inline(always)]
2227 pub const fn ptr() -> *const lp_intr::RegisterBlock {
2228 Self::PTR
2229 }
2230 #[doc = r" Steal an instance of this peripheral"]
2231 #[doc = r""]
2232 #[doc = r" # Safety"]
2233 #[doc = r""]
2234 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2235 #[doc = r" that may race with any existing instances, for example by only"]
2236 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2237 #[doc = r" original peripheral and using critical sections to coordinate"]
2238 #[doc = r" access between multiple new instances."]
2239 #[doc = r""]
2240 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2241 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2242 #[doc = r" no stolen instances are passed to such software."]
2243 pub unsafe fn steal() -> Self {
2244 Self {
2245 _marker: PhantomData,
2246 }
2247 }
2248}
2249impl Deref for LP_INTR {
2250 type Target = lp_intr::RegisterBlock;
2251 #[inline(always)]
2252 fn deref(&self) -> &Self::Target {
2253 unsafe { &*Self::PTR }
2254 }
2255}
2256impl core::fmt::Debug for LP_INTR {
2257 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2258 f.debug_struct("LP_INTR").finish()
2259 }
2260}
2261#[doc = "Low-power Interrupt Controller"]
2262pub mod lp_intr;
2263#[doc = "LP_PERI Peripheral"]
2264pub struct LP_PERI {
2265 _marker: PhantomData<*const ()>,
2266}
2267unsafe impl Send for LP_PERI {}
2268impl LP_PERI {
2269 #[doc = r"Pointer to the register block"]
2270 pub const PTR: *const lp_peri::RegisterBlock = 0x5012_0000 as *const _;
2271 #[doc = r"Return the pointer to the register block"]
2272 #[inline(always)]
2273 pub const fn ptr() -> *const lp_peri::RegisterBlock {
2274 Self::PTR
2275 }
2276 #[doc = r" Steal an instance of this peripheral"]
2277 #[doc = r""]
2278 #[doc = r" # Safety"]
2279 #[doc = r""]
2280 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2281 #[doc = r" that may race with any existing instances, for example by only"]
2282 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2283 #[doc = r" original peripheral and using critical sections to coordinate"]
2284 #[doc = r" access between multiple new instances."]
2285 #[doc = r""]
2286 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2287 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2288 #[doc = r" no stolen instances are passed to such software."]
2289 pub unsafe fn steal() -> Self {
2290 Self {
2291 _marker: PhantomData,
2292 }
2293 }
2294}
2295impl Deref for LP_PERI {
2296 type Target = lp_peri::RegisterBlock;
2297 #[inline(always)]
2298 fn deref(&self) -> &Self::Target {
2299 unsafe { &*Self::PTR }
2300 }
2301}
2302impl core::fmt::Debug for LP_PERI {
2303 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2304 f.debug_struct("LP_PERI").finish()
2305 }
2306}
2307#[doc = "LP_PERI Peripheral"]
2308pub mod lp_peri;
2309#[doc = "LP_SYS Peripheral"]
2310pub struct LP_SYS {
2311 _marker: PhantomData<*const ()>,
2312}
2313unsafe impl Send for LP_SYS {}
2314impl LP_SYS {
2315 #[doc = r"Pointer to the register block"]
2316 pub const PTR: *const lp_sys::RegisterBlock = 0x5011_0000 as *const _;
2317 #[doc = r"Return the pointer to the register block"]
2318 #[inline(always)]
2319 pub const fn ptr() -> *const lp_sys::RegisterBlock {
2320 Self::PTR
2321 }
2322 #[doc = r" Steal an instance of this peripheral"]
2323 #[doc = r""]
2324 #[doc = r" # Safety"]
2325 #[doc = r""]
2326 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2327 #[doc = r" that may race with any existing instances, for example by only"]
2328 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2329 #[doc = r" original peripheral and using critical sections to coordinate"]
2330 #[doc = r" access between multiple new instances."]
2331 #[doc = r""]
2332 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2333 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2334 #[doc = r" no stolen instances are passed to such software."]
2335 pub unsafe fn steal() -> Self {
2336 Self {
2337 _marker: PhantomData,
2338 }
2339 }
2340}
2341impl Deref for LP_SYS {
2342 type Target = lp_sys::RegisterBlock;
2343 #[inline(always)]
2344 fn deref(&self) -> &Self::Target {
2345 unsafe { &*Self::PTR }
2346 }
2347}
2348impl core::fmt::Debug for LP_SYS {
2349 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2350 f.debug_struct("LP_SYS").finish()
2351 }
2352}
2353#[doc = "LP_SYS Peripheral"]
2354pub mod lp_sys;
2355#[doc = "LP_ANA_PERI Peripheral"]
2356pub struct LP_ANA {
2357 _marker: PhantomData<*const ()>,
2358}
2359unsafe impl Send for LP_ANA {}
2360impl LP_ANA {
2361 #[doc = r"Pointer to the register block"]
2362 pub const PTR: *const lp_ana::RegisterBlock = 0x5011_3000 as *const _;
2363 #[doc = r"Return the pointer to the register block"]
2364 #[inline(always)]
2365 pub const fn ptr() -> *const lp_ana::RegisterBlock {
2366 Self::PTR
2367 }
2368 #[doc = r" Steal an instance of this peripheral"]
2369 #[doc = r""]
2370 #[doc = r" # Safety"]
2371 #[doc = r""]
2372 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2373 #[doc = r" that may race with any existing instances, for example by only"]
2374 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2375 #[doc = r" original peripheral and using critical sections to coordinate"]
2376 #[doc = r" access between multiple new instances."]
2377 #[doc = r""]
2378 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2379 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2380 #[doc = r" no stolen instances are passed to such software."]
2381 pub unsafe fn steal() -> Self {
2382 Self {
2383 _marker: PhantomData,
2384 }
2385 }
2386}
2387impl Deref for LP_ANA {
2388 type Target = lp_ana::RegisterBlock;
2389 #[inline(always)]
2390 fn deref(&self) -> &Self::Target {
2391 unsafe { &*Self::PTR }
2392 }
2393}
2394impl core::fmt::Debug for LP_ANA {
2395 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2396 f.debug_struct("LP_ANA").finish()
2397 }
2398}
2399#[doc = "LP_ANA_PERI Peripheral"]
2400pub mod lp_ana;
2401#[doc = "LP_AON_CLKRST Peripheral"]
2402pub struct LP_AON_CLKRST {
2403 _marker: PhantomData<*const ()>,
2404}
2405unsafe impl Send for LP_AON_CLKRST {}
2406impl LP_AON_CLKRST {
2407 #[doc = r"Pointer to the register block"]
2408 pub const PTR: *const lp_aon_clkrst::RegisterBlock = 0x5011_1000 as *const _;
2409 #[doc = r"Return the pointer to the register block"]
2410 #[inline(always)]
2411 pub const fn ptr() -> *const lp_aon_clkrst::RegisterBlock {
2412 Self::PTR
2413 }
2414 #[doc = r" Steal an instance of this peripheral"]
2415 #[doc = r""]
2416 #[doc = r" # Safety"]
2417 #[doc = r""]
2418 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2419 #[doc = r" that may race with any existing instances, for example by only"]
2420 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2421 #[doc = r" original peripheral and using critical sections to coordinate"]
2422 #[doc = r" access between multiple new instances."]
2423 #[doc = r""]
2424 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2425 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2426 #[doc = r" no stolen instances are passed to such software."]
2427 pub unsafe fn steal() -> Self {
2428 Self {
2429 _marker: PhantomData,
2430 }
2431 }
2432}
2433impl Deref for LP_AON_CLKRST {
2434 type Target = lp_aon_clkrst::RegisterBlock;
2435 #[inline(always)]
2436 fn deref(&self) -> &Self::Target {
2437 unsafe { &*Self::PTR }
2438 }
2439}
2440impl core::fmt::Debug for LP_AON_CLKRST {
2441 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2442 f.debug_struct("LP_AON_CLKRST").finish()
2443 }
2444}
2445#[doc = "LP_AON_CLKRST Peripheral"]
2446pub mod lp_aon_clkrst;
2447#[doc = "Low-power General Purpose Input/Output"]
2448pub struct LP_GPIO {
2449 _marker: PhantomData<*const ()>,
2450}
2451unsafe impl Send for LP_GPIO {}
2452impl LP_GPIO {
2453 #[doc = r"Pointer to the register block"]
2454 pub const PTR: *const lp_gpio::RegisterBlock = 0x5012_a000 as *const _;
2455 #[doc = r"Return the pointer to the register block"]
2456 #[inline(always)]
2457 pub const fn ptr() -> *const lp_gpio::RegisterBlock {
2458 Self::PTR
2459 }
2460 #[doc = r" Steal an instance of this peripheral"]
2461 #[doc = r""]
2462 #[doc = r" # Safety"]
2463 #[doc = r""]
2464 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2465 #[doc = r" that may race with any existing instances, for example by only"]
2466 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2467 #[doc = r" original peripheral and using critical sections to coordinate"]
2468 #[doc = r" access between multiple new instances."]
2469 #[doc = r""]
2470 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2471 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2472 #[doc = r" no stolen instances are passed to such software."]
2473 pub unsafe fn steal() -> Self {
2474 Self {
2475 _marker: PhantomData,
2476 }
2477 }
2478}
2479impl Deref for LP_GPIO {
2480 type Target = lp_gpio::RegisterBlock;
2481 #[inline(always)]
2482 fn deref(&self) -> &Self::Target {
2483 unsafe { &*Self::PTR }
2484 }
2485}
2486impl core::fmt::Debug for LP_GPIO {
2487 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2488 f.debug_struct("LP_GPIO").finish()
2489 }
2490}
2491#[doc = "Low-power General Purpose Input/Output"]
2492pub mod lp_gpio;
2493#[doc = "Low-power I2C (Inter-Integrated Circuit) Controller 0"]
2494pub struct LP_I2C0 {
2495 _marker: PhantomData<*const ()>,
2496}
2497unsafe impl Send for LP_I2C0 {}
2498impl LP_I2C0 {
2499 #[doc = r"Pointer to the register block"]
2500 pub const PTR: *const lp_i2c0::RegisterBlock = 0x5012_2000 as *const _;
2501 #[doc = r"Return the pointer to the register block"]
2502 #[inline(always)]
2503 pub const fn ptr() -> *const lp_i2c0::RegisterBlock {
2504 Self::PTR
2505 }
2506 #[doc = r" Steal an instance of this peripheral"]
2507 #[doc = r""]
2508 #[doc = r" # Safety"]
2509 #[doc = r""]
2510 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2511 #[doc = r" that may race with any existing instances, for example by only"]
2512 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2513 #[doc = r" original peripheral and using critical sections to coordinate"]
2514 #[doc = r" access between multiple new instances."]
2515 #[doc = r""]
2516 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2517 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2518 #[doc = r" no stolen instances are passed to such software."]
2519 pub unsafe fn steal() -> Self {
2520 Self {
2521 _marker: PhantomData,
2522 }
2523 }
2524}
2525impl Deref for LP_I2C0 {
2526 type Target = lp_i2c0::RegisterBlock;
2527 #[inline(always)]
2528 fn deref(&self) -> &Self::Target {
2529 unsafe { &*Self::PTR }
2530 }
2531}
2532impl core::fmt::Debug for LP_I2C0 {
2533 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2534 f.debug_struct("LP_I2C0").finish()
2535 }
2536}
2537#[doc = "Low-power I2C (Inter-Integrated Circuit) Controller 0"]
2538pub mod lp_i2c0;
2539#[doc = "Low-power I2S (Inter-IC Sound) Controller 0"]
2540pub struct LP_I2S0 {
2541 _marker: PhantomData<*const ()>,
2542}
2543unsafe impl Send for LP_I2S0 {}
2544impl LP_I2S0 {
2545 #[doc = r"Pointer to the register block"]
2546 pub const PTR: *const lp_i2s0::RegisterBlock = 0x5012_5000 as *const _;
2547 #[doc = r"Return the pointer to the register block"]
2548 #[inline(always)]
2549 pub const fn ptr() -> *const lp_i2s0::RegisterBlock {
2550 Self::PTR
2551 }
2552 #[doc = r" Steal an instance of this peripheral"]
2553 #[doc = r""]
2554 #[doc = r" # Safety"]
2555 #[doc = r""]
2556 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2557 #[doc = r" that may race with any existing instances, for example by only"]
2558 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2559 #[doc = r" original peripheral and using critical sections to coordinate"]
2560 #[doc = r" access between multiple new instances."]
2561 #[doc = r""]
2562 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2563 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2564 #[doc = r" no stolen instances are passed to such software."]
2565 pub unsafe fn steal() -> Self {
2566 Self {
2567 _marker: PhantomData,
2568 }
2569 }
2570}
2571impl Deref for LP_I2S0 {
2572 type Target = lp_i2s0::RegisterBlock;
2573 #[inline(always)]
2574 fn deref(&self) -> &Self::Target {
2575 unsafe { &*Self::PTR }
2576 }
2577}
2578impl core::fmt::Debug for LP_I2S0 {
2579 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2580 f.debug_struct("LP_I2S0").finish()
2581 }
2582}
2583#[doc = "Low-power I2S (Inter-IC Sound) Controller 0"]
2584pub mod lp_i2s0;
2585#[doc = "Low-power Input/Output Multiplexer"]
2586pub struct LP_IO_MUX {
2587 _marker: PhantomData<*const ()>,
2588}
2589unsafe impl Send for LP_IO_MUX {}
2590impl LP_IO_MUX {
2591 #[doc = r"Pointer to the register block"]
2592 pub const PTR: *const lp_io_mux::RegisterBlock = 0x5012_b000 as *const _;
2593 #[doc = r"Return the pointer to the register block"]
2594 #[inline(always)]
2595 pub const fn ptr() -> *const lp_io_mux::RegisterBlock {
2596 Self::PTR
2597 }
2598 #[doc = r" Steal an instance of this peripheral"]
2599 #[doc = r""]
2600 #[doc = r" # Safety"]
2601 #[doc = r""]
2602 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2603 #[doc = r" that may race with any existing instances, for example by only"]
2604 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2605 #[doc = r" original peripheral and using critical sections to coordinate"]
2606 #[doc = r" access between multiple new instances."]
2607 #[doc = r""]
2608 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2609 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2610 #[doc = r" no stolen instances are passed to such software."]
2611 pub unsafe fn steal() -> Self {
2612 Self {
2613 _marker: PhantomData,
2614 }
2615 }
2616}
2617impl Deref for LP_IO_MUX {
2618 type Target = lp_io_mux::RegisterBlock;
2619 #[inline(always)]
2620 fn deref(&self) -> &Self::Target {
2621 unsafe { &*Self::PTR }
2622 }
2623}
2624impl core::fmt::Debug for LP_IO_MUX {
2625 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2626 f.debug_struct("LP_IO_MUX").finish()
2627 }
2628}
2629#[doc = "Low-power Input/Output Multiplexer"]
2630pub mod lp_io_mux;
2631#[doc = "Low-power UART (Universal Asynchronous Receiver-Transmitter) Controller"]
2632pub struct LP_UART {
2633 _marker: PhantomData<*const ()>,
2634}
2635unsafe impl Send for LP_UART {}
2636impl LP_UART {
2637 #[doc = r"Pointer to the register block"]
2638 pub const PTR: *const lp_uart::RegisterBlock = 0x5012_1000 as *const _;
2639 #[doc = r"Return the pointer to the register block"]
2640 #[inline(always)]
2641 pub const fn ptr() -> *const lp_uart::RegisterBlock {
2642 Self::PTR
2643 }
2644 #[doc = r" Steal an instance of this peripheral"]
2645 #[doc = r""]
2646 #[doc = r" # Safety"]
2647 #[doc = r""]
2648 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2649 #[doc = r" that may race with any existing instances, for example by only"]
2650 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2651 #[doc = r" original peripheral and using critical sections to coordinate"]
2652 #[doc = r" access between multiple new instances."]
2653 #[doc = r""]
2654 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2655 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2656 #[doc = r" no stolen instances are passed to such software."]
2657 pub unsafe fn steal() -> Self {
2658 Self {
2659 _marker: PhantomData,
2660 }
2661 }
2662}
2663impl Deref for LP_UART {
2664 type Target = lp_uart::RegisterBlock;
2665 #[inline(always)]
2666 fn deref(&self) -> &Self::Target {
2667 unsafe { &*Self::PTR }
2668 }
2669}
2670impl core::fmt::Debug for LP_UART {
2671 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2672 f.debug_struct("LP_UART").finish()
2673 }
2674}
2675#[doc = "Low-power UART (Universal Asynchronous Receiver-Transmitter) Controller"]
2676pub mod lp_uart;
2677#[doc = "Motor Control Pulse-Width Modulation 0"]
2678pub struct MCPWM0 {
2679 _marker: PhantomData<*const ()>,
2680}
2681unsafe impl Send for MCPWM0 {}
2682impl MCPWM0 {
2683 #[doc = r"Pointer to the register block"]
2684 pub const PTR: *const mcpwm0::RegisterBlock = 0x500c_0000 as *const _;
2685 #[doc = r"Return the pointer to the register block"]
2686 #[inline(always)]
2687 pub const fn ptr() -> *const mcpwm0::RegisterBlock {
2688 Self::PTR
2689 }
2690 #[doc = r" Steal an instance of this peripheral"]
2691 #[doc = r""]
2692 #[doc = r" # Safety"]
2693 #[doc = r""]
2694 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2695 #[doc = r" that may race with any existing instances, for example by only"]
2696 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2697 #[doc = r" original peripheral and using critical sections to coordinate"]
2698 #[doc = r" access between multiple new instances."]
2699 #[doc = r""]
2700 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2701 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2702 #[doc = r" no stolen instances are passed to such software."]
2703 pub unsafe fn steal() -> Self {
2704 Self {
2705 _marker: PhantomData,
2706 }
2707 }
2708}
2709impl Deref for MCPWM0 {
2710 type Target = mcpwm0::RegisterBlock;
2711 #[inline(always)]
2712 fn deref(&self) -> &Self::Target {
2713 unsafe { &*Self::PTR }
2714 }
2715}
2716impl core::fmt::Debug for MCPWM0 {
2717 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2718 f.debug_struct("MCPWM0").finish()
2719 }
2720}
2721#[doc = "Motor Control Pulse-Width Modulation 0"]
2722pub mod mcpwm0;
2723#[doc = "Motor Control Pulse-Width Modulation 1"]
2724pub struct MCPWM1 {
2725 _marker: PhantomData<*const ()>,
2726}
2727unsafe impl Send for MCPWM1 {}
2728impl MCPWM1 {
2729 #[doc = r"Pointer to the register block"]
2730 pub const PTR: *const mcpwm0::RegisterBlock = 0x500c_1000 as *const _;
2731 #[doc = r"Return the pointer to the register block"]
2732 #[inline(always)]
2733 pub const fn ptr() -> *const mcpwm0::RegisterBlock {
2734 Self::PTR
2735 }
2736 #[doc = r" Steal an instance of this peripheral"]
2737 #[doc = r""]
2738 #[doc = r" # Safety"]
2739 #[doc = r""]
2740 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2741 #[doc = r" that may race with any existing instances, for example by only"]
2742 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2743 #[doc = r" original peripheral and using critical sections to coordinate"]
2744 #[doc = r" access between multiple new instances."]
2745 #[doc = r""]
2746 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2747 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2748 #[doc = r" no stolen instances are passed to such software."]
2749 pub unsafe fn steal() -> Self {
2750 Self {
2751 _marker: PhantomData,
2752 }
2753 }
2754}
2755impl Deref for MCPWM1 {
2756 type Target = mcpwm0::RegisterBlock;
2757 #[inline(always)]
2758 fn deref(&self) -> &Self::Target {
2759 unsafe { &*Self::PTR }
2760 }
2761}
2762impl core::fmt::Debug for MCPWM1 {
2763 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2764 f.debug_struct("MCPWM1").finish()
2765 }
2766}
2767#[doc = "Motor Control Pulse-Width Modulation 1"]
2768pub use self::mcpwm0 as mcpwm1;
2769#[doc = "Parallel IO Controller"]
2770pub struct PARL_IO {
2771 _marker: PhantomData<*const ()>,
2772}
2773unsafe impl Send for PARL_IO {}
2774impl PARL_IO {
2775 #[doc = r"Pointer to the register block"]
2776 pub const PTR: *const parl_io::RegisterBlock = 0x500c_f000 as *const _;
2777 #[doc = r"Return the pointer to the register block"]
2778 #[inline(always)]
2779 pub const fn ptr() -> *const parl_io::RegisterBlock {
2780 Self::PTR
2781 }
2782 #[doc = r" Steal an instance of this peripheral"]
2783 #[doc = r""]
2784 #[doc = r" # Safety"]
2785 #[doc = r""]
2786 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2787 #[doc = r" that may race with any existing instances, for example by only"]
2788 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2789 #[doc = r" original peripheral and using critical sections to coordinate"]
2790 #[doc = r" access between multiple new instances."]
2791 #[doc = r""]
2792 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2793 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2794 #[doc = r" no stolen instances are passed to such software."]
2795 pub unsafe fn steal() -> Self {
2796 Self {
2797 _marker: PhantomData,
2798 }
2799 }
2800}
2801impl Deref for PARL_IO {
2802 type Target = parl_io::RegisterBlock;
2803 #[inline(always)]
2804 fn deref(&self) -> &Self::Target {
2805 unsafe { &*Self::PTR }
2806 }
2807}
2808impl core::fmt::Debug for PARL_IO {
2809 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2810 f.debug_struct("PARL_IO").finish()
2811 }
2812}
2813#[doc = "Parallel IO Controller"]
2814pub mod parl_io;
2815#[doc = "PAU Peripheral"]
2816pub struct PAU {
2817 _marker: PhantomData<*const ()>,
2818}
2819unsafe impl Send for PAU {}
2820impl PAU {
2821 #[doc = r"Pointer to the register block"]
2822 pub const PTR: *const pau::RegisterBlock = 0x6009_3000 as *const _;
2823 #[doc = r"Return the pointer to the register block"]
2824 #[inline(always)]
2825 pub const fn ptr() -> *const pau::RegisterBlock {
2826 Self::PTR
2827 }
2828 #[doc = r" Steal an instance of this peripheral"]
2829 #[doc = r""]
2830 #[doc = r" # Safety"]
2831 #[doc = r""]
2832 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2833 #[doc = r" that may race with any existing instances, for example by only"]
2834 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2835 #[doc = r" original peripheral and using critical sections to coordinate"]
2836 #[doc = r" access between multiple new instances."]
2837 #[doc = r""]
2838 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2839 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2840 #[doc = r" no stolen instances are passed to such software."]
2841 pub unsafe fn steal() -> Self {
2842 Self {
2843 _marker: PhantomData,
2844 }
2845 }
2846}
2847impl Deref for PAU {
2848 type Target = pau::RegisterBlock;
2849 #[inline(always)]
2850 fn deref(&self) -> &Self::Target {
2851 unsafe { &*Self::PTR }
2852 }
2853}
2854impl core::fmt::Debug for PAU {
2855 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2856 f.debug_struct("PAU").finish()
2857 }
2858}
2859#[doc = "PAU Peripheral"]
2860pub mod pau;
2861#[doc = "Pulse Count Controller"]
2862pub struct PCNT {
2863 _marker: PhantomData<*const ()>,
2864}
2865unsafe impl Send for PCNT {}
2866impl PCNT {
2867 #[doc = r"Pointer to the register block"]
2868 pub const PTR: *const pcnt::RegisterBlock = 0x500c_9000 as *const _;
2869 #[doc = r"Return the pointer to the register block"]
2870 #[inline(always)]
2871 pub const fn ptr() -> *const pcnt::RegisterBlock {
2872 Self::PTR
2873 }
2874 #[doc = r" Steal an instance of this peripheral"]
2875 #[doc = r""]
2876 #[doc = r" # Safety"]
2877 #[doc = r""]
2878 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2879 #[doc = r" that may race with any existing instances, for example by only"]
2880 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2881 #[doc = r" original peripheral and using critical sections to coordinate"]
2882 #[doc = r" access between multiple new instances."]
2883 #[doc = r""]
2884 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2885 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2886 #[doc = r" no stolen instances are passed to such software."]
2887 pub unsafe fn steal() -> Self {
2888 Self {
2889 _marker: PhantomData,
2890 }
2891 }
2892}
2893impl Deref for PCNT {
2894 type Target = pcnt::RegisterBlock;
2895 #[inline(always)]
2896 fn deref(&self) -> &Self::Target {
2897 unsafe { &*Self::PTR }
2898 }
2899}
2900impl core::fmt::Debug for PCNT {
2901 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2902 f.debug_struct("PCNT").finish()
2903 }
2904}
2905#[doc = "Pulse Count Controller"]
2906pub mod pcnt;
2907#[doc = "PMU Peripheral"]
2908pub struct PMU {
2909 _marker: PhantomData<*const ()>,
2910}
2911unsafe impl Send for PMU {}
2912impl PMU {
2913 #[doc = r"Pointer to the register block"]
2914 pub const PTR: *const pmu::RegisterBlock = 0x5011_5000 as *const _;
2915 #[doc = r"Return the pointer to the register block"]
2916 #[inline(always)]
2917 pub const fn ptr() -> *const pmu::RegisterBlock {
2918 Self::PTR
2919 }
2920 #[doc = r" Steal an instance of this peripheral"]
2921 #[doc = r""]
2922 #[doc = r" # Safety"]
2923 #[doc = r""]
2924 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2925 #[doc = r" that may race with any existing instances, for example by only"]
2926 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2927 #[doc = r" original peripheral and using critical sections to coordinate"]
2928 #[doc = r" access between multiple new instances."]
2929 #[doc = r""]
2930 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2931 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2932 #[doc = r" no stolen instances are passed to such software."]
2933 pub unsafe fn steal() -> Self {
2934 Self {
2935 _marker: PhantomData,
2936 }
2937 }
2938}
2939impl Deref for PMU {
2940 type Target = pmu::RegisterBlock;
2941 #[inline(always)]
2942 fn deref(&self) -> &Self::Target {
2943 unsafe { &*Self::PTR }
2944 }
2945}
2946impl core::fmt::Debug for PMU {
2947 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2948 f.debug_struct("PMU").finish()
2949 }
2950}
2951#[doc = "PMU Peripheral"]
2952pub mod pmu;
2953#[doc = "PPA Peripheral"]
2954pub struct PPA {
2955 _marker: PhantomData<*const ()>,
2956}
2957unsafe impl Send for PPA {}
2958impl PPA {
2959 #[doc = r"Pointer to the register block"]
2960 pub const PTR: *const ppa::RegisterBlock = 0x5008_7000 as *const _;
2961 #[doc = r"Return the pointer to the register block"]
2962 #[inline(always)]
2963 pub const fn ptr() -> *const ppa::RegisterBlock {
2964 Self::PTR
2965 }
2966 #[doc = r" Steal an instance of this peripheral"]
2967 #[doc = r""]
2968 #[doc = r" # Safety"]
2969 #[doc = r""]
2970 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2971 #[doc = r" that may race with any existing instances, for example by only"]
2972 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2973 #[doc = r" original peripheral and using critical sections to coordinate"]
2974 #[doc = r" access between multiple new instances."]
2975 #[doc = r""]
2976 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2977 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2978 #[doc = r" no stolen instances are passed to such software."]
2979 pub unsafe fn steal() -> Self {
2980 Self {
2981 _marker: PhantomData,
2982 }
2983 }
2984}
2985impl Deref for PPA {
2986 type Target = ppa::RegisterBlock;
2987 #[inline(always)]
2988 fn deref(&self) -> &Self::Target {
2989 unsafe { &*Self::PTR }
2990 }
2991}
2992impl core::fmt::Debug for PPA {
2993 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2994 f.debug_struct("PPA").finish()
2995 }
2996}
2997#[doc = "PPA Peripheral"]
2998pub mod ppa;
2999#[doc = "PVT Peripheral"]
3000pub struct PVT {
3001 _marker: PhantomData<*const ()>,
3002}
3003unsafe impl Send for PVT {}
3004impl PVT {
3005 #[doc = r"Pointer to the register block"]
3006 pub const PTR: *const pvt::RegisterBlock = 0x5009_e000 as *const _;
3007 #[doc = r"Return the pointer to the register block"]
3008 #[inline(always)]
3009 pub const fn ptr() -> *const pvt::RegisterBlock {
3010 Self::PTR
3011 }
3012 #[doc = r" Steal an instance of this peripheral"]
3013 #[doc = r""]
3014 #[doc = r" # Safety"]
3015 #[doc = r""]
3016 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3017 #[doc = r" that may race with any existing instances, for example by only"]
3018 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3019 #[doc = r" original peripheral and using critical sections to coordinate"]
3020 #[doc = r" access between multiple new instances."]
3021 #[doc = r""]
3022 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3023 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3024 #[doc = r" no stolen instances are passed to such software."]
3025 pub unsafe fn steal() -> Self {
3026 Self {
3027 _marker: PhantomData,
3028 }
3029 }
3030}
3031impl Deref for PVT {
3032 type Target = pvt::RegisterBlock;
3033 #[inline(always)]
3034 fn deref(&self) -> &Self::Target {
3035 unsafe { &*Self::PTR }
3036 }
3037}
3038impl core::fmt::Debug for PVT {
3039 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3040 f.debug_struct("PVT").finish()
3041 }
3042}
3043#[doc = "PVT Peripheral"]
3044pub mod pvt;
3045#[doc = "Remote Control"]
3046pub struct RMT {
3047 _marker: PhantomData<*const ()>,
3048}
3049unsafe impl Send for RMT {}
3050impl RMT {
3051 #[doc = r"Pointer to the register block"]
3052 pub const PTR: *const rmt::RegisterBlock = 0x500d_4000 as *const _;
3053 #[doc = r"Return the pointer to the register block"]
3054 #[inline(always)]
3055 pub const fn ptr() -> *const rmt::RegisterBlock {
3056 Self::PTR
3057 }
3058 #[doc = r" Steal an instance of this peripheral"]
3059 #[doc = r""]
3060 #[doc = r" # Safety"]
3061 #[doc = r""]
3062 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3063 #[doc = r" that may race with any existing instances, for example by only"]
3064 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3065 #[doc = r" original peripheral and using critical sections to coordinate"]
3066 #[doc = r" access between multiple new instances."]
3067 #[doc = r""]
3068 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3069 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3070 #[doc = r" no stolen instances are passed to such software."]
3071 pub unsafe fn steal() -> Self {
3072 Self {
3073 _marker: PhantomData,
3074 }
3075 }
3076}
3077impl Deref for RMT {
3078 type Target = rmt::RegisterBlock;
3079 #[inline(always)]
3080 fn deref(&self) -> &Self::Target {
3081 unsafe { &*Self::PTR }
3082 }
3083}
3084impl core::fmt::Debug for RMT {
3085 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3086 f.debug_struct("RMT").finish()
3087 }
3088}
3089#[doc = "Remote Control"]
3090pub mod rmt;
3091#[doc = "RSA (Rivest Shamir Adleman) Accelerator"]
3092pub struct RSA {
3093 _marker: PhantomData<*const ()>,
3094}
3095unsafe impl Send for RSA {}
3096impl RSA {
3097 #[doc = r"Pointer to the register block"]
3098 pub const PTR: *const rsa::RegisterBlock = 0x5009_2000 as *const _;
3099 #[doc = r"Return the pointer to the register block"]
3100 #[inline(always)]
3101 pub const fn ptr() -> *const rsa::RegisterBlock {
3102 Self::PTR
3103 }
3104 #[doc = r" Steal an instance of this peripheral"]
3105 #[doc = r""]
3106 #[doc = r" # Safety"]
3107 #[doc = r""]
3108 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3109 #[doc = r" that may race with any existing instances, for example by only"]
3110 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3111 #[doc = r" original peripheral and using critical sections to coordinate"]
3112 #[doc = r" access between multiple new instances."]
3113 #[doc = r""]
3114 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3115 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3116 #[doc = r" no stolen instances are passed to such software."]
3117 pub unsafe fn steal() -> Self {
3118 Self {
3119 _marker: PhantomData,
3120 }
3121 }
3122}
3123impl Deref for RSA {
3124 type Target = rsa::RegisterBlock;
3125 #[inline(always)]
3126 fn deref(&self) -> &Self::Target {
3127 unsafe { &*Self::PTR }
3128 }
3129}
3130impl core::fmt::Debug for RSA {
3131 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3132 f.debug_struct("RSA").finish()
3133 }
3134}
3135#[doc = "RSA (Rivest Shamir Adleman) Accelerator"]
3136pub mod rsa;
3137#[doc = "Low-power Analog to Digital Converter"]
3138pub struct LP_ADC {
3139 _marker: PhantomData<*const ()>,
3140}
3141unsafe impl Send for LP_ADC {}
3142impl LP_ADC {
3143 #[doc = r"Pointer to the register block"]
3144 pub const PTR: *const lp_adc::RegisterBlock = 0x5012_7000 as *const _;
3145 #[doc = r"Return the pointer to the register block"]
3146 #[inline(always)]
3147 pub const fn ptr() -> *const lp_adc::RegisterBlock {
3148 Self::PTR
3149 }
3150 #[doc = r" Steal an instance of this peripheral"]
3151 #[doc = r""]
3152 #[doc = r" # Safety"]
3153 #[doc = r""]
3154 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3155 #[doc = r" that may race with any existing instances, for example by only"]
3156 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3157 #[doc = r" original peripheral and using critical sections to coordinate"]
3158 #[doc = r" access between multiple new instances."]
3159 #[doc = r""]
3160 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3161 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3162 #[doc = r" no stolen instances are passed to such software."]
3163 pub unsafe fn steal() -> Self {
3164 Self {
3165 _marker: PhantomData,
3166 }
3167 }
3168}
3169impl Deref for LP_ADC {
3170 type Target = lp_adc::RegisterBlock;
3171 #[inline(always)]
3172 fn deref(&self) -> &Self::Target {
3173 unsafe { &*Self::PTR }
3174 }
3175}
3176impl core::fmt::Debug for LP_ADC {
3177 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3178 f.debug_struct("LP_ADC").finish()
3179 }
3180}
3181#[doc = "Low-power Analog to Digital Converter"]
3182pub mod lp_adc;
3183#[doc = "Low-power Timer"]
3184pub struct LP_TIMER {
3185 _marker: PhantomData<*const ()>,
3186}
3187unsafe impl Send for LP_TIMER {}
3188impl LP_TIMER {
3189 #[doc = r"Pointer to the register block"]
3190 pub const PTR: *const lp_timer::RegisterBlock = 0x5011_2000 as *const _;
3191 #[doc = r"Return the pointer to the register block"]
3192 #[inline(always)]
3193 pub const fn ptr() -> *const lp_timer::RegisterBlock {
3194 Self::PTR
3195 }
3196 #[doc = r" Steal an instance of this peripheral"]
3197 #[doc = r""]
3198 #[doc = r" # Safety"]
3199 #[doc = r""]
3200 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3201 #[doc = r" that may race with any existing instances, for example by only"]
3202 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3203 #[doc = r" original peripheral and using critical sections to coordinate"]
3204 #[doc = r" access between multiple new instances."]
3205 #[doc = r""]
3206 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3207 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3208 #[doc = r" no stolen instances are passed to such software."]
3209 pub unsafe fn steal() -> Self {
3210 Self {
3211 _marker: PhantomData,
3212 }
3213 }
3214}
3215impl Deref for LP_TIMER {
3216 type Target = lp_timer::RegisterBlock;
3217 #[inline(always)]
3218 fn deref(&self) -> &Self::Target {
3219 unsafe { &*Self::PTR }
3220 }
3221}
3222impl core::fmt::Debug for LP_TIMER {
3223 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3224 f.debug_struct("LP_TIMER").finish()
3225 }
3226}
3227#[doc = "Low-power Timer"]
3228pub mod lp_timer;
3229#[doc = "LP_TOUCH Peripheral"]
3230pub struct LP_TOUCH {
3231 _marker: PhantomData<*const ()>,
3232}
3233unsafe impl Send for LP_TOUCH {}
3234impl LP_TOUCH {
3235 #[doc = r"Pointer to the register block"]
3236 pub const PTR: *const lp_touch::RegisterBlock = 0x5012_8000 as *const _;
3237 #[doc = r"Return the pointer to the register block"]
3238 #[inline(always)]
3239 pub const fn ptr() -> *const lp_touch::RegisterBlock {
3240 Self::PTR
3241 }
3242 #[doc = r" Steal an instance of this peripheral"]
3243 #[doc = r""]
3244 #[doc = r" # Safety"]
3245 #[doc = r""]
3246 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3247 #[doc = r" that may race with any existing instances, for example by only"]
3248 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3249 #[doc = r" original peripheral and using critical sections to coordinate"]
3250 #[doc = r" access between multiple new instances."]
3251 #[doc = r""]
3252 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3253 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3254 #[doc = r" no stolen instances are passed to such software."]
3255 pub unsafe fn steal() -> Self {
3256 Self {
3257 _marker: PhantomData,
3258 }
3259 }
3260}
3261impl Deref for LP_TOUCH {
3262 type Target = lp_touch::RegisterBlock;
3263 #[inline(always)]
3264 fn deref(&self) -> &Self::Target {
3265 unsafe { &*Self::PTR }
3266 }
3267}
3268impl core::fmt::Debug for LP_TOUCH {
3269 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3270 f.debug_struct("LP_TOUCH").finish()
3271 }
3272}
3273#[doc = "LP_TOUCH Peripheral"]
3274pub mod lp_touch;
3275#[doc = "Low-power Watchdog Timer"]
3276pub struct LP_WDT {
3277 _marker: PhantomData<*const ()>,
3278}
3279unsafe impl Send for LP_WDT {}
3280impl LP_WDT {
3281 #[doc = r"Pointer to the register block"]
3282 pub const PTR: *const lp_wdt::RegisterBlock = 0x5011_6000 as *const _;
3283 #[doc = r"Return the pointer to the register block"]
3284 #[inline(always)]
3285 pub const fn ptr() -> *const lp_wdt::RegisterBlock {
3286 Self::PTR
3287 }
3288 #[doc = r" Steal an instance of this peripheral"]
3289 #[doc = r""]
3290 #[doc = r" # Safety"]
3291 #[doc = r""]
3292 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3293 #[doc = r" that may race with any existing instances, for example by only"]
3294 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3295 #[doc = r" original peripheral and using critical sections to coordinate"]
3296 #[doc = r" access between multiple new instances."]
3297 #[doc = r""]
3298 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3299 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3300 #[doc = r" no stolen instances are passed to such software."]
3301 pub unsafe fn steal() -> Self {
3302 Self {
3303 _marker: PhantomData,
3304 }
3305 }
3306}
3307impl Deref for LP_WDT {
3308 type Target = lp_wdt::RegisterBlock;
3309 #[inline(always)]
3310 fn deref(&self) -> &Self::Target {
3311 unsafe { &*Self::PTR }
3312 }
3313}
3314impl core::fmt::Debug for LP_WDT {
3315 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3316 f.debug_struct("LP_WDT").finish()
3317 }
3318}
3319#[doc = "Low-power Watchdog Timer"]
3320pub mod lp_wdt;
3321#[doc = "SD/MMC Host Controller"]
3322pub struct SDHOST {
3323 _marker: PhantomData<*const ()>,
3324}
3325unsafe impl Send for SDHOST {}
3326impl SDHOST {
3327 #[doc = r"Pointer to the register block"]
3328 pub const PTR: *const sdhost::RegisterBlock = 0x5008_3000 as *const _;
3329 #[doc = r"Return the pointer to the register block"]
3330 #[inline(always)]
3331 pub const fn ptr() -> *const sdhost::RegisterBlock {
3332 Self::PTR
3333 }
3334 #[doc = r" Steal an instance of this peripheral"]
3335 #[doc = r""]
3336 #[doc = r" # Safety"]
3337 #[doc = r""]
3338 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3339 #[doc = r" that may race with any existing instances, for example by only"]
3340 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3341 #[doc = r" original peripheral and using critical sections to coordinate"]
3342 #[doc = r" access between multiple new instances."]
3343 #[doc = r""]
3344 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3345 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3346 #[doc = r" no stolen instances are passed to such software."]
3347 pub unsafe fn steal() -> Self {
3348 Self {
3349 _marker: PhantomData,
3350 }
3351 }
3352}
3353impl Deref for SDHOST {
3354 type Target = sdhost::RegisterBlock;
3355 #[inline(always)]
3356 fn deref(&self) -> &Self::Target {
3357 unsafe { &*Self::PTR }
3358 }
3359}
3360impl core::fmt::Debug for SDHOST {
3361 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3362 f.debug_struct("SDHOST").finish()
3363 }
3364}
3365#[doc = "SD/MMC Host Controller"]
3366pub mod sdhost;
3367#[doc = "SHA (Secure Hash Algorithm) Accelerator"]
3368pub struct SHA {
3369 _marker: PhantomData<*const ()>,
3370}
3371unsafe impl Send for SHA {}
3372impl SHA {
3373 #[doc = r"Pointer to the register block"]
3374 pub const PTR: *const sha::RegisterBlock = 0x5009_1000 as *const _;
3375 #[doc = r"Return the pointer to the register block"]
3376 #[inline(always)]
3377 pub const fn ptr() -> *const sha::RegisterBlock {
3378 Self::PTR
3379 }
3380 #[doc = r" Steal an instance of this peripheral"]
3381 #[doc = r""]
3382 #[doc = r" # Safety"]
3383 #[doc = r""]
3384 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3385 #[doc = r" that may race with any existing instances, for example by only"]
3386 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3387 #[doc = r" original peripheral and using critical sections to coordinate"]
3388 #[doc = r" access between multiple new instances."]
3389 #[doc = r""]
3390 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3391 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3392 #[doc = r" no stolen instances are passed to such software."]
3393 pub unsafe fn steal() -> Self {
3394 Self {
3395 _marker: PhantomData,
3396 }
3397 }
3398}
3399impl Deref for SHA {
3400 type Target = sha::RegisterBlock;
3401 #[inline(always)]
3402 fn deref(&self) -> &Self::Target {
3403 unsafe { &*Self::PTR }
3404 }
3405}
3406impl core::fmt::Debug for SHA {
3407 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3408 f.debug_struct("SHA").finish()
3409 }
3410}
3411#[doc = "SHA (Secure Hash Algorithm) Accelerator"]
3412pub mod sha;
3413#[doc = "Event Task Matrix"]
3414pub struct SOC_ETM {
3415 _marker: PhantomData<*const ()>,
3416}
3417unsafe impl Send for SOC_ETM {}
3418impl SOC_ETM {
3419 #[doc = r"Pointer to the register block"]
3420 pub const PTR: *const soc_etm::RegisterBlock = 0x500d_5000 as *const _;
3421 #[doc = r"Return the pointer to the register block"]
3422 #[inline(always)]
3423 pub const fn ptr() -> *const soc_etm::RegisterBlock {
3424 Self::PTR
3425 }
3426 #[doc = r" Steal an instance of this peripheral"]
3427 #[doc = r""]
3428 #[doc = r" # Safety"]
3429 #[doc = r""]
3430 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3431 #[doc = r" that may race with any existing instances, for example by only"]
3432 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3433 #[doc = r" original peripheral and using critical sections to coordinate"]
3434 #[doc = r" access between multiple new instances."]
3435 #[doc = r""]
3436 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3437 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3438 #[doc = r" no stolen instances are passed to such software."]
3439 pub unsafe fn steal() -> Self {
3440 Self {
3441 _marker: PhantomData,
3442 }
3443 }
3444}
3445impl Deref for SOC_ETM {
3446 type Target = soc_etm::RegisterBlock;
3447 #[inline(always)]
3448 fn deref(&self) -> &Self::Target {
3449 unsafe { &*Self::PTR }
3450 }
3451}
3452impl core::fmt::Debug for SOC_ETM {
3453 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3454 f.debug_struct("SOC_ETM").finish()
3455 }
3456}
3457#[doc = "Event Task Matrix"]
3458pub mod soc_etm;
3459#[doc = "SPI (Serial Peripheral Interface) Controller 0"]
3460pub struct SPI0 {
3461 _marker: PhantomData<*const ()>,
3462}
3463unsafe impl Send for SPI0 {}
3464impl SPI0 {
3465 #[doc = r"Pointer to the register block"]
3466 pub const PTR: *const spi0::RegisterBlock = 0x5008_c000 as *const _;
3467 #[doc = r"Return the pointer to the register block"]
3468 #[inline(always)]
3469 pub const fn ptr() -> *const spi0::RegisterBlock {
3470 Self::PTR
3471 }
3472 #[doc = r" Steal an instance of this peripheral"]
3473 #[doc = r""]
3474 #[doc = r" # Safety"]
3475 #[doc = r""]
3476 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3477 #[doc = r" that may race with any existing instances, for example by only"]
3478 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3479 #[doc = r" original peripheral and using critical sections to coordinate"]
3480 #[doc = r" access between multiple new instances."]
3481 #[doc = r""]
3482 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3483 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3484 #[doc = r" no stolen instances are passed to such software."]
3485 pub unsafe fn steal() -> Self {
3486 Self {
3487 _marker: PhantomData,
3488 }
3489 }
3490}
3491impl Deref for SPI0 {
3492 type Target = spi0::RegisterBlock;
3493 #[inline(always)]
3494 fn deref(&self) -> &Self::Target {
3495 unsafe { &*Self::PTR }
3496 }
3497}
3498impl core::fmt::Debug for SPI0 {
3499 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3500 f.debug_struct("SPI0").finish()
3501 }
3502}
3503#[doc = "SPI (Serial Peripheral Interface) Controller 0"]
3504pub mod spi0;
3505#[doc = "SPI (Serial Peripheral Interface) Controller 1"]
3506pub struct SPI1 {
3507 _marker: PhantomData<*const ()>,
3508}
3509unsafe impl Send for SPI1 {}
3510impl SPI1 {
3511 #[doc = r"Pointer to the register block"]
3512 pub const PTR: *const spi1::RegisterBlock = 0x5008_d000 as *const _;
3513 #[doc = r"Return the pointer to the register block"]
3514 #[inline(always)]
3515 pub const fn ptr() -> *const spi1::RegisterBlock {
3516 Self::PTR
3517 }
3518 #[doc = r" Steal an instance of this peripheral"]
3519 #[doc = r""]
3520 #[doc = r" # Safety"]
3521 #[doc = r""]
3522 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3523 #[doc = r" that may race with any existing instances, for example by only"]
3524 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3525 #[doc = r" original peripheral and using critical sections to coordinate"]
3526 #[doc = r" access between multiple new instances."]
3527 #[doc = r""]
3528 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3529 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3530 #[doc = r" no stolen instances are passed to such software."]
3531 pub unsafe fn steal() -> Self {
3532 Self {
3533 _marker: PhantomData,
3534 }
3535 }
3536}
3537impl Deref for SPI1 {
3538 type Target = spi1::RegisterBlock;
3539 #[inline(always)]
3540 fn deref(&self) -> &Self::Target {
3541 unsafe { &*Self::PTR }
3542 }
3543}
3544impl core::fmt::Debug for SPI1 {
3545 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3546 f.debug_struct("SPI1").finish()
3547 }
3548}
3549#[doc = "SPI (Serial Peripheral Interface) Controller 1"]
3550pub mod spi1;
3551#[doc = "SPI (Serial Peripheral Interface) Controller 2"]
3552pub struct SPI2 {
3553 _marker: PhantomData<*const ()>,
3554}
3555unsafe impl Send for SPI2 {}
3556impl SPI2 {
3557 #[doc = r"Pointer to the register block"]
3558 pub const PTR: *const spi2::RegisterBlock = 0x500d_0000 as *const _;
3559 #[doc = r"Return the pointer to the register block"]
3560 #[inline(always)]
3561 pub const fn ptr() -> *const spi2::RegisterBlock {
3562 Self::PTR
3563 }
3564 #[doc = r" Steal an instance of this peripheral"]
3565 #[doc = r""]
3566 #[doc = r" # Safety"]
3567 #[doc = r""]
3568 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3569 #[doc = r" that may race with any existing instances, for example by only"]
3570 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3571 #[doc = r" original peripheral and using critical sections to coordinate"]
3572 #[doc = r" access between multiple new instances."]
3573 #[doc = r""]
3574 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3575 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3576 #[doc = r" no stolen instances are passed to such software."]
3577 pub unsafe fn steal() -> Self {
3578 Self {
3579 _marker: PhantomData,
3580 }
3581 }
3582}
3583impl Deref for SPI2 {
3584 type Target = spi2::RegisterBlock;
3585 #[inline(always)]
3586 fn deref(&self) -> &Self::Target {
3587 unsafe { &*Self::PTR }
3588 }
3589}
3590impl core::fmt::Debug for SPI2 {
3591 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3592 f.debug_struct("SPI2").finish()
3593 }
3594}
3595#[doc = "SPI (Serial Peripheral Interface) Controller 2"]
3596pub mod spi2;
3597#[doc = "SPI (Serial Peripheral Interface) Controller 3"]
3598pub struct SPI3 {
3599 _marker: PhantomData<*const ()>,
3600}
3601unsafe impl Send for SPI3 {}
3602impl SPI3 {
3603 #[doc = r"Pointer to the register block"]
3604 pub const PTR: *const spi3::RegisterBlock = 0x500d_1000 as *const _;
3605 #[doc = r"Return the pointer to the register block"]
3606 #[inline(always)]
3607 pub const fn ptr() -> *const spi3::RegisterBlock {
3608 Self::PTR
3609 }
3610 #[doc = r" Steal an instance of this peripheral"]
3611 #[doc = r""]
3612 #[doc = r" # Safety"]
3613 #[doc = r""]
3614 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3615 #[doc = r" that may race with any existing instances, for example by only"]
3616 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3617 #[doc = r" original peripheral and using critical sections to coordinate"]
3618 #[doc = r" access between multiple new instances."]
3619 #[doc = r""]
3620 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3621 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3622 #[doc = r" no stolen instances are passed to such software."]
3623 pub unsafe fn steal() -> Self {
3624 Self {
3625 _marker: PhantomData,
3626 }
3627 }
3628}
3629impl Deref for SPI3 {
3630 type Target = spi3::RegisterBlock;
3631 #[inline(always)]
3632 fn deref(&self) -> &Self::Target {
3633 unsafe { &*Self::PTR }
3634 }
3635}
3636impl core::fmt::Debug for SPI3 {
3637 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3638 f.debug_struct("SPI3").finish()
3639 }
3640}
3641#[doc = "SPI (Serial Peripheral Interface) Controller 3"]
3642pub mod spi3;
3643#[doc = "System Timer"]
3644pub struct SYSTIMER {
3645 _marker: PhantomData<*const ()>,
3646}
3647unsafe impl Send for SYSTIMER {}
3648impl SYSTIMER {
3649 #[doc = r"Pointer to the register block"]
3650 pub const PTR: *const systimer::RegisterBlock = 0x500e_2000 as *const _;
3651 #[doc = r"Return the pointer to the register block"]
3652 #[inline(always)]
3653 pub const fn ptr() -> *const systimer::RegisterBlock {
3654 Self::PTR
3655 }
3656 #[doc = r" Steal an instance of this peripheral"]
3657 #[doc = r""]
3658 #[doc = r" # Safety"]
3659 #[doc = r""]
3660 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3661 #[doc = r" that may race with any existing instances, for example by only"]
3662 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3663 #[doc = r" original peripheral and using critical sections to coordinate"]
3664 #[doc = r" access between multiple new instances."]
3665 #[doc = r""]
3666 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3667 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3668 #[doc = r" no stolen instances are passed to such software."]
3669 pub unsafe fn steal() -> Self {
3670 Self {
3671 _marker: PhantomData,
3672 }
3673 }
3674}
3675impl Deref for SYSTIMER {
3676 type Target = systimer::RegisterBlock;
3677 #[inline(always)]
3678 fn deref(&self) -> &Self::Target {
3679 unsafe { &*Self::PTR }
3680 }
3681}
3682impl core::fmt::Debug for SYSTIMER {
3683 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3684 f.debug_struct("SYSTIMER").finish()
3685 }
3686}
3687#[doc = "System Timer"]
3688pub mod systimer;
3689#[doc = "Timer Group 0"]
3690pub struct TIMG0 {
3691 _marker: PhantomData<*const ()>,
3692}
3693unsafe impl Send for TIMG0 {}
3694impl TIMG0 {
3695 #[doc = r"Pointer to the register block"]
3696 pub const PTR: *const timg0::RegisterBlock = 0x500c_2000 as *const _;
3697 #[doc = r"Return the pointer to the register block"]
3698 #[inline(always)]
3699 pub const fn ptr() -> *const timg0::RegisterBlock {
3700 Self::PTR
3701 }
3702 #[doc = r" Steal an instance of this peripheral"]
3703 #[doc = r""]
3704 #[doc = r" # Safety"]
3705 #[doc = r""]
3706 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3707 #[doc = r" that may race with any existing instances, for example by only"]
3708 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3709 #[doc = r" original peripheral and using critical sections to coordinate"]
3710 #[doc = r" access between multiple new instances."]
3711 #[doc = r""]
3712 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3713 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3714 #[doc = r" no stolen instances are passed to such software."]
3715 pub unsafe fn steal() -> Self {
3716 Self {
3717 _marker: PhantomData,
3718 }
3719 }
3720}
3721impl Deref for TIMG0 {
3722 type Target = timg0::RegisterBlock;
3723 #[inline(always)]
3724 fn deref(&self) -> &Self::Target {
3725 unsafe { &*Self::PTR }
3726 }
3727}
3728impl core::fmt::Debug for TIMG0 {
3729 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3730 f.debug_struct("TIMG0").finish()
3731 }
3732}
3733#[doc = "Timer Group 0"]
3734pub mod timg0;
3735#[doc = "Timer Group 1"]
3736pub struct TIMG1 {
3737 _marker: PhantomData<*const ()>,
3738}
3739unsafe impl Send for TIMG1 {}
3740impl TIMG1 {
3741 #[doc = r"Pointer to the register block"]
3742 pub const PTR: *const timg0::RegisterBlock = 0x500c_3000 as *const _;
3743 #[doc = r"Return the pointer to the register block"]
3744 #[inline(always)]
3745 pub const fn ptr() -> *const timg0::RegisterBlock {
3746 Self::PTR
3747 }
3748 #[doc = r" Steal an instance of this peripheral"]
3749 #[doc = r""]
3750 #[doc = r" # Safety"]
3751 #[doc = r""]
3752 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3753 #[doc = r" that may race with any existing instances, for example by only"]
3754 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3755 #[doc = r" original peripheral and using critical sections to coordinate"]
3756 #[doc = r" access between multiple new instances."]
3757 #[doc = r""]
3758 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3759 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3760 #[doc = r" no stolen instances are passed to such software."]
3761 pub unsafe fn steal() -> Self {
3762 Self {
3763 _marker: PhantomData,
3764 }
3765 }
3766}
3767impl Deref for TIMG1 {
3768 type Target = timg0::RegisterBlock;
3769 #[inline(always)]
3770 fn deref(&self) -> &Self::Target {
3771 unsafe { &*Self::PTR }
3772 }
3773}
3774impl core::fmt::Debug for TIMG1 {
3775 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3776 f.debug_struct("TIMG1").finish()
3777 }
3778}
3779#[doc = "Timer Group 1"]
3780pub use self::timg0 as timg1;
3781#[doc = "TRACE0 Peripheral"]
3782pub struct TRACE0 {
3783 _marker: PhantomData<*const ()>,
3784}
3785unsafe impl Send for TRACE0 {}
3786impl TRACE0 {
3787 #[doc = r"Pointer to the register block"]
3788 pub const PTR: *const trace0::RegisterBlock = 0x3ff0_4000 as *const _;
3789 #[doc = r"Return the pointer to the register block"]
3790 #[inline(always)]
3791 pub const fn ptr() -> *const trace0::RegisterBlock {
3792 Self::PTR
3793 }
3794 #[doc = r" Steal an instance of this peripheral"]
3795 #[doc = r""]
3796 #[doc = r" # Safety"]
3797 #[doc = r""]
3798 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3799 #[doc = r" that may race with any existing instances, for example by only"]
3800 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3801 #[doc = r" original peripheral and using critical sections to coordinate"]
3802 #[doc = r" access between multiple new instances."]
3803 #[doc = r""]
3804 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3805 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3806 #[doc = r" no stolen instances are passed to such software."]
3807 pub unsafe fn steal() -> Self {
3808 Self {
3809 _marker: PhantomData,
3810 }
3811 }
3812}
3813impl Deref for TRACE0 {
3814 type Target = trace0::RegisterBlock;
3815 #[inline(always)]
3816 fn deref(&self) -> &Self::Target {
3817 unsafe { &*Self::PTR }
3818 }
3819}
3820impl core::fmt::Debug for TRACE0 {
3821 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3822 f.debug_struct("TRACE0").finish()
3823 }
3824}
3825#[doc = "TRACE0 Peripheral"]
3826pub mod trace0;
3827#[doc = "TRACE1 Peripheral"]
3828pub struct TRACE1 {
3829 _marker: PhantomData<*const ()>,
3830}
3831unsafe impl Send for TRACE1 {}
3832impl TRACE1 {
3833 #[doc = r"Pointer to the register block"]
3834 pub const PTR: *const trace0::RegisterBlock = 0x3ff0_5000 as *const _;
3835 #[doc = r"Return the pointer to the register block"]
3836 #[inline(always)]
3837 pub const fn ptr() -> *const trace0::RegisterBlock {
3838 Self::PTR
3839 }
3840 #[doc = r" Steal an instance of this peripheral"]
3841 #[doc = r""]
3842 #[doc = r" # Safety"]
3843 #[doc = r""]
3844 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3845 #[doc = r" that may race with any existing instances, for example by only"]
3846 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3847 #[doc = r" original peripheral and using critical sections to coordinate"]
3848 #[doc = r" access between multiple new instances."]
3849 #[doc = r""]
3850 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3851 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3852 #[doc = r" no stolen instances are passed to such software."]
3853 pub unsafe fn steal() -> Self {
3854 Self {
3855 _marker: PhantomData,
3856 }
3857 }
3858}
3859impl Deref for TRACE1 {
3860 type Target = trace0::RegisterBlock;
3861 #[inline(always)]
3862 fn deref(&self) -> &Self::Target {
3863 unsafe { &*Self::PTR }
3864 }
3865}
3866impl core::fmt::Debug for TRACE1 {
3867 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3868 f.debug_struct("TRACE1").finish()
3869 }
3870}
3871#[doc = "TRACE1 Peripheral"]
3872pub use self::trace0 as trace1;
3873#[doc = "Low-power Temperature Sensor"]
3874pub struct LP_TSENS {
3875 _marker: PhantomData<*const ()>,
3876}
3877unsafe impl Send for LP_TSENS {}
3878impl LP_TSENS {
3879 #[doc = r"Pointer to the register block"]
3880 pub const PTR: *const lp_tsens::RegisterBlock = 0x5012_f000 as *const _;
3881 #[doc = r"Return the pointer to the register block"]
3882 #[inline(always)]
3883 pub const fn ptr() -> *const lp_tsens::RegisterBlock {
3884 Self::PTR
3885 }
3886 #[doc = r" Steal an instance of this peripheral"]
3887 #[doc = r""]
3888 #[doc = r" # Safety"]
3889 #[doc = r""]
3890 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3891 #[doc = r" that may race with any existing instances, for example by only"]
3892 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3893 #[doc = r" original peripheral and using critical sections to coordinate"]
3894 #[doc = r" access between multiple new instances."]
3895 #[doc = r""]
3896 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3897 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3898 #[doc = r" no stolen instances are passed to such software."]
3899 pub unsafe fn steal() -> Self {
3900 Self {
3901 _marker: PhantomData,
3902 }
3903 }
3904}
3905impl Deref for LP_TSENS {
3906 type Target = lp_tsens::RegisterBlock;
3907 #[inline(always)]
3908 fn deref(&self) -> &Self::Target {
3909 unsafe { &*Self::PTR }
3910 }
3911}
3912impl core::fmt::Debug for LP_TSENS {
3913 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3914 f.debug_struct("LP_TSENS").finish()
3915 }
3916}
3917#[doc = "Low-power Temperature Sensor"]
3918pub mod lp_tsens;
3919#[doc = "Two-Wire Automotive Interface"]
3920pub struct TWAI0 {
3921 _marker: PhantomData<*const ()>,
3922}
3923unsafe impl Send for TWAI0 {}
3924impl TWAI0 {
3925 #[doc = r"Pointer to the register block"]
3926 pub const PTR: *const twai0::RegisterBlock = 0x500d_7000 as *const _;
3927 #[doc = r"Return the pointer to the register block"]
3928 #[inline(always)]
3929 pub const fn ptr() -> *const twai0::RegisterBlock {
3930 Self::PTR
3931 }
3932 #[doc = r" Steal an instance of this peripheral"]
3933 #[doc = r""]
3934 #[doc = r" # Safety"]
3935 #[doc = r""]
3936 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3937 #[doc = r" that may race with any existing instances, for example by only"]
3938 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3939 #[doc = r" original peripheral and using critical sections to coordinate"]
3940 #[doc = r" access between multiple new instances."]
3941 #[doc = r""]
3942 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3943 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3944 #[doc = r" no stolen instances are passed to such software."]
3945 pub unsafe fn steal() -> Self {
3946 Self {
3947 _marker: PhantomData,
3948 }
3949 }
3950}
3951impl Deref for TWAI0 {
3952 type Target = twai0::RegisterBlock;
3953 #[inline(always)]
3954 fn deref(&self) -> &Self::Target {
3955 unsafe { &*Self::PTR }
3956 }
3957}
3958impl core::fmt::Debug for TWAI0 {
3959 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3960 f.debug_struct("TWAI0").finish()
3961 }
3962}
3963#[doc = "Two-Wire Automotive Interface"]
3964pub mod twai0;
3965#[doc = "Two-Wire Automotive Interface"]
3966pub struct TWAI1 {
3967 _marker: PhantomData<*const ()>,
3968}
3969unsafe impl Send for TWAI1 {}
3970impl TWAI1 {
3971 #[doc = r"Pointer to the register block"]
3972 pub const PTR: *const twai0::RegisterBlock = 0x500d_8000 as *const _;
3973 #[doc = r"Return the pointer to the register block"]
3974 #[inline(always)]
3975 pub const fn ptr() -> *const twai0::RegisterBlock {
3976 Self::PTR
3977 }
3978 #[doc = r" Steal an instance of this peripheral"]
3979 #[doc = r""]
3980 #[doc = r" # Safety"]
3981 #[doc = r""]
3982 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3983 #[doc = r" that may race with any existing instances, for example by only"]
3984 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3985 #[doc = r" original peripheral and using critical sections to coordinate"]
3986 #[doc = r" access between multiple new instances."]
3987 #[doc = r""]
3988 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3989 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3990 #[doc = r" no stolen instances are passed to such software."]
3991 pub unsafe fn steal() -> Self {
3992 Self {
3993 _marker: PhantomData,
3994 }
3995 }
3996}
3997impl Deref for TWAI1 {
3998 type Target = twai0::RegisterBlock;
3999 #[inline(always)]
4000 fn deref(&self) -> &Self::Target {
4001 unsafe { &*Self::PTR }
4002 }
4003}
4004impl core::fmt::Debug for TWAI1 {
4005 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4006 f.debug_struct("TWAI1").finish()
4007 }
4008}
4009#[doc = "Two-Wire Automotive Interface"]
4010pub use self::twai0 as twai1;
4011#[doc = "Two-Wire Automotive Interface"]
4012pub struct TWAI2 {
4013 _marker: PhantomData<*const ()>,
4014}
4015unsafe impl Send for TWAI2 {}
4016impl TWAI2 {
4017 #[doc = r"Pointer to the register block"]
4018 pub const PTR: *const twai0::RegisterBlock = 0x500d_9000 as *const _;
4019 #[doc = r"Return the pointer to the register block"]
4020 #[inline(always)]
4021 pub const fn ptr() -> *const twai0::RegisterBlock {
4022 Self::PTR
4023 }
4024 #[doc = r" Steal an instance of this peripheral"]
4025 #[doc = r""]
4026 #[doc = r" # Safety"]
4027 #[doc = r""]
4028 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4029 #[doc = r" that may race with any existing instances, for example by only"]
4030 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4031 #[doc = r" original peripheral and using critical sections to coordinate"]
4032 #[doc = r" access between multiple new instances."]
4033 #[doc = r""]
4034 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4035 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4036 #[doc = r" no stolen instances are passed to such software."]
4037 pub unsafe fn steal() -> Self {
4038 Self {
4039 _marker: PhantomData,
4040 }
4041 }
4042}
4043impl Deref for TWAI2 {
4044 type Target = twai0::RegisterBlock;
4045 #[inline(always)]
4046 fn deref(&self) -> &Self::Target {
4047 unsafe { &*Self::PTR }
4048 }
4049}
4050impl core::fmt::Debug for TWAI2 {
4051 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4052 f.debug_struct("TWAI2").finish()
4053 }
4054}
4055#[doc = "Two-Wire Automotive Interface"]
4056pub use self::twai0 as twai2;
4057#[doc = "UART (Universal Asynchronous Receiver-Transmitter) Controller 0"]
4058pub struct UART0 {
4059 _marker: PhantomData<*const ()>,
4060}
4061unsafe impl Send for UART0 {}
4062impl UART0 {
4063 #[doc = r"Pointer to the register block"]
4064 pub const PTR: *const uart0::RegisterBlock = 0x500c_a000 as *const _;
4065 #[doc = r"Return the pointer to the register block"]
4066 #[inline(always)]
4067 pub const fn ptr() -> *const uart0::RegisterBlock {
4068 Self::PTR
4069 }
4070 #[doc = r" Steal an instance of this peripheral"]
4071 #[doc = r""]
4072 #[doc = r" # Safety"]
4073 #[doc = r""]
4074 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4075 #[doc = r" that may race with any existing instances, for example by only"]
4076 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4077 #[doc = r" original peripheral and using critical sections to coordinate"]
4078 #[doc = r" access between multiple new instances."]
4079 #[doc = r""]
4080 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4081 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4082 #[doc = r" no stolen instances are passed to such software."]
4083 pub unsafe fn steal() -> Self {
4084 Self {
4085 _marker: PhantomData,
4086 }
4087 }
4088}
4089impl Deref for UART0 {
4090 type Target = uart0::RegisterBlock;
4091 #[inline(always)]
4092 fn deref(&self) -> &Self::Target {
4093 unsafe { &*Self::PTR }
4094 }
4095}
4096impl core::fmt::Debug for UART0 {
4097 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4098 f.debug_struct("UART0").finish()
4099 }
4100}
4101#[doc = "UART (Universal Asynchronous Receiver-Transmitter) Controller 0"]
4102pub mod uart0;
4103#[doc = "UART (Universal Asynchronous Receiver-Transmitter) Controller 1"]
4104pub struct UART1 {
4105 _marker: PhantomData<*const ()>,
4106}
4107unsafe impl Send for UART1 {}
4108impl UART1 {
4109 #[doc = r"Pointer to the register block"]
4110 pub const PTR: *const uart0::RegisterBlock = 0x500c_b000 as *const _;
4111 #[doc = r"Return the pointer to the register block"]
4112 #[inline(always)]
4113 pub const fn ptr() -> *const uart0::RegisterBlock {
4114 Self::PTR
4115 }
4116 #[doc = r" Steal an instance of this peripheral"]
4117 #[doc = r""]
4118 #[doc = r" # Safety"]
4119 #[doc = r""]
4120 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4121 #[doc = r" that may race with any existing instances, for example by only"]
4122 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4123 #[doc = r" original peripheral and using critical sections to coordinate"]
4124 #[doc = r" access between multiple new instances."]
4125 #[doc = r""]
4126 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4127 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4128 #[doc = r" no stolen instances are passed to such software."]
4129 pub unsafe fn steal() -> Self {
4130 Self {
4131 _marker: PhantomData,
4132 }
4133 }
4134}
4135impl Deref for UART1 {
4136 type Target = uart0::RegisterBlock;
4137 #[inline(always)]
4138 fn deref(&self) -> &Self::Target {
4139 unsafe { &*Self::PTR }
4140 }
4141}
4142impl core::fmt::Debug for UART1 {
4143 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4144 f.debug_struct("UART1").finish()
4145 }
4146}
4147#[doc = "UART (Universal Asynchronous Receiver-Transmitter) Controller 1"]
4148pub use self::uart0 as uart1;
4149#[doc = "UART (Universal Asynchronous Receiver-Transmitter) Controller 2"]
4150pub struct UART2 {
4151 _marker: PhantomData<*const ()>,
4152}
4153unsafe impl Send for UART2 {}
4154impl UART2 {
4155 #[doc = r"Pointer to the register block"]
4156 pub const PTR: *const uart0::RegisterBlock = 0x500c_c000 as *const _;
4157 #[doc = r"Return the pointer to the register block"]
4158 #[inline(always)]
4159 pub const fn ptr() -> *const uart0::RegisterBlock {
4160 Self::PTR
4161 }
4162 #[doc = r" Steal an instance of this peripheral"]
4163 #[doc = r""]
4164 #[doc = r" # Safety"]
4165 #[doc = r""]
4166 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4167 #[doc = r" that may race with any existing instances, for example by only"]
4168 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4169 #[doc = r" original peripheral and using critical sections to coordinate"]
4170 #[doc = r" access between multiple new instances."]
4171 #[doc = r""]
4172 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4173 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4174 #[doc = r" no stolen instances are passed to such software."]
4175 pub unsafe fn steal() -> Self {
4176 Self {
4177 _marker: PhantomData,
4178 }
4179 }
4180}
4181impl Deref for UART2 {
4182 type Target = uart0::RegisterBlock;
4183 #[inline(always)]
4184 fn deref(&self) -> &Self::Target {
4185 unsafe { &*Self::PTR }
4186 }
4187}
4188impl core::fmt::Debug for UART2 {
4189 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4190 f.debug_struct("UART2").finish()
4191 }
4192}
4193#[doc = "UART (Universal Asynchronous Receiver-Transmitter) Controller 2"]
4194pub use self::uart0 as uart2;
4195#[doc = "UART (Universal Asynchronous Receiver-Transmitter) Controller 3"]
4196pub struct UART3 {
4197 _marker: PhantomData<*const ()>,
4198}
4199unsafe impl Send for UART3 {}
4200impl UART3 {
4201 #[doc = r"Pointer to the register block"]
4202 pub const PTR: *const uart0::RegisterBlock = 0x500c_d000 as *const _;
4203 #[doc = r"Return the pointer to the register block"]
4204 #[inline(always)]
4205 pub const fn ptr() -> *const uart0::RegisterBlock {
4206 Self::PTR
4207 }
4208 #[doc = r" Steal an instance of this peripheral"]
4209 #[doc = r""]
4210 #[doc = r" # Safety"]
4211 #[doc = r""]
4212 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4213 #[doc = r" that may race with any existing instances, for example by only"]
4214 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4215 #[doc = r" original peripheral and using critical sections to coordinate"]
4216 #[doc = r" access between multiple new instances."]
4217 #[doc = r""]
4218 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4219 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4220 #[doc = r" no stolen instances are passed to such software."]
4221 pub unsafe fn steal() -> Self {
4222 Self {
4223 _marker: PhantomData,
4224 }
4225 }
4226}
4227impl Deref for UART3 {
4228 type Target = uart0::RegisterBlock;
4229 #[inline(always)]
4230 fn deref(&self) -> &Self::Target {
4231 unsafe { &*Self::PTR }
4232 }
4233}
4234impl core::fmt::Debug for UART3 {
4235 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4236 f.debug_struct("UART3").finish()
4237 }
4238}
4239#[doc = "UART (Universal Asynchronous Receiver-Transmitter) Controller 3"]
4240pub use self::uart0 as uart3;
4241#[doc = "UART (Universal Asynchronous Receiver-Transmitter) Controller 4"]
4242pub struct UART4 {
4243 _marker: PhantomData<*const ()>,
4244}
4245unsafe impl Send for UART4 {}
4246impl UART4 {
4247 #[doc = r"Pointer to the register block"]
4248 pub const PTR: *const uart0::RegisterBlock = 0x500c_e000 as *const _;
4249 #[doc = r"Return the pointer to the register block"]
4250 #[inline(always)]
4251 pub const fn ptr() -> *const uart0::RegisterBlock {
4252 Self::PTR
4253 }
4254 #[doc = r" Steal an instance of this peripheral"]
4255 #[doc = r""]
4256 #[doc = r" # Safety"]
4257 #[doc = r""]
4258 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4259 #[doc = r" that may race with any existing instances, for example by only"]
4260 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4261 #[doc = r" original peripheral and using critical sections to coordinate"]
4262 #[doc = r" access between multiple new instances."]
4263 #[doc = r""]
4264 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4265 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4266 #[doc = r" no stolen instances are passed to such software."]
4267 pub unsafe fn steal() -> Self {
4268 Self {
4269 _marker: PhantomData,
4270 }
4271 }
4272}
4273impl Deref for UART4 {
4274 type Target = uart0::RegisterBlock;
4275 #[inline(always)]
4276 fn deref(&self) -> &Self::Target {
4277 unsafe { &*Self::PTR }
4278 }
4279}
4280impl core::fmt::Debug for UART4 {
4281 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4282 f.debug_struct("UART4").finish()
4283 }
4284}
4285#[doc = "UART (Universal Asynchronous Receiver-Transmitter) Controller 4"]
4286pub use self::uart0 as uart4;
4287#[doc = "Universal Host Controller Interface 0"]
4288pub struct UHCI0 {
4289 _marker: PhantomData<*const ()>,
4290}
4291unsafe impl Send for UHCI0 {}
4292impl UHCI0 {
4293 #[doc = r"Pointer to the register block"]
4294 pub const PTR: *const uhci0::RegisterBlock = 0x500d_f000 as *const _;
4295 #[doc = r"Return the pointer to the register block"]
4296 #[inline(always)]
4297 pub const fn ptr() -> *const uhci0::RegisterBlock {
4298 Self::PTR
4299 }
4300 #[doc = r" Steal an instance of this peripheral"]
4301 #[doc = r""]
4302 #[doc = r" # Safety"]
4303 #[doc = r""]
4304 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4305 #[doc = r" that may race with any existing instances, for example by only"]
4306 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4307 #[doc = r" original peripheral and using critical sections to coordinate"]
4308 #[doc = r" access between multiple new instances."]
4309 #[doc = r""]
4310 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4311 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4312 #[doc = r" no stolen instances are passed to such software."]
4313 pub unsafe fn steal() -> Self {
4314 Self {
4315 _marker: PhantomData,
4316 }
4317 }
4318}
4319impl Deref for UHCI0 {
4320 type Target = uhci0::RegisterBlock;
4321 #[inline(always)]
4322 fn deref(&self) -> &Self::Target {
4323 unsafe { &*Self::PTR }
4324 }
4325}
4326impl core::fmt::Debug for UHCI0 {
4327 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4328 f.debug_struct("UHCI0").finish()
4329 }
4330}
4331#[doc = "Universal Host Controller Interface 0"]
4332pub mod uhci0;
4333#[doc = "Full-speed USB Serial/JTAG Controller"]
4334pub struct USB_DEVICE {
4335 _marker: PhantomData<*const ()>,
4336}
4337unsafe impl Send for USB_DEVICE {}
4338impl USB_DEVICE {
4339 #[doc = r"Pointer to the register block"]
4340 pub const PTR: *const usb_device::RegisterBlock = 0x500d_2000 as *const _;
4341 #[doc = r"Return the pointer to the register block"]
4342 #[inline(always)]
4343 pub const fn ptr() -> *const usb_device::RegisterBlock {
4344 Self::PTR
4345 }
4346 #[doc = r" Steal an instance of this peripheral"]
4347 #[doc = r""]
4348 #[doc = r" # Safety"]
4349 #[doc = r""]
4350 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4351 #[doc = r" that may race with any existing instances, for example by only"]
4352 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4353 #[doc = r" original peripheral and using critical sections to coordinate"]
4354 #[doc = r" access between multiple new instances."]
4355 #[doc = r""]
4356 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4357 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4358 #[doc = r" no stolen instances are passed to such software."]
4359 pub unsafe fn steal() -> Self {
4360 Self {
4361 _marker: PhantomData,
4362 }
4363 }
4364}
4365impl Deref for USB_DEVICE {
4366 type Target = usb_device::RegisterBlock;
4367 #[inline(always)]
4368 fn deref(&self) -> &Self::Target {
4369 unsafe { &*Self::PTR }
4370 }
4371}
4372impl core::fmt::Debug for USB_DEVICE {
4373 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4374 f.debug_struct("USB_DEVICE").finish()
4375 }
4376}
4377#[doc = "Full-speed USB Serial/JTAG Controller"]
4378pub mod usb_device;
4379#[doc = "USB_WRAP Peripheral"]
4380pub struct USB_WRAP {
4381 _marker: PhantomData<*const ()>,
4382}
4383unsafe impl Send for USB_WRAP {}
4384impl USB_WRAP {
4385 #[doc = r"Pointer to the register block"]
4386 pub const PTR: *const usb_wrap::RegisterBlock = 0x5008_0000 as *const _;
4387 #[doc = r"Return the pointer to the register block"]
4388 #[inline(always)]
4389 pub const fn ptr() -> *const usb_wrap::RegisterBlock {
4390 Self::PTR
4391 }
4392 #[doc = r" Steal an instance of this peripheral"]
4393 #[doc = r""]
4394 #[doc = r" # Safety"]
4395 #[doc = r""]
4396 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4397 #[doc = r" that may race with any existing instances, for example by only"]
4398 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4399 #[doc = r" original peripheral and using critical sections to coordinate"]
4400 #[doc = r" access between multiple new instances."]
4401 #[doc = r""]
4402 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4403 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4404 #[doc = r" no stolen instances are passed to such software."]
4405 pub unsafe fn steal() -> Self {
4406 Self {
4407 _marker: PhantomData,
4408 }
4409 }
4410}
4411impl Deref for USB_WRAP {
4412 type Target = usb_wrap::RegisterBlock;
4413 #[inline(always)]
4414 fn deref(&self) -> &Self::Target {
4415 unsafe { &*Self::PTR }
4416 }
4417}
4418impl core::fmt::Debug for USB_WRAP {
4419 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4420 f.debug_struct("USB_WRAP").finish()
4421 }
4422}
4423#[doc = "USB_WRAP Peripheral"]
4424pub mod usb_wrap;
4425#[no_mangle]
4426static mut DEVICE_PERIPHERALS: bool = false;
4427#[doc = r" All the peripherals."]
4428#[allow(non_snake_case)]
4429pub struct Peripherals {
4430 #[doc = "ADC"]
4431 pub ADC: ADC,
4432 #[doc = "AES"]
4433 pub AES: AES,
4434 #[doc = "AHB_DMA"]
4435 pub AHB_DMA: AHB_DMA,
4436 #[doc = "LP_I2C_ANA_MST"]
4437 pub LP_I2C_ANA_MST: LP_I2C_ANA_MST,
4438 #[doc = "ASSIST_DEBUG"]
4439 pub ASSIST_DEBUG: ASSIST_DEBUG,
4440 #[doc = "AXI_DMA"]
4441 pub AXI_DMA: AXI_DMA,
4442 #[doc = "BITSCRAMBLER"]
4443 pub BITSCRAMBLER: BITSCRAMBLER,
4444 #[doc = "CACHE"]
4445 pub CACHE: CACHE,
4446 #[doc = "INTERRUPT_CORE0"]
4447 pub INTERRUPT_CORE0: INTERRUPT_CORE0,
4448 #[doc = "INTERRUPT_CORE1"]
4449 pub INTERRUPT_CORE1: INTERRUPT_CORE1,
4450 #[doc = "MIPI_CSI_BRIDGE"]
4451 pub MIPI_CSI_BRIDGE: MIPI_CSI_BRIDGE,
4452 #[doc = "MIPI_CSI_HOST"]
4453 pub MIPI_CSI_HOST: MIPI_CSI_HOST,
4454 #[doc = "DMA"]
4455 pub DMA: DMA,
4456 #[doc = "DS"]
4457 pub DS: DS,
4458 #[doc = "MIPI_DSI_BRIDGE"]
4459 pub MIPI_DSI_BRIDGE: MIPI_DSI_BRIDGE,
4460 #[doc = "MIPI_DSI_HOST"]
4461 pub MIPI_DSI_HOST: MIPI_DSI_HOST,
4462 #[doc = "ECC"]
4463 pub ECC: ECC,
4464 #[doc = "ECDSA"]
4465 pub ECDSA: ECDSA,
4466 #[doc = "EFUSE"]
4467 pub EFUSE: EFUSE,
4468 #[doc = "GPIO"]
4469 pub GPIO: GPIO,
4470 #[doc = "GPIO_SD"]
4471 pub GPIO_SD: GPIO_SD,
4472 #[doc = "H264"]
4473 pub H264: H264,
4474 #[doc = "H264_DMA"]
4475 pub H264_DMA: H264_DMA,
4476 #[doc = "HMAC"]
4477 pub HMAC: HMAC,
4478 #[doc = "HP_SYS"]
4479 pub HP_SYS: HP_SYS,
4480 #[doc = "HP_SYS_CLKRST"]
4481 pub HP_SYS_CLKRST: HP_SYS_CLKRST,
4482 #[doc = "LP_HUK"]
4483 pub LP_HUK: LP_HUK,
4484 #[doc = "I2C0"]
4485 pub I2C0: I2C0,
4486 #[doc = "I2C1"]
4487 pub I2C1: I2C1,
4488 #[doc = "I2S0"]
4489 pub I2S0: I2S0,
4490 #[doc = "I2S1"]
4491 pub I2S1: I2S1,
4492 #[doc = "I2S2"]
4493 pub I2S2: I2S2,
4494 #[doc = "I3C_MST"]
4495 pub I3C_MST: I3C_MST,
4496 #[doc = "I3C_MST_MEM"]
4497 pub I3C_MST_MEM: I3C_MST_MEM,
4498 #[doc = "I3C_SLV"]
4499 pub I3C_SLV: I3C_SLV,
4500 #[doc = "AXI_ICM"]
4501 pub AXI_ICM: AXI_ICM,
4502 #[doc = "IO_MUX"]
4503 pub IO_MUX: IO_MUX,
4504 #[doc = "ISP"]
4505 pub ISP: ISP,
4506 #[doc = "JPEG"]
4507 pub JPEG: JPEG,
4508 #[doc = "LCD_CAM"]
4509 pub LCD_CAM: LCD_CAM,
4510 #[doc = "LEDC"]
4511 pub LEDC: LEDC,
4512 #[doc = "LP_INTR"]
4513 pub LP_INTR: LP_INTR,
4514 #[doc = "LP_PERI"]
4515 pub LP_PERI: LP_PERI,
4516 #[doc = "LP_SYS"]
4517 pub LP_SYS: LP_SYS,
4518 #[doc = "LP_ANA"]
4519 pub LP_ANA: LP_ANA,
4520 #[doc = "LP_AON_CLKRST"]
4521 pub LP_AON_CLKRST: LP_AON_CLKRST,
4522 #[doc = "LP_GPIO"]
4523 pub LP_GPIO: LP_GPIO,
4524 #[doc = "LP_I2C0"]
4525 pub LP_I2C0: LP_I2C0,
4526 #[doc = "LP_I2S0"]
4527 pub LP_I2S0: LP_I2S0,
4528 #[doc = "LP_IO_MUX"]
4529 pub LP_IO_MUX: LP_IO_MUX,
4530 #[doc = "LP_UART"]
4531 pub LP_UART: LP_UART,
4532 #[doc = "MCPWM0"]
4533 pub MCPWM0: MCPWM0,
4534 #[doc = "MCPWM1"]
4535 pub MCPWM1: MCPWM1,
4536 #[doc = "PARL_IO"]
4537 pub PARL_IO: PARL_IO,
4538 #[doc = "PAU"]
4539 pub PAU: PAU,
4540 #[doc = "PCNT"]
4541 pub PCNT: PCNT,
4542 #[doc = "PMU"]
4543 pub PMU: PMU,
4544 #[doc = "PPA"]
4545 pub PPA: PPA,
4546 #[doc = "PVT"]
4547 pub PVT: PVT,
4548 #[doc = "RMT"]
4549 pub RMT: RMT,
4550 #[doc = "RSA"]
4551 pub RSA: RSA,
4552 #[doc = "LP_ADC"]
4553 pub LP_ADC: LP_ADC,
4554 #[doc = "LP_TIMER"]
4555 pub LP_TIMER: LP_TIMER,
4556 #[doc = "LP_TOUCH"]
4557 pub LP_TOUCH: LP_TOUCH,
4558 #[doc = "LP_WDT"]
4559 pub LP_WDT: LP_WDT,
4560 #[doc = "SDHOST"]
4561 pub SDHOST: SDHOST,
4562 #[doc = "SHA"]
4563 pub SHA: SHA,
4564 #[doc = "SOC_ETM"]
4565 pub SOC_ETM: SOC_ETM,
4566 #[doc = "SPI0"]
4567 pub SPI0: SPI0,
4568 #[doc = "SPI1"]
4569 pub SPI1: SPI1,
4570 #[doc = "SPI2"]
4571 pub SPI2: SPI2,
4572 #[doc = "SPI3"]
4573 pub SPI3: SPI3,
4574 #[doc = "SYSTIMER"]
4575 pub SYSTIMER: SYSTIMER,
4576 #[doc = "TIMG0"]
4577 pub TIMG0: TIMG0,
4578 #[doc = "TIMG1"]
4579 pub TIMG1: TIMG1,
4580 #[doc = "TRACE0"]
4581 pub TRACE0: TRACE0,
4582 #[doc = "TRACE1"]
4583 pub TRACE1: TRACE1,
4584 #[doc = "LP_TSENS"]
4585 pub LP_TSENS: LP_TSENS,
4586 #[doc = "TWAI0"]
4587 pub TWAI0: TWAI0,
4588 #[doc = "TWAI1"]
4589 pub TWAI1: TWAI1,
4590 #[doc = "TWAI2"]
4591 pub TWAI2: TWAI2,
4592 #[doc = "UART0"]
4593 pub UART0: UART0,
4594 #[doc = "UART1"]
4595 pub UART1: UART1,
4596 #[doc = "UART2"]
4597 pub UART2: UART2,
4598 #[doc = "UART3"]
4599 pub UART3: UART3,
4600 #[doc = "UART4"]
4601 pub UART4: UART4,
4602 #[doc = "UHCI0"]
4603 pub UHCI0: UHCI0,
4604 #[doc = "USB_DEVICE"]
4605 pub USB_DEVICE: USB_DEVICE,
4606 #[doc = "USB_WRAP"]
4607 pub USB_WRAP: USB_WRAP,
4608}
4609impl Peripherals {
4610 #[doc = r" Returns all the peripherals *once*."]
4611 #[cfg(feature = "critical-section")]
4612 #[inline]
4613 pub fn take() -> Option<Self> {
4614 critical_section::with(|_| {
4615 if unsafe { DEVICE_PERIPHERALS } {
4616 return None;
4617 }
4618 Some(unsafe { Peripherals::steal() })
4619 })
4620 }
4621 #[doc = r" Unchecked version of `Peripherals::take`."]
4622 #[doc = r""]
4623 #[doc = r" # Safety"]
4624 #[doc = r""]
4625 #[doc = r" Each of the returned peripherals must be used at most once."]
4626 #[inline]
4627 pub unsafe fn steal() -> Self {
4628 DEVICE_PERIPHERALS = true;
4629 Peripherals {
4630 ADC: ADC {
4631 _marker: PhantomData,
4632 },
4633 AES: AES {
4634 _marker: PhantomData,
4635 },
4636 AHB_DMA: AHB_DMA {
4637 _marker: PhantomData,
4638 },
4639 LP_I2C_ANA_MST: LP_I2C_ANA_MST {
4640 _marker: PhantomData,
4641 },
4642 ASSIST_DEBUG: ASSIST_DEBUG {
4643 _marker: PhantomData,
4644 },
4645 AXI_DMA: AXI_DMA {
4646 _marker: PhantomData,
4647 },
4648 BITSCRAMBLER: BITSCRAMBLER {
4649 _marker: PhantomData,
4650 },
4651 CACHE: CACHE {
4652 _marker: PhantomData,
4653 },
4654 INTERRUPT_CORE0: INTERRUPT_CORE0 {
4655 _marker: PhantomData,
4656 },
4657 INTERRUPT_CORE1: INTERRUPT_CORE1 {
4658 _marker: PhantomData,
4659 },
4660 MIPI_CSI_BRIDGE: MIPI_CSI_BRIDGE {
4661 _marker: PhantomData,
4662 },
4663 MIPI_CSI_HOST: MIPI_CSI_HOST {
4664 _marker: PhantomData,
4665 },
4666 DMA: DMA {
4667 _marker: PhantomData,
4668 },
4669 DS: DS {
4670 _marker: PhantomData,
4671 },
4672 MIPI_DSI_BRIDGE: MIPI_DSI_BRIDGE {
4673 _marker: PhantomData,
4674 },
4675 MIPI_DSI_HOST: MIPI_DSI_HOST {
4676 _marker: PhantomData,
4677 },
4678 ECC: ECC {
4679 _marker: PhantomData,
4680 },
4681 ECDSA: ECDSA {
4682 _marker: PhantomData,
4683 },
4684 EFUSE: EFUSE {
4685 _marker: PhantomData,
4686 },
4687 GPIO: GPIO {
4688 _marker: PhantomData,
4689 },
4690 GPIO_SD: GPIO_SD {
4691 _marker: PhantomData,
4692 },
4693 H264: H264 {
4694 _marker: PhantomData,
4695 },
4696 H264_DMA: H264_DMA {
4697 _marker: PhantomData,
4698 },
4699 HMAC: HMAC {
4700 _marker: PhantomData,
4701 },
4702 HP_SYS: HP_SYS {
4703 _marker: PhantomData,
4704 },
4705 HP_SYS_CLKRST: HP_SYS_CLKRST {
4706 _marker: PhantomData,
4707 },
4708 LP_HUK: LP_HUK {
4709 _marker: PhantomData,
4710 },
4711 I2C0: I2C0 {
4712 _marker: PhantomData,
4713 },
4714 I2C1: I2C1 {
4715 _marker: PhantomData,
4716 },
4717 I2S0: I2S0 {
4718 _marker: PhantomData,
4719 },
4720 I2S1: I2S1 {
4721 _marker: PhantomData,
4722 },
4723 I2S2: I2S2 {
4724 _marker: PhantomData,
4725 },
4726 I3C_MST: I3C_MST {
4727 _marker: PhantomData,
4728 },
4729 I3C_MST_MEM: I3C_MST_MEM {
4730 _marker: PhantomData,
4731 },
4732 I3C_SLV: I3C_SLV {
4733 _marker: PhantomData,
4734 },
4735 AXI_ICM: AXI_ICM {
4736 _marker: PhantomData,
4737 },
4738 IO_MUX: IO_MUX {
4739 _marker: PhantomData,
4740 },
4741 ISP: ISP {
4742 _marker: PhantomData,
4743 },
4744 JPEG: JPEG {
4745 _marker: PhantomData,
4746 },
4747 LCD_CAM: LCD_CAM {
4748 _marker: PhantomData,
4749 },
4750 LEDC: LEDC {
4751 _marker: PhantomData,
4752 },
4753 LP_INTR: LP_INTR {
4754 _marker: PhantomData,
4755 },
4756 LP_PERI: LP_PERI {
4757 _marker: PhantomData,
4758 },
4759 LP_SYS: LP_SYS {
4760 _marker: PhantomData,
4761 },
4762 LP_ANA: LP_ANA {
4763 _marker: PhantomData,
4764 },
4765 LP_AON_CLKRST: LP_AON_CLKRST {
4766 _marker: PhantomData,
4767 },
4768 LP_GPIO: LP_GPIO {
4769 _marker: PhantomData,
4770 },
4771 LP_I2C0: LP_I2C0 {
4772 _marker: PhantomData,
4773 },
4774 LP_I2S0: LP_I2S0 {
4775 _marker: PhantomData,
4776 },
4777 LP_IO_MUX: LP_IO_MUX {
4778 _marker: PhantomData,
4779 },
4780 LP_UART: LP_UART {
4781 _marker: PhantomData,
4782 },
4783 MCPWM0: MCPWM0 {
4784 _marker: PhantomData,
4785 },
4786 MCPWM1: MCPWM1 {
4787 _marker: PhantomData,
4788 },
4789 PARL_IO: PARL_IO {
4790 _marker: PhantomData,
4791 },
4792 PAU: PAU {
4793 _marker: PhantomData,
4794 },
4795 PCNT: PCNT {
4796 _marker: PhantomData,
4797 },
4798 PMU: PMU {
4799 _marker: PhantomData,
4800 },
4801 PPA: PPA {
4802 _marker: PhantomData,
4803 },
4804 PVT: PVT {
4805 _marker: PhantomData,
4806 },
4807 RMT: RMT {
4808 _marker: PhantomData,
4809 },
4810 RSA: RSA {
4811 _marker: PhantomData,
4812 },
4813 LP_ADC: LP_ADC {
4814 _marker: PhantomData,
4815 },
4816 LP_TIMER: LP_TIMER {
4817 _marker: PhantomData,
4818 },
4819 LP_TOUCH: LP_TOUCH {
4820 _marker: PhantomData,
4821 },
4822 LP_WDT: LP_WDT {
4823 _marker: PhantomData,
4824 },
4825 SDHOST: SDHOST {
4826 _marker: PhantomData,
4827 },
4828 SHA: SHA {
4829 _marker: PhantomData,
4830 },
4831 SOC_ETM: SOC_ETM {
4832 _marker: PhantomData,
4833 },
4834 SPI0: SPI0 {
4835 _marker: PhantomData,
4836 },
4837 SPI1: SPI1 {
4838 _marker: PhantomData,
4839 },
4840 SPI2: SPI2 {
4841 _marker: PhantomData,
4842 },
4843 SPI3: SPI3 {
4844 _marker: PhantomData,
4845 },
4846 SYSTIMER: SYSTIMER {
4847 _marker: PhantomData,
4848 },
4849 TIMG0: TIMG0 {
4850 _marker: PhantomData,
4851 },
4852 TIMG1: TIMG1 {
4853 _marker: PhantomData,
4854 },
4855 TRACE0: TRACE0 {
4856 _marker: PhantomData,
4857 },
4858 TRACE1: TRACE1 {
4859 _marker: PhantomData,
4860 },
4861 LP_TSENS: LP_TSENS {
4862 _marker: PhantomData,
4863 },
4864 TWAI0: TWAI0 {
4865 _marker: PhantomData,
4866 },
4867 TWAI1: TWAI1 {
4868 _marker: PhantomData,
4869 },
4870 TWAI2: TWAI2 {
4871 _marker: PhantomData,
4872 },
4873 UART0: UART0 {
4874 _marker: PhantomData,
4875 },
4876 UART1: UART1 {
4877 _marker: PhantomData,
4878 },
4879 UART2: UART2 {
4880 _marker: PhantomData,
4881 },
4882 UART3: UART3 {
4883 _marker: PhantomData,
4884 },
4885 UART4: UART4 {
4886 _marker: PhantomData,
4887 },
4888 UHCI0: UHCI0 {
4889 _marker: PhantomData,
4890 },
4891 USB_DEVICE: USB_DEVICE {
4892 _marker: PhantomData,
4893 },
4894 USB_WRAP: USB_WRAP {
4895 _marker: PhantomData,
4896 },
4897 }
4898 }
4899}