1#![doc = "Peripheral access API for ESP32-C6 microcontrollers (generated using svd2rust v0.35.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.35.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 WIFI_MAC();
17 fn WIFI_MAC_NMI();
18 fn WIFI_PWR();
19 fn WIFI_BB();
20 fn BT_MAC();
21 fn BT_BB();
22 fn BT_BB_NMI();
23 fn LP_TIMER();
24 fn COEX();
25 fn BLE_TIMER();
26 fn BLE_SEC();
27 fn I2C_MASTER();
28 fn ZB_MAC();
29 fn PMU();
30 fn EFUSE();
31 fn LP_RTC_TIMER();
32 fn LP_UART();
33 fn LP_I2C();
34 fn LP_WDT();
35 fn LP_PERI_TIMEOUT();
36 fn LP_APM_M0();
37 fn LP_APM_M1();
38 fn FROM_CPU_INTR0();
39 fn FROM_CPU_INTR1();
40 fn FROM_CPU_INTR2();
41 fn FROM_CPU_INTR3();
42 fn ASSIST_DEBUG();
43 fn TRACE();
44 fn CACHE();
45 fn CPU_PERI_TIMEOUT();
46 fn GPIO();
47 fn GPIO_NMI();
48 fn PAU();
49 fn HP_PERI_TIMEOUT();
50 fn MODEM_PERI_TIMEOUT();
51 fn HP_APM_M0();
52 fn HP_APM_M1();
53 fn HP_APM_M2();
54 fn HP_APM_M3();
55 fn LP_APM0();
56 fn MSPI();
57 fn I2S0();
58 fn UHCI0();
59 fn UART0();
60 fn UART1();
61 fn LEDC();
62 fn TWAI0();
63 fn TWAI1();
64 fn USB_DEVICE();
65 fn RMT();
66 fn I2C_EXT0();
67 fn TG0_T0_LEVEL();
68 fn TG0_T1_LEVEL();
69 fn TG0_WDT_LEVEL();
70 fn TG1_T0_LEVEL();
71 fn TG1_T1_LEVEL();
72 fn TG1_WDT_LEVEL();
73 fn SYSTIMER_TARGET0();
74 fn SYSTIMER_TARGET1();
75 fn SYSTIMER_TARGET2();
76 fn APB_SARADC();
77 fn MCPWM0();
78 fn PCNT();
79 fn PARL_IO();
80 fn SLC0();
81 fn SLC1();
82 fn DMA_IN_CH0();
83 fn DMA_IN_CH1();
84 fn DMA_IN_CH2();
85 fn DMA_OUT_CH0();
86 fn DMA_OUT_CH1();
87 fn DMA_OUT_CH2();
88 fn SPI2();
89 fn AES();
90 fn SHA();
91 fn RSA();
92 fn ECC();
93}
94#[doc(hidden)]
95#[repr(C)]
96pub union Vector {
97 pub _handler: unsafe extern "C" fn(),
98 pub _reserved: usize,
99}
100#[cfg(feature = "rt")]
101#[doc(hidden)]
102#[link_section = ".rwtext"]
103#[no_mangle]
104pub static __EXTERNAL_INTERRUPTS: [Vector; 77] = [
105 Vector { _handler: WIFI_MAC },
106 Vector {
107 _handler: WIFI_MAC_NMI,
108 },
109 Vector { _handler: WIFI_PWR },
110 Vector { _handler: WIFI_BB },
111 Vector { _handler: BT_MAC },
112 Vector { _handler: BT_BB },
113 Vector {
114 _handler: BT_BB_NMI,
115 },
116 Vector { _handler: LP_TIMER },
117 Vector { _handler: COEX },
118 Vector {
119 _handler: BLE_TIMER,
120 },
121 Vector { _handler: BLE_SEC },
122 Vector {
123 _handler: I2C_MASTER,
124 },
125 Vector { _handler: ZB_MAC },
126 Vector { _handler: PMU },
127 Vector { _handler: EFUSE },
128 Vector {
129 _handler: LP_RTC_TIMER,
130 },
131 Vector { _handler: LP_UART },
132 Vector { _handler: LP_I2C },
133 Vector { _handler: LP_WDT },
134 Vector {
135 _handler: LP_PERI_TIMEOUT,
136 },
137 Vector {
138 _handler: LP_APM_M0,
139 },
140 Vector {
141 _handler: LP_APM_M1,
142 },
143 Vector {
144 _handler: FROM_CPU_INTR0,
145 },
146 Vector {
147 _handler: FROM_CPU_INTR1,
148 },
149 Vector {
150 _handler: FROM_CPU_INTR2,
151 },
152 Vector {
153 _handler: FROM_CPU_INTR3,
154 },
155 Vector {
156 _handler: ASSIST_DEBUG,
157 },
158 Vector { _handler: TRACE },
159 Vector { _handler: CACHE },
160 Vector {
161 _handler: CPU_PERI_TIMEOUT,
162 },
163 Vector { _handler: GPIO },
164 Vector { _handler: GPIO_NMI },
165 Vector { _handler: PAU },
166 Vector {
167 _handler: HP_PERI_TIMEOUT,
168 },
169 Vector {
170 _handler: MODEM_PERI_TIMEOUT,
171 },
172 Vector {
173 _handler: HP_APM_M0,
174 },
175 Vector {
176 _handler: HP_APM_M1,
177 },
178 Vector {
179 _handler: HP_APM_M2,
180 },
181 Vector {
182 _handler: HP_APM_M3,
183 },
184 Vector { _handler: LP_APM0 },
185 Vector { _handler: MSPI },
186 Vector { _handler: I2S0 },
187 Vector { _handler: UHCI0 },
188 Vector { _handler: UART0 },
189 Vector { _handler: UART1 },
190 Vector { _handler: LEDC },
191 Vector { _handler: TWAI0 },
192 Vector { _handler: TWAI1 },
193 Vector {
194 _handler: USB_DEVICE,
195 },
196 Vector { _handler: RMT },
197 Vector { _handler: I2C_EXT0 },
198 Vector {
199 _handler: TG0_T0_LEVEL,
200 },
201 Vector {
202 _handler: TG0_T1_LEVEL,
203 },
204 Vector {
205 _handler: TG0_WDT_LEVEL,
206 },
207 Vector {
208 _handler: TG1_T0_LEVEL,
209 },
210 Vector {
211 _handler: TG1_T1_LEVEL,
212 },
213 Vector {
214 _handler: TG1_WDT_LEVEL,
215 },
216 Vector {
217 _handler: SYSTIMER_TARGET0,
218 },
219 Vector {
220 _handler: SYSTIMER_TARGET1,
221 },
222 Vector {
223 _handler: SYSTIMER_TARGET2,
224 },
225 Vector {
226 _handler: APB_SARADC,
227 },
228 Vector { _handler: MCPWM0 },
229 Vector { _handler: PCNT },
230 Vector { _handler: PARL_IO },
231 Vector { _handler: SLC0 },
232 Vector { _handler: SLC1 },
233 Vector {
234 _handler: DMA_IN_CH0,
235 },
236 Vector {
237 _handler: DMA_IN_CH1,
238 },
239 Vector {
240 _handler: DMA_IN_CH2,
241 },
242 Vector {
243 _handler: DMA_OUT_CH0,
244 },
245 Vector {
246 _handler: DMA_OUT_CH1,
247 },
248 Vector {
249 _handler: DMA_OUT_CH2,
250 },
251 Vector { _handler: SPI2 },
252 Vector { _handler: AES },
253 Vector { _handler: SHA },
254 Vector { _handler: RSA },
255 Vector { _handler: ECC },
256];
257#[doc(hidden)]
258pub mod interrupt;
259pub use self::interrupt::Interrupt;
260#[doc = "AES (Advanced Encryption Standard) Accelerator"]
261pub struct AES {
262 _marker: PhantomData<*const ()>,
263}
264unsafe impl Send for AES {}
265impl AES {
266 #[doc = r"Pointer to the register block"]
267 pub const PTR: *const aes::RegisterBlock = 0x6008_8000 as *const _;
268 #[doc = r"Return the pointer to the register block"]
269 #[inline(always)]
270 pub const fn ptr() -> *const aes::RegisterBlock {
271 Self::PTR
272 }
273 #[doc = r" Steal an instance of this peripheral"]
274 #[doc = r""]
275 #[doc = r" # Safety"]
276 #[doc = r""]
277 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
278 #[doc = r" that may race with any existing instances, for example by only"]
279 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
280 #[doc = r" original peripheral and using critical sections to coordinate"]
281 #[doc = r" access between multiple new instances."]
282 #[doc = r""]
283 #[doc = r" Additionally, other software such as HALs may rely on only one"]
284 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
285 #[doc = r" no stolen instances are passed to such software."]
286 pub unsafe fn steal() -> Self {
287 Self {
288 _marker: PhantomData,
289 }
290 }
291}
292impl Deref for AES {
293 type Target = aes::RegisterBlock;
294 #[inline(always)]
295 fn deref(&self) -> &Self::Target {
296 unsafe { &*Self::PTR }
297 }
298}
299impl core::fmt::Debug for AES {
300 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
301 f.debug_struct("AES").finish()
302 }
303}
304#[doc = "AES (Advanced Encryption Standard) Accelerator"]
305pub mod aes;
306#[doc = "SAR (Successive Approximation Register) Analog-to-Digital Converter"]
307pub struct APB_SARADC {
308 _marker: PhantomData<*const ()>,
309}
310unsafe impl Send for APB_SARADC {}
311impl APB_SARADC {
312 #[doc = r"Pointer to the register block"]
313 pub const PTR: *const apb_saradc::RegisterBlock = 0x6000_e000 as *const _;
314 #[doc = r"Return the pointer to the register block"]
315 #[inline(always)]
316 pub const fn ptr() -> *const apb_saradc::RegisterBlock {
317 Self::PTR
318 }
319 #[doc = r" Steal an instance of this peripheral"]
320 #[doc = r""]
321 #[doc = r" # Safety"]
322 #[doc = r""]
323 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
324 #[doc = r" that may race with any existing instances, for example by only"]
325 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
326 #[doc = r" original peripheral and using critical sections to coordinate"]
327 #[doc = r" access between multiple new instances."]
328 #[doc = r""]
329 #[doc = r" Additionally, other software such as HALs may rely on only one"]
330 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
331 #[doc = r" no stolen instances are passed to such software."]
332 pub unsafe fn steal() -> Self {
333 Self {
334 _marker: PhantomData,
335 }
336 }
337}
338impl Deref for APB_SARADC {
339 type Target = apb_saradc::RegisterBlock;
340 #[inline(always)]
341 fn deref(&self) -> &Self::Target {
342 unsafe { &*Self::PTR }
343 }
344}
345impl core::fmt::Debug for APB_SARADC {
346 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
347 f.debug_struct("APB_SARADC").finish()
348 }
349}
350#[doc = "SAR (Successive Approximation Register) Analog-to-Digital Converter"]
351pub mod apb_saradc;
352#[doc = "Debug Assist"]
353pub struct ASSIST_DEBUG {
354 _marker: PhantomData<*const ()>,
355}
356unsafe impl Send for ASSIST_DEBUG {}
357impl ASSIST_DEBUG {
358 #[doc = r"Pointer to the register block"]
359 pub const PTR: *const assist_debug::RegisterBlock = 0x600c_2000 as *const _;
360 #[doc = r"Return the pointer to the register block"]
361 #[inline(always)]
362 pub const fn ptr() -> *const assist_debug::RegisterBlock {
363 Self::PTR
364 }
365 #[doc = r" Steal an instance of this peripheral"]
366 #[doc = r""]
367 #[doc = r" # Safety"]
368 #[doc = r""]
369 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
370 #[doc = r" that may race with any existing instances, for example by only"]
371 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
372 #[doc = r" original peripheral and using critical sections to coordinate"]
373 #[doc = r" access between multiple new instances."]
374 #[doc = r""]
375 #[doc = r" Additionally, other software such as HALs may rely on only one"]
376 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
377 #[doc = r" no stolen instances are passed to such software."]
378 pub unsafe fn steal() -> Self {
379 Self {
380 _marker: PhantomData,
381 }
382 }
383}
384impl Deref for ASSIST_DEBUG {
385 type Target = assist_debug::RegisterBlock;
386 #[inline(always)]
387 fn deref(&self) -> &Self::Target {
388 unsafe { &*Self::PTR }
389 }
390}
391impl core::fmt::Debug for ASSIST_DEBUG {
392 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
393 f.debug_struct("ASSIST_DEBUG").finish()
394 }
395}
396#[doc = "Debug Assist"]
397pub mod assist_debug;
398#[doc = "Atomic Locker"]
399pub struct ATOMIC {
400 _marker: PhantomData<*const ()>,
401}
402unsafe impl Send for ATOMIC {}
403impl ATOMIC {
404 #[doc = r"Pointer to the register block"]
405 pub const PTR: *const atomic::RegisterBlock = 0x6001_1000 as *const _;
406 #[doc = r"Return the pointer to the register block"]
407 #[inline(always)]
408 pub const fn ptr() -> *const atomic::RegisterBlock {
409 Self::PTR
410 }
411 #[doc = r" Steal an instance of this peripheral"]
412 #[doc = r""]
413 #[doc = r" # Safety"]
414 #[doc = r""]
415 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
416 #[doc = r" that may race with any existing instances, for example by only"]
417 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
418 #[doc = r" original peripheral and using critical sections to coordinate"]
419 #[doc = r" access between multiple new instances."]
420 #[doc = r""]
421 #[doc = r" Additionally, other software such as HALs may rely on only one"]
422 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
423 #[doc = r" no stolen instances are passed to such software."]
424 pub unsafe fn steal() -> Self {
425 Self {
426 _marker: PhantomData,
427 }
428 }
429}
430impl Deref for ATOMIC {
431 type Target = atomic::RegisterBlock;
432 #[inline(always)]
433 fn deref(&self) -> &Self::Target {
434 unsafe { &*Self::PTR }
435 }
436}
437impl core::fmt::Debug for ATOMIC {
438 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
439 f.debug_struct("ATOMIC").finish()
440 }
441}
442#[doc = "Atomic Locker"]
443pub mod atomic;
444#[doc = "DMA (Direct Memory Access) Controller"]
445pub struct DMA {
446 _marker: PhantomData<*const ()>,
447}
448unsafe impl Send for DMA {}
449impl DMA {
450 #[doc = r"Pointer to the register block"]
451 pub const PTR: *const dma::RegisterBlock = 0x6008_0000 as *const _;
452 #[doc = r"Return the pointer to the register block"]
453 #[inline(always)]
454 pub const fn ptr() -> *const dma::RegisterBlock {
455 Self::PTR
456 }
457 #[doc = r" Steal an instance of this peripheral"]
458 #[doc = r""]
459 #[doc = r" # Safety"]
460 #[doc = r""]
461 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
462 #[doc = r" that may race with any existing instances, for example by only"]
463 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
464 #[doc = r" original peripheral and using critical sections to coordinate"]
465 #[doc = r" access between multiple new instances."]
466 #[doc = r""]
467 #[doc = r" Additionally, other software such as HALs may rely on only one"]
468 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
469 #[doc = r" no stolen instances are passed to such software."]
470 pub unsafe fn steal() -> Self {
471 Self {
472 _marker: PhantomData,
473 }
474 }
475}
476impl Deref for DMA {
477 type Target = dma::RegisterBlock;
478 #[inline(always)]
479 fn deref(&self) -> &Self::Target {
480 unsafe { &*Self::PTR }
481 }
482}
483impl core::fmt::Debug for DMA {
484 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
485 f.debug_struct("DMA").finish()
486 }
487}
488#[doc = "DMA (Direct Memory Access) Controller"]
489pub mod dma;
490#[doc = "Digital Signature"]
491pub struct DS {
492 _marker: PhantomData<*const ()>,
493}
494unsafe impl Send for DS {}
495impl DS {
496 #[doc = r"Pointer to the register block"]
497 pub const PTR: *const ds::RegisterBlock = 0x6008_c000 as *const _;
498 #[doc = r"Return the pointer to the register block"]
499 #[inline(always)]
500 pub const fn ptr() -> *const ds::RegisterBlock {
501 Self::PTR
502 }
503 #[doc = r" Steal an instance of this peripheral"]
504 #[doc = r""]
505 #[doc = r" # Safety"]
506 #[doc = r""]
507 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
508 #[doc = r" that may race with any existing instances, for example by only"]
509 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
510 #[doc = r" original peripheral and using critical sections to coordinate"]
511 #[doc = r" access between multiple new instances."]
512 #[doc = r""]
513 #[doc = r" Additionally, other software such as HALs may rely on only one"]
514 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
515 #[doc = r" no stolen instances are passed to such software."]
516 pub unsafe fn steal() -> Self {
517 Self {
518 _marker: PhantomData,
519 }
520 }
521}
522impl Deref for DS {
523 type Target = ds::RegisterBlock;
524 #[inline(always)]
525 fn deref(&self) -> &Self::Target {
526 unsafe { &*Self::PTR }
527 }
528}
529impl core::fmt::Debug for DS {
530 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
531 f.debug_struct("DS").finish()
532 }
533}
534#[doc = "Digital Signature"]
535pub mod ds;
536#[doc = "ECC (ECC Hardware Accelerator)"]
537pub struct ECC {
538 _marker: PhantomData<*const ()>,
539}
540unsafe impl Send for ECC {}
541impl ECC {
542 #[doc = r"Pointer to the register block"]
543 pub const PTR: *const ecc::RegisterBlock = 0x6008_b000 as *const _;
544 #[doc = r"Return the pointer to the register block"]
545 #[inline(always)]
546 pub const fn ptr() -> *const ecc::RegisterBlock {
547 Self::PTR
548 }
549 #[doc = r" Steal an instance of this peripheral"]
550 #[doc = r""]
551 #[doc = r" # Safety"]
552 #[doc = r""]
553 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
554 #[doc = r" that may race with any existing instances, for example by only"]
555 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
556 #[doc = r" original peripheral and using critical sections to coordinate"]
557 #[doc = r" access between multiple new instances."]
558 #[doc = r""]
559 #[doc = r" Additionally, other software such as HALs may rely on only one"]
560 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
561 #[doc = r" no stolen instances are passed to such software."]
562 pub unsafe fn steal() -> Self {
563 Self {
564 _marker: PhantomData,
565 }
566 }
567}
568impl Deref for ECC {
569 type Target = ecc::RegisterBlock;
570 #[inline(always)]
571 fn deref(&self) -> &Self::Target {
572 unsafe { &*Self::PTR }
573 }
574}
575impl core::fmt::Debug for ECC {
576 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
577 f.debug_struct("ECC").finish()
578 }
579}
580#[doc = "ECC (ECC Hardware Accelerator)"]
581pub mod ecc;
582#[doc = "eFuse Controller"]
583pub struct EFUSE {
584 _marker: PhantomData<*const ()>,
585}
586unsafe impl Send for EFUSE {}
587impl EFUSE {
588 #[doc = r"Pointer to the register block"]
589 pub const PTR: *const efuse::RegisterBlock = 0x600b_0800 as *const _;
590 #[doc = r"Return the pointer to the register block"]
591 #[inline(always)]
592 pub const fn ptr() -> *const efuse::RegisterBlock {
593 Self::PTR
594 }
595 #[doc = r" Steal an instance of this peripheral"]
596 #[doc = r""]
597 #[doc = r" # Safety"]
598 #[doc = r""]
599 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
600 #[doc = r" that may race with any existing instances, for example by only"]
601 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
602 #[doc = r" original peripheral and using critical sections to coordinate"]
603 #[doc = r" access between multiple new instances."]
604 #[doc = r""]
605 #[doc = r" Additionally, other software such as HALs may rely on only one"]
606 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
607 #[doc = r" no stolen instances are passed to such software."]
608 pub unsafe fn steal() -> Self {
609 Self {
610 _marker: PhantomData,
611 }
612 }
613}
614impl Deref for EFUSE {
615 type Target = efuse::RegisterBlock;
616 #[inline(always)]
617 fn deref(&self) -> &Self::Target {
618 unsafe { &*Self::PTR }
619 }
620}
621impl core::fmt::Debug for EFUSE {
622 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
623 f.debug_struct("EFUSE").finish()
624 }
625}
626#[doc = "eFuse Controller"]
627pub mod efuse;
628#[doc = "External Memory"]
629pub struct EXTMEM {
630 _marker: PhantomData<*const ()>,
631}
632unsafe impl Send for EXTMEM {}
633impl EXTMEM {
634 #[doc = r"Pointer to the register block"]
635 pub const PTR: *const extmem::RegisterBlock = 0x600c_8000 as *const _;
636 #[doc = r"Return the pointer to the register block"]
637 #[inline(always)]
638 pub const fn ptr() -> *const extmem::RegisterBlock {
639 Self::PTR
640 }
641 #[doc = r" Steal an instance of this peripheral"]
642 #[doc = r""]
643 #[doc = r" # Safety"]
644 #[doc = r""]
645 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
646 #[doc = r" that may race with any existing instances, for example by only"]
647 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
648 #[doc = r" original peripheral and using critical sections to coordinate"]
649 #[doc = r" access between multiple new instances."]
650 #[doc = r""]
651 #[doc = r" Additionally, other software such as HALs may rely on only one"]
652 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
653 #[doc = r" no stolen instances are passed to such software."]
654 pub unsafe fn steal() -> Self {
655 Self {
656 _marker: PhantomData,
657 }
658 }
659}
660impl Deref for EXTMEM {
661 type Target = extmem::RegisterBlock;
662 #[inline(always)]
663 fn deref(&self) -> &Self::Target {
664 unsafe { &*Self::PTR }
665 }
666}
667impl core::fmt::Debug for EXTMEM {
668 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
669 f.debug_struct("EXTMEM").finish()
670 }
671}
672#[doc = "External Memory"]
673pub mod extmem;
674#[doc = "General Purpose Input/Output"]
675pub struct GPIO {
676 _marker: PhantomData<*const ()>,
677}
678unsafe impl Send for GPIO {}
679impl GPIO {
680 #[doc = r"Pointer to the register block"]
681 pub const PTR: *const gpio::RegisterBlock = 0x6009_1000 as *const _;
682 #[doc = r"Return the pointer to the register block"]
683 #[inline(always)]
684 pub const fn ptr() -> *const gpio::RegisterBlock {
685 Self::PTR
686 }
687 #[doc = r" Steal an instance of this peripheral"]
688 #[doc = r""]
689 #[doc = r" # Safety"]
690 #[doc = r""]
691 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
692 #[doc = r" that may race with any existing instances, for example by only"]
693 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
694 #[doc = r" original peripheral and using critical sections to coordinate"]
695 #[doc = r" access between multiple new instances."]
696 #[doc = r""]
697 #[doc = r" Additionally, other software such as HALs may rely on only one"]
698 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
699 #[doc = r" no stolen instances are passed to such software."]
700 pub unsafe fn steal() -> Self {
701 Self {
702 _marker: PhantomData,
703 }
704 }
705}
706impl Deref for GPIO {
707 type Target = gpio::RegisterBlock;
708 #[inline(always)]
709 fn deref(&self) -> &Self::Target {
710 unsafe { &*Self::PTR }
711 }
712}
713impl core::fmt::Debug for GPIO {
714 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
715 f.debug_struct("GPIO").finish()
716 }
717}
718#[doc = "General Purpose Input/Output"]
719pub mod gpio;
720#[doc = "Sigma-Delta Modulation"]
721pub struct GPIO_SD {
722 _marker: PhantomData<*const ()>,
723}
724unsafe impl Send for GPIO_SD {}
725impl GPIO_SD {
726 #[doc = r"Pointer to the register block"]
727 pub const PTR: *const gpio_sd::RegisterBlock = 0x6009_1f00 as *const _;
728 #[doc = r"Return the pointer to the register block"]
729 #[inline(always)]
730 pub const fn ptr() -> *const gpio_sd::RegisterBlock {
731 Self::PTR
732 }
733 #[doc = r" Steal an instance of this peripheral"]
734 #[doc = r""]
735 #[doc = r" # Safety"]
736 #[doc = r""]
737 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
738 #[doc = r" that may race with any existing instances, for example by only"]
739 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
740 #[doc = r" original peripheral and using critical sections to coordinate"]
741 #[doc = r" access between multiple new instances."]
742 #[doc = r""]
743 #[doc = r" Additionally, other software such as HALs may rely on only one"]
744 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
745 #[doc = r" no stolen instances are passed to such software."]
746 pub unsafe fn steal() -> Self {
747 Self {
748 _marker: PhantomData,
749 }
750 }
751}
752impl Deref for GPIO_SD {
753 type Target = gpio_sd::RegisterBlock;
754 #[inline(always)]
755 fn deref(&self) -> &Self::Target {
756 unsafe { &*Self::PTR }
757 }
758}
759impl core::fmt::Debug for GPIO_SD {
760 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
761 f.debug_struct("GPIO_SD").finish()
762 }
763}
764#[doc = "Sigma-Delta Modulation"]
765pub mod gpio_sd;
766#[doc = "HINF Peripheral"]
767pub struct HINF {
768 _marker: PhantomData<*const ()>,
769}
770unsafe impl Send for HINF {}
771impl HINF {
772 #[doc = r"Pointer to the register block"]
773 pub const PTR: *const hinf::RegisterBlock = 0x6001_6000 as *const _;
774 #[doc = r"Return the pointer to the register block"]
775 #[inline(always)]
776 pub const fn ptr() -> *const hinf::RegisterBlock {
777 Self::PTR
778 }
779 #[doc = r" Steal an instance of this peripheral"]
780 #[doc = r""]
781 #[doc = r" # Safety"]
782 #[doc = r""]
783 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
784 #[doc = r" that may race with any existing instances, for example by only"]
785 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
786 #[doc = r" original peripheral and using critical sections to coordinate"]
787 #[doc = r" access between multiple new instances."]
788 #[doc = r""]
789 #[doc = r" Additionally, other software such as HALs may rely on only one"]
790 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
791 #[doc = r" no stolen instances are passed to such software."]
792 pub unsafe fn steal() -> Self {
793 Self {
794 _marker: PhantomData,
795 }
796 }
797}
798impl Deref for HINF {
799 type Target = hinf::RegisterBlock;
800 #[inline(always)]
801 fn deref(&self) -> &Self::Target {
802 unsafe { &*Self::PTR }
803 }
804}
805impl core::fmt::Debug for HINF {
806 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
807 f.debug_struct("HINF").finish()
808 }
809}
810#[doc = "HINF Peripheral"]
811pub mod hinf;
812#[doc = "HMAC (Hash-based Message Authentication Code) Accelerator"]
813pub struct HMAC {
814 _marker: PhantomData<*const ()>,
815}
816unsafe impl Send for HMAC {}
817impl HMAC {
818 #[doc = r"Pointer to the register block"]
819 pub const PTR: *const hmac::RegisterBlock = 0x6008_d000 as *const _;
820 #[doc = r"Return the pointer to the register block"]
821 #[inline(always)]
822 pub const fn ptr() -> *const hmac::RegisterBlock {
823 Self::PTR
824 }
825 #[doc = r" Steal an instance of this peripheral"]
826 #[doc = r""]
827 #[doc = r" # Safety"]
828 #[doc = r""]
829 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
830 #[doc = r" that may race with any existing instances, for example by only"]
831 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
832 #[doc = r" original peripheral and using critical sections to coordinate"]
833 #[doc = r" access between multiple new instances."]
834 #[doc = r""]
835 #[doc = r" Additionally, other software such as HALs may rely on only one"]
836 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
837 #[doc = r" no stolen instances are passed to such software."]
838 pub unsafe fn steal() -> Self {
839 Self {
840 _marker: PhantomData,
841 }
842 }
843}
844impl Deref for HMAC {
845 type Target = hmac::RegisterBlock;
846 #[inline(always)]
847 fn deref(&self) -> &Self::Target {
848 unsafe { &*Self::PTR }
849 }
850}
851impl core::fmt::Debug for HMAC {
852 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
853 f.debug_struct("HMAC").finish()
854 }
855}
856#[doc = "HMAC (Hash-based Message Authentication Code) Accelerator"]
857pub mod hmac;
858#[doc = "HP_APM Peripheral"]
859pub struct HP_APM {
860 _marker: PhantomData<*const ()>,
861}
862unsafe impl Send for HP_APM {}
863impl HP_APM {
864 #[doc = r"Pointer to the register block"]
865 pub const PTR: *const hp_apm::RegisterBlock = 0x6009_9000 as *const _;
866 #[doc = r"Return the pointer to the register block"]
867 #[inline(always)]
868 pub const fn ptr() -> *const hp_apm::RegisterBlock {
869 Self::PTR
870 }
871 #[doc = r" Steal an instance of this peripheral"]
872 #[doc = r""]
873 #[doc = r" # Safety"]
874 #[doc = r""]
875 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
876 #[doc = r" that may race with any existing instances, for example by only"]
877 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
878 #[doc = r" original peripheral and using critical sections to coordinate"]
879 #[doc = r" access between multiple new instances."]
880 #[doc = r""]
881 #[doc = r" Additionally, other software such as HALs may rely on only one"]
882 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
883 #[doc = r" no stolen instances are passed to such software."]
884 pub unsafe fn steal() -> Self {
885 Self {
886 _marker: PhantomData,
887 }
888 }
889}
890impl Deref for HP_APM {
891 type Target = hp_apm::RegisterBlock;
892 #[inline(always)]
893 fn deref(&self) -> &Self::Target {
894 unsafe { &*Self::PTR }
895 }
896}
897impl core::fmt::Debug for HP_APM {
898 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
899 f.debug_struct("HP_APM").finish()
900 }
901}
902#[doc = "HP_APM Peripheral"]
903pub mod hp_apm;
904#[doc = "High-Power System"]
905pub struct HP_SYS {
906 _marker: PhantomData<*const ()>,
907}
908unsafe impl Send for HP_SYS {}
909impl HP_SYS {
910 #[doc = r"Pointer to the register block"]
911 pub const PTR: *const hp_sys::RegisterBlock = 0x6009_5000 as *const _;
912 #[doc = r"Return the pointer to the register block"]
913 #[inline(always)]
914 pub const fn ptr() -> *const hp_sys::RegisterBlock {
915 Self::PTR
916 }
917 #[doc = r" Steal an instance of this peripheral"]
918 #[doc = r""]
919 #[doc = r" # Safety"]
920 #[doc = r""]
921 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
922 #[doc = r" that may race with any existing instances, for example by only"]
923 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
924 #[doc = r" original peripheral and using critical sections to coordinate"]
925 #[doc = r" access between multiple new instances."]
926 #[doc = r""]
927 #[doc = r" Additionally, other software such as HALs may rely on only one"]
928 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
929 #[doc = r" no stolen instances are passed to such software."]
930 pub unsafe fn steal() -> Self {
931 Self {
932 _marker: PhantomData,
933 }
934 }
935}
936impl Deref for HP_SYS {
937 type Target = hp_sys::RegisterBlock;
938 #[inline(always)]
939 fn deref(&self) -> &Self::Target {
940 unsafe { &*Self::PTR }
941 }
942}
943impl core::fmt::Debug for HP_SYS {
944 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
945 f.debug_struct("HP_SYS").finish()
946 }
947}
948#[doc = "High-Power System"]
949pub mod hp_sys;
950#[doc = "I2C (Inter-Integrated Circuit) Controller 0"]
951pub struct I2C0 {
952 _marker: PhantomData<*const ()>,
953}
954unsafe impl Send for I2C0 {}
955impl I2C0 {
956 #[doc = r"Pointer to the register block"]
957 pub const PTR: *const i2c0::RegisterBlock = 0x6000_4000 as *const _;
958 #[doc = r"Return the pointer to the register block"]
959 #[inline(always)]
960 pub const fn ptr() -> *const i2c0::RegisterBlock {
961 Self::PTR
962 }
963 #[doc = r" Steal an instance of this peripheral"]
964 #[doc = r""]
965 #[doc = r" # Safety"]
966 #[doc = r""]
967 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
968 #[doc = r" that may race with any existing instances, for example by only"]
969 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
970 #[doc = r" original peripheral and using critical sections to coordinate"]
971 #[doc = r" access between multiple new instances."]
972 #[doc = r""]
973 #[doc = r" Additionally, other software such as HALs may rely on only one"]
974 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
975 #[doc = r" no stolen instances are passed to such software."]
976 pub unsafe fn steal() -> Self {
977 Self {
978 _marker: PhantomData,
979 }
980 }
981}
982impl Deref for I2C0 {
983 type Target = i2c0::RegisterBlock;
984 #[inline(always)]
985 fn deref(&self) -> &Self::Target {
986 unsafe { &*Self::PTR }
987 }
988}
989impl core::fmt::Debug for I2C0 {
990 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
991 f.debug_struct("I2C0").finish()
992 }
993}
994#[doc = "I2C (Inter-Integrated Circuit) Controller 0"]
995pub mod i2c0;
996#[doc = "I2S (Inter-IC Sound) Controller 0"]
997pub struct I2S0 {
998 _marker: PhantomData<*const ()>,
999}
1000unsafe impl Send for I2S0 {}
1001impl I2S0 {
1002 #[doc = r"Pointer to the register block"]
1003 pub const PTR: *const i2s0::RegisterBlock = 0x6000_c000 as *const _;
1004 #[doc = r"Return the pointer to the register block"]
1005 #[inline(always)]
1006 pub const fn ptr() -> *const i2s0::RegisterBlock {
1007 Self::PTR
1008 }
1009 #[doc = r" Steal an instance of this peripheral"]
1010 #[doc = r""]
1011 #[doc = r" # Safety"]
1012 #[doc = r""]
1013 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1014 #[doc = r" that may race with any existing instances, for example by only"]
1015 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1016 #[doc = r" original peripheral and using critical sections to coordinate"]
1017 #[doc = r" access between multiple new instances."]
1018 #[doc = r""]
1019 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1020 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1021 #[doc = r" no stolen instances are passed to such software."]
1022 pub unsafe fn steal() -> Self {
1023 Self {
1024 _marker: PhantomData,
1025 }
1026 }
1027}
1028impl Deref for I2S0 {
1029 type Target = i2s0::RegisterBlock;
1030 #[inline(always)]
1031 fn deref(&self) -> &Self::Target {
1032 unsafe { &*Self::PTR }
1033 }
1034}
1035impl core::fmt::Debug for I2S0 {
1036 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1037 f.debug_struct("I2S0").finish()
1038 }
1039}
1040#[doc = "I2S (Inter-IC Sound) Controller 0"]
1041pub mod i2s0;
1042#[doc = "IEEE802154 Peripheral"]
1043pub struct IEEE802154 {
1044 _marker: PhantomData<*const ()>,
1045}
1046unsafe impl Send for IEEE802154 {}
1047impl IEEE802154 {
1048 #[doc = r"Pointer to the register block"]
1049 pub const PTR: *const ieee802154::RegisterBlock = 0x600a_3000 as *const _;
1050 #[doc = r"Return the pointer to the register block"]
1051 #[inline(always)]
1052 pub const fn ptr() -> *const ieee802154::RegisterBlock {
1053 Self::PTR
1054 }
1055 #[doc = r" Steal an instance of this peripheral"]
1056 #[doc = r""]
1057 #[doc = r" # Safety"]
1058 #[doc = r""]
1059 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1060 #[doc = r" that may race with any existing instances, for example by only"]
1061 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1062 #[doc = r" original peripheral and using critical sections to coordinate"]
1063 #[doc = r" access between multiple new instances."]
1064 #[doc = r""]
1065 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1066 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1067 #[doc = r" no stolen instances are passed to such software."]
1068 pub unsafe fn steal() -> Self {
1069 Self {
1070 _marker: PhantomData,
1071 }
1072 }
1073}
1074impl Deref for IEEE802154 {
1075 type Target = ieee802154::RegisterBlock;
1076 #[inline(always)]
1077 fn deref(&self) -> &Self::Target {
1078 unsafe { &*Self::PTR }
1079 }
1080}
1081impl core::fmt::Debug for IEEE802154 {
1082 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1083 f.debug_struct("IEEE802154").finish()
1084 }
1085}
1086#[doc = "IEEE802154 Peripheral"]
1087pub mod ieee802154;
1088#[doc = "Interrupt Controller (Core 0)"]
1089pub struct INTERRUPT_CORE0 {
1090 _marker: PhantomData<*const ()>,
1091}
1092unsafe impl Send for INTERRUPT_CORE0 {}
1093impl INTERRUPT_CORE0 {
1094 #[doc = r"Pointer to the register block"]
1095 pub const PTR: *const interrupt_core0::RegisterBlock = 0x6001_0000 as *const _;
1096 #[doc = r"Return the pointer to the register block"]
1097 #[inline(always)]
1098 pub const fn ptr() -> *const interrupt_core0::RegisterBlock {
1099 Self::PTR
1100 }
1101 #[doc = r" Steal an instance of this peripheral"]
1102 #[doc = r""]
1103 #[doc = r" # Safety"]
1104 #[doc = r""]
1105 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1106 #[doc = r" that may race with any existing instances, for example by only"]
1107 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1108 #[doc = r" original peripheral and using critical sections to coordinate"]
1109 #[doc = r" access between multiple new instances."]
1110 #[doc = r""]
1111 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1112 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1113 #[doc = r" no stolen instances are passed to such software."]
1114 pub unsafe fn steal() -> Self {
1115 Self {
1116 _marker: PhantomData,
1117 }
1118 }
1119}
1120impl Deref for INTERRUPT_CORE0 {
1121 type Target = interrupt_core0::RegisterBlock;
1122 #[inline(always)]
1123 fn deref(&self) -> &Self::Target {
1124 unsafe { &*Self::PTR }
1125 }
1126}
1127impl core::fmt::Debug for INTERRUPT_CORE0 {
1128 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1129 f.debug_struct("INTERRUPT_CORE0").finish()
1130 }
1131}
1132#[doc = "Interrupt Controller (Core 0)"]
1133pub mod interrupt_core0;
1134#[doc = "INTPRI Peripheral"]
1135pub struct INTPRI {
1136 _marker: PhantomData<*const ()>,
1137}
1138unsafe impl Send for INTPRI {}
1139impl INTPRI {
1140 #[doc = r"Pointer to the register block"]
1141 pub const PTR: *const intpri::RegisterBlock = 0x600c_5000 as *const _;
1142 #[doc = r"Return the pointer to the register block"]
1143 #[inline(always)]
1144 pub const fn ptr() -> *const intpri::RegisterBlock {
1145 Self::PTR
1146 }
1147 #[doc = r" Steal an instance of this peripheral"]
1148 #[doc = r""]
1149 #[doc = r" # Safety"]
1150 #[doc = r""]
1151 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1152 #[doc = r" that may race with any existing instances, for example by only"]
1153 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1154 #[doc = r" original peripheral and using critical sections to coordinate"]
1155 #[doc = r" access between multiple new instances."]
1156 #[doc = r""]
1157 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1158 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1159 #[doc = r" no stolen instances are passed to such software."]
1160 pub unsafe fn steal() -> Self {
1161 Self {
1162 _marker: PhantomData,
1163 }
1164 }
1165}
1166impl Deref for INTPRI {
1167 type Target = intpri::RegisterBlock;
1168 #[inline(always)]
1169 fn deref(&self) -> &Self::Target {
1170 unsafe { &*Self::PTR }
1171 }
1172}
1173impl core::fmt::Debug for INTPRI {
1174 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1175 f.debug_struct("INTPRI").finish()
1176 }
1177}
1178#[doc = "INTPRI Peripheral"]
1179pub mod intpri;
1180#[doc = "Input/Output Multiplexer"]
1181pub struct IO_MUX {
1182 _marker: PhantomData<*const ()>,
1183}
1184unsafe impl Send for IO_MUX {}
1185impl IO_MUX {
1186 #[doc = r"Pointer to the register block"]
1187 pub const PTR: *const io_mux::RegisterBlock = 0x6009_0000 as *const _;
1188 #[doc = r"Return the pointer to the register block"]
1189 #[inline(always)]
1190 pub const fn ptr() -> *const io_mux::RegisterBlock {
1191 Self::PTR
1192 }
1193 #[doc = r" Steal an instance of this peripheral"]
1194 #[doc = r""]
1195 #[doc = r" # Safety"]
1196 #[doc = r""]
1197 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1198 #[doc = r" that may race with any existing instances, for example by only"]
1199 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1200 #[doc = r" original peripheral and using critical sections to coordinate"]
1201 #[doc = r" access between multiple new instances."]
1202 #[doc = r""]
1203 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1204 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1205 #[doc = r" no stolen instances are passed to such software."]
1206 pub unsafe fn steal() -> Self {
1207 Self {
1208 _marker: PhantomData,
1209 }
1210 }
1211}
1212impl Deref for IO_MUX {
1213 type Target = io_mux::RegisterBlock;
1214 #[inline(always)]
1215 fn deref(&self) -> &Self::Target {
1216 unsafe { &*Self::PTR }
1217 }
1218}
1219impl core::fmt::Debug for IO_MUX {
1220 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1221 f.debug_struct("IO_MUX").finish()
1222 }
1223}
1224#[doc = "Input/Output Multiplexer"]
1225pub mod io_mux;
1226#[doc = "LED Control PWM (Pulse Width Modulation)"]
1227pub struct LEDC {
1228 _marker: PhantomData<*const ()>,
1229}
1230unsafe impl Send for LEDC {}
1231impl LEDC {
1232 #[doc = r"Pointer to the register block"]
1233 pub const PTR: *const ledc::RegisterBlock = 0x6000_7000 as *const _;
1234 #[doc = r"Return the pointer to the register block"]
1235 #[inline(always)]
1236 pub const fn ptr() -> *const ledc::RegisterBlock {
1237 Self::PTR
1238 }
1239 #[doc = r" Steal an instance of this peripheral"]
1240 #[doc = r""]
1241 #[doc = r" # Safety"]
1242 #[doc = r""]
1243 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1244 #[doc = r" that may race with any existing instances, for example by only"]
1245 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1246 #[doc = r" original peripheral and using critical sections to coordinate"]
1247 #[doc = r" access between multiple new instances."]
1248 #[doc = r""]
1249 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1250 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1251 #[doc = r" no stolen instances are passed to such software."]
1252 pub unsafe fn steal() -> Self {
1253 Self {
1254 _marker: PhantomData,
1255 }
1256 }
1257}
1258impl Deref for LEDC {
1259 type Target = ledc::RegisterBlock;
1260 #[inline(always)]
1261 fn deref(&self) -> &Self::Target {
1262 unsafe { &*Self::PTR }
1263 }
1264}
1265impl core::fmt::Debug for LEDC {
1266 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1267 f.debug_struct("LEDC").finish()
1268 }
1269}
1270#[doc = "LED Control PWM (Pulse Width Modulation)"]
1271pub mod ledc;
1272#[doc = "LP_PERI Peripheral"]
1273pub struct LP_PERI {
1274 _marker: PhantomData<*const ()>,
1275}
1276unsafe impl Send for LP_PERI {}
1277impl LP_PERI {
1278 #[doc = r"Pointer to the register block"]
1279 pub const PTR: *const lp_peri::RegisterBlock = 0x600b_2800 as *const _;
1280 #[doc = r"Return the pointer to the register block"]
1281 #[inline(always)]
1282 pub const fn ptr() -> *const lp_peri::RegisterBlock {
1283 Self::PTR
1284 }
1285 #[doc = r" Steal an instance of this peripheral"]
1286 #[doc = r""]
1287 #[doc = r" # Safety"]
1288 #[doc = r""]
1289 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1290 #[doc = r" that may race with any existing instances, for example by only"]
1291 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1292 #[doc = r" original peripheral and using critical sections to coordinate"]
1293 #[doc = r" access between multiple new instances."]
1294 #[doc = r""]
1295 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1296 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1297 #[doc = r" no stolen instances are passed to such software."]
1298 pub unsafe fn steal() -> Self {
1299 Self {
1300 _marker: PhantomData,
1301 }
1302 }
1303}
1304impl Deref for LP_PERI {
1305 type Target = lp_peri::RegisterBlock;
1306 #[inline(always)]
1307 fn deref(&self) -> &Self::Target {
1308 unsafe { &*Self::PTR }
1309 }
1310}
1311impl core::fmt::Debug for LP_PERI {
1312 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1313 f.debug_struct("LP_PERI").finish()
1314 }
1315}
1316#[doc = "LP_PERI Peripheral"]
1317pub mod lp_peri;
1318#[doc = "LP_ANA Peripheral"]
1319pub struct LP_ANA {
1320 _marker: PhantomData<*const ()>,
1321}
1322unsafe impl Send for LP_ANA {}
1323impl LP_ANA {
1324 #[doc = r"Pointer to the register block"]
1325 pub const PTR: *const lp_ana::RegisterBlock = 0x600b_2c00 as *const _;
1326 #[doc = r"Return the pointer to the register block"]
1327 #[inline(always)]
1328 pub const fn ptr() -> *const lp_ana::RegisterBlock {
1329 Self::PTR
1330 }
1331 #[doc = r" Steal an instance of this peripheral"]
1332 #[doc = r""]
1333 #[doc = r" # Safety"]
1334 #[doc = r""]
1335 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1336 #[doc = r" that may race with any existing instances, for example by only"]
1337 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1338 #[doc = r" original peripheral and using critical sections to coordinate"]
1339 #[doc = r" access between multiple new instances."]
1340 #[doc = r""]
1341 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1342 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1343 #[doc = r" no stolen instances are passed to such software."]
1344 pub unsafe fn steal() -> Self {
1345 Self {
1346 _marker: PhantomData,
1347 }
1348 }
1349}
1350impl Deref for LP_ANA {
1351 type Target = lp_ana::RegisterBlock;
1352 #[inline(always)]
1353 fn deref(&self) -> &Self::Target {
1354 unsafe { &*Self::PTR }
1355 }
1356}
1357impl core::fmt::Debug for LP_ANA {
1358 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1359 f.debug_struct("LP_ANA").finish()
1360 }
1361}
1362#[doc = "LP_ANA Peripheral"]
1363pub mod lp_ana;
1364#[doc = "LP_AON Peripheral"]
1365pub struct LP_AON {
1366 _marker: PhantomData<*const ()>,
1367}
1368unsafe impl Send for LP_AON {}
1369impl LP_AON {
1370 #[doc = r"Pointer to the register block"]
1371 pub const PTR: *const lp_aon::RegisterBlock = 0x600b_1000 as *const _;
1372 #[doc = r"Return the pointer to the register block"]
1373 #[inline(always)]
1374 pub const fn ptr() -> *const lp_aon::RegisterBlock {
1375 Self::PTR
1376 }
1377 #[doc = r" Steal an instance of this peripheral"]
1378 #[doc = r""]
1379 #[doc = r" # Safety"]
1380 #[doc = r""]
1381 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1382 #[doc = r" that may race with any existing instances, for example by only"]
1383 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1384 #[doc = r" original peripheral and using critical sections to coordinate"]
1385 #[doc = r" access between multiple new instances."]
1386 #[doc = r""]
1387 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1388 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1389 #[doc = r" no stolen instances are passed to such software."]
1390 pub unsafe fn steal() -> Self {
1391 Self {
1392 _marker: PhantomData,
1393 }
1394 }
1395}
1396impl Deref for LP_AON {
1397 type Target = lp_aon::RegisterBlock;
1398 #[inline(always)]
1399 fn deref(&self) -> &Self::Target {
1400 unsafe { &*Self::PTR }
1401 }
1402}
1403impl core::fmt::Debug for LP_AON {
1404 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1405 f.debug_struct("LP_AON").finish()
1406 }
1407}
1408#[doc = "LP_AON Peripheral"]
1409pub mod lp_aon;
1410#[doc = "Low-power Access Permission Management Controller"]
1411pub struct LP_APM {
1412 _marker: PhantomData<*const ()>,
1413}
1414unsafe impl Send for LP_APM {}
1415impl LP_APM {
1416 #[doc = r"Pointer to the register block"]
1417 pub const PTR: *const lp_apm::RegisterBlock = 0x600b_3800 as *const _;
1418 #[doc = r"Return the pointer to the register block"]
1419 #[inline(always)]
1420 pub const fn ptr() -> *const lp_apm::RegisterBlock {
1421 Self::PTR
1422 }
1423 #[doc = r" Steal an instance of this peripheral"]
1424 #[doc = r""]
1425 #[doc = r" # Safety"]
1426 #[doc = r""]
1427 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1428 #[doc = r" that may race with any existing instances, for example by only"]
1429 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1430 #[doc = r" original peripheral and using critical sections to coordinate"]
1431 #[doc = r" access between multiple new instances."]
1432 #[doc = r""]
1433 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1434 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1435 #[doc = r" no stolen instances are passed to such software."]
1436 pub unsafe fn steal() -> Self {
1437 Self {
1438 _marker: PhantomData,
1439 }
1440 }
1441}
1442impl Deref for LP_APM {
1443 type Target = lp_apm::RegisterBlock;
1444 #[inline(always)]
1445 fn deref(&self) -> &Self::Target {
1446 unsafe { &*Self::PTR }
1447 }
1448}
1449impl core::fmt::Debug for LP_APM {
1450 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1451 f.debug_struct("LP_APM").finish()
1452 }
1453}
1454#[doc = "Low-power Access Permission Management Controller"]
1455pub mod lp_apm;
1456#[doc = "LP_APM0 Peripheral"]
1457pub struct LP_APM0 {
1458 _marker: PhantomData<*const ()>,
1459}
1460unsafe impl Send for LP_APM0 {}
1461impl LP_APM0 {
1462 #[doc = r"Pointer to the register block"]
1463 pub const PTR: *const lp_apm0::RegisterBlock = 0x6009_9800 as *const _;
1464 #[doc = r"Return the pointer to the register block"]
1465 #[inline(always)]
1466 pub const fn ptr() -> *const lp_apm0::RegisterBlock {
1467 Self::PTR
1468 }
1469 #[doc = r" Steal an instance of this peripheral"]
1470 #[doc = r""]
1471 #[doc = r" # Safety"]
1472 #[doc = r""]
1473 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1474 #[doc = r" that may race with any existing instances, for example by only"]
1475 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1476 #[doc = r" original peripheral and using critical sections to coordinate"]
1477 #[doc = r" access between multiple new instances."]
1478 #[doc = r""]
1479 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1480 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1481 #[doc = r" no stolen instances are passed to such software."]
1482 pub unsafe fn steal() -> Self {
1483 Self {
1484 _marker: PhantomData,
1485 }
1486 }
1487}
1488impl Deref for LP_APM0 {
1489 type Target = lp_apm0::RegisterBlock;
1490 #[inline(always)]
1491 fn deref(&self) -> &Self::Target {
1492 unsafe { &*Self::PTR }
1493 }
1494}
1495impl core::fmt::Debug for LP_APM0 {
1496 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1497 f.debug_struct("LP_APM0").finish()
1498 }
1499}
1500#[doc = "LP_APM0 Peripheral"]
1501pub mod lp_apm0;
1502#[doc = "LP_CLKRST Peripheral"]
1503pub struct LP_CLKRST {
1504 _marker: PhantomData<*const ()>,
1505}
1506unsafe impl Send for LP_CLKRST {}
1507impl LP_CLKRST {
1508 #[doc = r"Pointer to the register block"]
1509 pub const PTR: *const lp_clkrst::RegisterBlock = 0x600b_0400 as *const _;
1510 #[doc = r"Return the pointer to the register block"]
1511 #[inline(always)]
1512 pub const fn ptr() -> *const lp_clkrst::RegisterBlock {
1513 Self::PTR
1514 }
1515 #[doc = r" Steal an instance of this peripheral"]
1516 #[doc = r""]
1517 #[doc = r" # Safety"]
1518 #[doc = r""]
1519 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1520 #[doc = r" that may race with any existing instances, for example by only"]
1521 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1522 #[doc = r" original peripheral and using critical sections to coordinate"]
1523 #[doc = r" access between multiple new instances."]
1524 #[doc = r""]
1525 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1526 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1527 #[doc = r" no stolen instances are passed to such software."]
1528 pub unsafe fn steal() -> Self {
1529 Self {
1530 _marker: PhantomData,
1531 }
1532 }
1533}
1534impl Deref for LP_CLKRST {
1535 type Target = lp_clkrst::RegisterBlock;
1536 #[inline(always)]
1537 fn deref(&self) -> &Self::Target {
1538 unsafe { &*Self::PTR }
1539 }
1540}
1541impl core::fmt::Debug for LP_CLKRST {
1542 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1543 f.debug_struct("LP_CLKRST").finish()
1544 }
1545}
1546#[doc = "LP_CLKRST Peripheral"]
1547pub mod lp_clkrst;
1548#[doc = "Low-power I2C (Inter-Integrated Circuit) Controller 0"]
1549pub struct LP_I2C0 {
1550 _marker: PhantomData<*const ()>,
1551}
1552unsafe impl Send for LP_I2C0 {}
1553impl LP_I2C0 {
1554 #[doc = r"Pointer to the register block"]
1555 pub const PTR: *const lp_i2c0::RegisterBlock = 0x600b_1800 as *const _;
1556 #[doc = r"Return the pointer to the register block"]
1557 #[inline(always)]
1558 pub const fn ptr() -> *const lp_i2c0::RegisterBlock {
1559 Self::PTR
1560 }
1561 #[doc = r" Steal an instance of this peripheral"]
1562 #[doc = r""]
1563 #[doc = r" # Safety"]
1564 #[doc = r""]
1565 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1566 #[doc = r" that may race with any existing instances, for example by only"]
1567 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1568 #[doc = r" original peripheral and using critical sections to coordinate"]
1569 #[doc = r" access between multiple new instances."]
1570 #[doc = r""]
1571 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1572 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1573 #[doc = r" no stolen instances are passed to such software."]
1574 pub unsafe fn steal() -> Self {
1575 Self {
1576 _marker: PhantomData,
1577 }
1578 }
1579}
1580impl Deref for LP_I2C0 {
1581 type Target = lp_i2c0::RegisterBlock;
1582 #[inline(always)]
1583 fn deref(&self) -> &Self::Target {
1584 unsafe { &*Self::PTR }
1585 }
1586}
1587impl core::fmt::Debug for LP_I2C0 {
1588 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1589 f.debug_struct("LP_I2C0").finish()
1590 }
1591}
1592#[doc = "Low-power I2C (Inter-Integrated Circuit) Controller 0"]
1593pub mod lp_i2c0;
1594#[doc = "LP_I2C_ANA_MST Peripheral"]
1595pub struct LP_I2C_ANA_MST {
1596 _marker: PhantomData<*const ()>,
1597}
1598unsafe impl Send for LP_I2C_ANA_MST {}
1599impl LP_I2C_ANA_MST {
1600 #[doc = r"Pointer to the register block"]
1601 pub const PTR: *const lp_i2c_ana_mst::RegisterBlock = 0x600b_2400 as *const _;
1602 #[doc = r"Return the pointer to the register block"]
1603 #[inline(always)]
1604 pub const fn ptr() -> *const lp_i2c_ana_mst::RegisterBlock {
1605 Self::PTR
1606 }
1607 #[doc = r" Steal an instance of this peripheral"]
1608 #[doc = r""]
1609 #[doc = r" # Safety"]
1610 #[doc = r""]
1611 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1612 #[doc = r" that may race with any existing instances, for example by only"]
1613 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1614 #[doc = r" original peripheral and using critical sections to coordinate"]
1615 #[doc = r" access between multiple new instances."]
1616 #[doc = r""]
1617 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1618 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1619 #[doc = r" no stolen instances are passed to such software."]
1620 pub unsafe fn steal() -> Self {
1621 Self {
1622 _marker: PhantomData,
1623 }
1624 }
1625}
1626impl Deref for LP_I2C_ANA_MST {
1627 type Target = lp_i2c_ana_mst::RegisterBlock;
1628 #[inline(always)]
1629 fn deref(&self) -> &Self::Target {
1630 unsafe { &*Self::PTR }
1631 }
1632}
1633impl core::fmt::Debug for LP_I2C_ANA_MST {
1634 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1635 f.debug_struct("LP_I2C_ANA_MST").finish()
1636 }
1637}
1638#[doc = "LP_I2C_ANA_MST Peripheral"]
1639pub mod lp_i2c_ana_mst;
1640#[doc = "LP_IO Peripheral"]
1641pub struct LP_IO {
1642 _marker: PhantomData<*const ()>,
1643}
1644unsafe impl Send for LP_IO {}
1645impl LP_IO {
1646 #[doc = r"Pointer to the register block"]
1647 pub const PTR: *const lp_io::RegisterBlock = 0x600b_2000 as *const _;
1648 #[doc = r"Return the pointer to the register block"]
1649 #[inline(always)]
1650 pub const fn ptr() -> *const lp_io::RegisterBlock {
1651 Self::PTR
1652 }
1653 #[doc = r" Steal an instance of this peripheral"]
1654 #[doc = r""]
1655 #[doc = r" # Safety"]
1656 #[doc = r""]
1657 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1658 #[doc = r" that may race with any existing instances, for example by only"]
1659 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1660 #[doc = r" original peripheral and using critical sections to coordinate"]
1661 #[doc = r" access between multiple new instances."]
1662 #[doc = r""]
1663 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1664 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1665 #[doc = r" no stolen instances are passed to such software."]
1666 pub unsafe fn steal() -> Self {
1667 Self {
1668 _marker: PhantomData,
1669 }
1670 }
1671}
1672impl Deref for LP_IO {
1673 type Target = lp_io::RegisterBlock;
1674 #[inline(always)]
1675 fn deref(&self) -> &Self::Target {
1676 unsafe { &*Self::PTR }
1677 }
1678}
1679impl core::fmt::Debug for LP_IO {
1680 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1681 f.debug_struct("LP_IO").finish()
1682 }
1683}
1684#[doc = "LP_IO Peripheral"]
1685pub mod lp_io;
1686#[doc = "Low-power Trusted Execution Environment"]
1687pub struct LP_TEE {
1688 _marker: PhantomData<*const ()>,
1689}
1690unsafe impl Send for LP_TEE {}
1691impl LP_TEE {
1692 #[doc = r"Pointer to the register block"]
1693 pub const PTR: *const lp_tee::RegisterBlock = 0x600b_3400 as *const _;
1694 #[doc = r"Return the pointer to the register block"]
1695 #[inline(always)]
1696 pub const fn ptr() -> *const lp_tee::RegisterBlock {
1697 Self::PTR
1698 }
1699 #[doc = r" Steal an instance of this peripheral"]
1700 #[doc = r""]
1701 #[doc = r" # Safety"]
1702 #[doc = r""]
1703 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1704 #[doc = r" that may race with any existing instances, for example by only"]
1705 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1706 #[doc = r" original peripheral and using critical sections to coordinate"]
1707 #[doc = r" access between multiple new instances."]
1708 #[doc = r""]
1709 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1710 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1711 #[doc = r" no stolen instances are passed to such software."]
1712 pub unsafe fn steal() -> Self {
1713 Self {
1714 _marker: PhantomData,
1715 }
1716 }
1717}
1718impl Deref for LP_TEE {
1719 type Target = lp_tee::RegisterBlock;
1720 #[inline(always)]
1721 fn deref(&self) -> &Self::Target {
1722 unsafe { &*Self::PTR }
1723 }
1724}
1725impl core::fmt::Debug for LP_TEE {
1726 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1727 f.debug_struct("LP_TEE").finish()
1728 }
1729}
1730#[doc = "Low-power Trusted Execution Environment"]
1731pub mod lp_tee;
1732#[doc = "Low-power Timer"]
1733pub struct LP_TIMER {
1734 _marker: PhantomData<*const ()>,
1735}
1736unsafe impl Send for LP_TIMER {}
1737impl LP_TIMER {
1738 #[doc = r"Pointer to the register block"]
1739 pub const PTR: *const lp_timer::RegisterBlock = 0x600b_0c00 as *const _;
1740 #[doc = r"Return the pointer to the register block"]
1741 #[inline(always)]
1742 pub const fn ptr() -> *const lp_timer::RegisterBlock {
1743 Self::PTR
1744 }
1745 #[doc = r" Steal an instance of this peripheral"]
1746 #[doc = r""]
1747 #[doc = r" # Safety"]
1748 #[doc = r""]
1749 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1750 #[doc = r" that may race with any existing instances, for example by only"]
1751 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1752 #[doc = r" original peripheral and using critical sections to coordinate"]
1753 #[doc = r" access between multiple new instances."]
1754 #[doc = r""]
1755 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1756 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1757 #[doc = r" no stolen instances are passed to such software."]
1758 pub unsafe fn steal() -> Self {
1759 Self {
1760 _marker: PhantomData,
1761 }
1762 }
1763}
1764impl Deref for LP_TIMER {
1765 type Target = lp_timer::RegisterBlock;
1766 #[inline(always)]
1767 fn deref(&self) -> &Self::Target {
1768 unsafe { &*Self::PTR }
1769 }
1770}
1771impl core::fmt::Debug for LP_TIMER {
1772 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1773 f.debug_struct("LP_TIMER").finish()
1774 }
1775}
1776#[doc = "Low-power Timer"]
1777pub mod lp_timer;
1778#[doc = "Low-power UART (Universal Asynchronous Receiver-Transmitter) Controller"]
1779pub struct LP_UART {
1780 _marker: PhantomData<*const ()>,
1781}
1782unsafe impl Send for LP_UART {}
1783impl LP_UART {
1784 #[doc = r"Pointer to the register block"]
1785 pub const PTR: *const lp_uart::RegisterBlock = 0x600b_1400 as *const _;
1786 #[doc = r"Return the pointer to the register block"]
1787 #[inline(always)]
1788 pub const fn ptr() -> *const lp_uart::RegisterBlock {
1789 Self::PTR
1790 }
1791 #[doc = r" Steal an instance of this peripheral"]
1792 #[doc = r""]
1793 #[doc = r" # Safety"]
1794 #[doc = r""]
1795 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1796 #[doc = r" that may race with any existing instances, for example by only"]
1797 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1798 #[doc = r" original peripheral and using critical sections to coordinate"]
1799 #[doc = r" access between multiple new instances."]
1800 #[doc = r""]
1801 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1802 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1803 #[doc = r" no stolen instances are passed to such software."]
1804 pub unsafe fn steal() -> Self {
1805 Self {
1806 _marker: PhantomData,
1807 }
1808 }
1809}
1810impl Deref for LP_UART {
1811 type Target = lp_uart::RegisterBlock;
1812 #[inline(always)]
1813 fn deref(&self) -> &Self::Target {
1814 unsafe { &*Self::PTR }
1815 }
1816}
1817impl core::fmt::Debug for LP_UART {
1818 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1819 f.debug_struct("LP_UART").finish()
1820 }
1821}
1822#[doc = "Low-power UART (Universal Asynchronous Receiver-Transmitter) Controller"]
1823pub mod lp_uart;
1824#[doc = "Low-power Watchdog Timer"]
1825pub struct LP_WDT {
1826 _marker: PhantomData<*const ()>,
1827}
1828unsafe impl Send for LP_WDT {}
1829impl LP_WDT {
1830 #[doc = r"Pointer to the register block"]
1831 pub const PTR: *const lp_wdt::RegisterBlock = 0x600b_1c00 as *const _;
1832 #[doc = r"Return the pointer to the register block"]
1833 #[inline(always)]
1834 pub const fn ptr() -> *const lp_wdt::RegisterBlock {
1835 Self::PTR
1836 }
1837 #[doc = r" Steal an instance of this peripheral"]
1838 #[doc = r""]
1839 #[doc = r" # Safety"]
1840 #[doc = r""]
1841 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1842 #[doc = r" that may race with any existing instances, for example by only"]
1843 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1844 #[doc = r" original peripheral and using critical sections to coordinate"]
1845 #[doc = r" access between multiple new instances."]
1846 #[doc = r""]
1847 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1848 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1849 #[doc = r" no stolen instances are passed to such software."]
1850 pub unsafe fn steal() -> Self {
1851 Self {
1852 _marker: PhantomData,
1853 }
1854 }
1855}
1856impl Deref for LP_WDT {
1857 type Target = lp_wdt::RegisterBlock;
1858 #[inline(always)]
1859 fn deref(&self) -> &Self::Target {
1860 unsafe { &*Self::PTR }
1861 }
1862}
1863impl core::fmt::Debug for LP_WDT {
1864 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1865 f.debug_struct("LP_WDT").finish()
1866 }
1867}
1868#[doc = "Low-power Watchdog Timer"]
1869pub mod lp_wdt;
1870#[doc = "Motor Control Pulse-Width Modulation 0"]
1871pub struct MCPWM0 {
1872 _marker: PhantomData<*const ()>,
1873}
1874unsafe impl Send for MCPWM0 {}
1875impl MCPWM0 {
1876 #[doc = r"Pointer to the register block"]
1877 pub const PTR: *const mcpwm0::RegisterBlock = 0x6001_4000 as *const _;
1878 #[doc = r"Return the pointer to the register block"]
1879 #[inline(always)]
1880 pub const fn ptr() -> *const mcpwm0::RegisterBlock {
1881 Self::PTR
1882 }
1883 #[doc = r" Steal an instance of this peripheral"]
1884 #[doc = r""]
1885 #[doc = r" # Safety"]
1886 #[doc = r""]
1887 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1888 #[doc = r" that may race with any existing instances, for example by only"]
1889 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1890 #[doc = r" original peripheral and using critical sections to coordinate"]
1891 #[doc = r" access between multiple new instances."]
1892 #[doc = r""]
1893 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1894 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1895 #[doc = r" no stolen instances are passed to such software."]
1896 pub unsafe fn steal() -> Self {
1897 Self {
1898 _marker: PhantomData,
1899 }
1900 }
1901}
1902impl Deref for MCPWM0 {
1903 type Target = mcpwm0::RegisterBlock;
1904 #[inline(always)]
1905 fn deref(&self) -> &Self::Target {
1906 unsafe { &*Self::PTR }
1907 }
1908}
1909impl core::fmt::Debug for MCPWM0 {
1910 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1911 f.debug_struct("MCPWM0").finish()
1912 }
1913}
1914#[doc = "Motor Control Pulse-Width Modulation 0"]
1915pub mod mcpwm0;
1916#[doc = "MEM_MONITOR Peripheral"]
1917pub struct MEM_MONITOR {
1918 _marker: PhantomData<*const ()>,
1919}
1920unsafe impl Send for MEM_MONITOR {}
1921impl MEM_MONITOR {
1922 #[doc = r"Pointer to the register block"]
1923 pub const PTR: *const mem_monitor::RegisterBlock = 0x6009_2000 as *const _;
1924 #[doc = r"Return the pointer to the register block"]
1925 #[inline(always)]
1926 pub const fn ptr() -> *const mem_monitor::RegisterBlock {
1927 Self::PTR
1928 }
1929 #[doc = r" Steal an instance of this peripheral"]
1930 #[doc = r""]
1931 #[doc = r" # Safety"]
1932 #[doc = r""]
1933 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1934 #[doc = r" that may race with any existing instances, for example by only"]
1935 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1936 #[doc = r" original peripheral and using critical sections to coordinate"]
1937 #[doc = r" access between multiple new instances."]
1938 #[doc = r""]
1939 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1940 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1941 #[doc = r" no stolen instances are passed to such software."]
1942 pub unsafe fn steal() -> Self {
1943 Self {
1944 _marker: PhantomData,
1945 }
1946 }
1947}
1948impl Deref for MEM_MONITOR {
1949 type Target = mem_monitor::RegisterBlock;
1950 #[inline(always)]
1951 fn deref(&self) -> &Self::Target {
1952 unsafe { &*Self::PTR }
1953 }
1954}
1955impl core::fmt::Debug for MEM_MONITOR {
1956 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1957 f.debug_struct("MEM_MONITOR").finish()
1958 }
1959}
1960#[doc = "MEM_MONITOR Peripheral"]
1961pub mod mem_monitor;
1962#[doc = "MODEM_LPCON Peripheral"]
1963pub struct MODEM_LPCON {
1964 _marker: PhantomData<*const ()>,
1965}
1966unsafe impl Send for MODEM_LPCON {}
1967impl MODEM_LPCON {
1968 #[doc = r"Pointer to the register block"]
1969 pub const PTR: *const modem_lpcon::RegisterBlock = 0x600a_f000 as *const _;
1970 #[doc = r"Return the pointer to the register block"]
1971 #[inline(always)]
1972 pub const fn ptr() -> *const modem_lpcon::RegisterBlock {
1973 Self::PTR
1974 }
1975 #[doc = r" Steal an instance of this peripheral"]
1976 #[doc = r""]
1977 #[doc = r" # Safety"]
1978 #[doc = r""]
1979 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1980 #[doc = r" that may race with any existing instances, for example by only"]
1981 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1982 #[doc = r" original peripheral and using critical sections to coordinate"]
1983 #[doc = r" access between multiple new instances."]
1984 #[doc = r""]
1985 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1986 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1987 #[doc = r" no stolen instances are passed to such software."]
1988 pub unsafe fn steal() -> Self {
1989 Self {
1990 _marker: PhantomData,
1991 }
1992 }
1993}
1994impl Deref for MODEM_LPCON {
1995 type Target = modem_lpcon::RegisterBlock;
1996 #[inline(always)]
1997 fn deref(&self) -> &Self::Target {
1998 unsafe { &*Self::PTR }
1999 }
2000}
2001impl core::fmt::Debug for MODEM_LPCON {
2002 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2003 f.debug_struct("MODEM_LPCON").finish()
2004 }
2005}
2006#[doc = "MODEM_LPCON Peripheral"]
2007pub mod modem_lpcon;
2008#[doc = "MODEM_SYSCON Peripheral"]
2009pub struct MODEM_SYSCON {
2010 _marker: PhantomData<*const ()>,
2011}
2012unsafe impl Send for MODEM_SYSCON {}
2013impl MODEM_SYSCON {
2014 #[doc = r"Pointer to the register block"]
2015 pub const PTR: *const modem_syscon::RegisterBlock = 0x600a_9800 as *const _;
2016 #[doc = r"Return the pointer to the register block"]
2017 #[inline(always)]
2018 pub const fn ptr() -> *const modem_syscon::RegisterBlock {
2019 Self::PTR
2020 }
2021 #[doc = r" Steal an instance of this peripheral"]
2022 #[doc = r""]
2023 #[doc = r" # Safety"]
2024 #[doc = r""]
2025 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2026 #[doc = r" that may race with any existing instances, for example by only"]
2027 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2028 #[doc = r" original peripheral and using critical sections to coordinate"]
2029 #[doc = r" access between multiple new instances."]
2030 #[doc = r""]
2031 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2032 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2033 #[doc = r" no stolen instances are passed to such software."]
2034 pub unsafe fn steal() -> Self {
2035 Self {
2036 _marker: PhantomData,
2037 }
2038 }
2039}
2040impl Deref for MODEM_SYSCON {
2041 type Target = modem_syscon::RegisterBlock;
2042 #[inline(always)]
2043 fn deref(&self) -> &Self::Target {
2044 unsafe { &*Self::PTR }
2045 }
2046}
2047impl core::fmt::Debug for MODEM_SYSCON {
2048 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2049 f.debug_struct("MODEM_SYSCON").finish()
2050 }
2051}
2052#[doc = "MODEM_SYSCON Peripheral"]
2053pub mod modem_syscon;
2054#[doc = "OTP_DEBUG Peripheral"]
2055pub struct OTP_DEBUG {
2056 _marker: PhantomData<*const ()>,
2057}
2058unsafe impl Send for OTP_DEBUG {}
2059impl OTP_DEBUG {
2060 #[doc = r"Pointer to the register block"]
2061 pub const PTR: *const otp_debug::RegisterBlock = 0x600b_3c00 as *const _;
2062 #[doc = r"Return the pointer to the register block"]
2063 #[inline(always)]
2064 pub const fn ptr() -> *const otp_debug::RegisterBlock {
2065 Self::PTR
2066 }
2067 #[doc = r" Steal an instance of this peripheral"]
2068 #[doc = r""]
2069 #[doc = r" # Safety"]
2070 #[doc = r""]
2071 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2072 #[doc = r" that may race with any existing instances, for example by only"]
2073 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2074 #[doc = r" original peripheral and using critical sections to coordinate"]
2075 #[doc = r" access between multiple new instances."]
2076 #[doc = r""]
2077 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2078 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2079 #[doc = r" no stolen instances are passed to such software."]
2080 pub unsafe fn steal() -> Self {
2081 Self {
2082 _marker: PhantomData,
2083 }
2084 }
2085}
2086impl Deref for OTP_DEBUG {
2087 type Target = otp_debug::RegisterBlock;
2088 #[inline(always)]
2089 fn deref(&self) -> &Self::Target {
2090 unsafe { &*Self::PTR }
2091 }
2092}
2093impl core::fmt::Debug for OTP_DEBUG {
2094 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2095 f.debug_struct("OTP_DEBUG").finish()
2096 }
2097}
2098#[doc = "OTP_DEBUG Peripheral"]
2099pub mod otp_debug;
2100#[doc = "Parallel IO Controller"]
2101pub struct PARL_IO {
2102 _marker: PhantomData<*const ()>,
2103}
2104unsafe impl Send for PARL_IO {}
2105impl PARL_IO {
2106 #[doc = r"Pointer to the register block"]
2107 pub const PTR: *const parl_io::RegisterBlock = 0x6001_5000 as *const _;
2108 #[doc = r"Return the pointer to the register block"]
2109 #[inline(always)]
2110 pub const fn ptr() -> *const parl_io::RegisterBlock {
2111 Self::PTR
2112 }
2113 #[doc = r" Steal an instance of this peripheral"]
2114 #[doc = r""]
2115 #[doc = r" # Safety"]
2116 #[doc = r""]
2117 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2118 #[doc = r" that may race with any existing instances, for example by only"]
2119 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2120 #[doc = r" original peripheral and using critical sections to coordinate"]
2121 #[doc = r" access between multiple new instances."]
2122 #[doc = r""]
2123 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2124 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2125 #[doc = r" no stolen instances are passed to such software."]
2126 pub unsafe fn steal() -> Self {
2127 Self {
2128 _marker: PhantomData,
2129 }
2130 }
2131}
2132impl Deref for PARL_IO {
2133 type Target = parl_io::RegisterBlock;
2134 #[inline(always)]
2135 fn deref(&self) -> &Self::Target {
2136 unsafe { &*Self::PTR }
2137 }
2138}
2139impl core::fmt::Debug for PARL_IO {
2140 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2141 f.debug_struct("PARL_IO").finish()
2142 }
2143}
2144#[doc = "Parallel IO Controller"]
2145pub mod parl_io;
2146#[doc = "PAU Peripheral"]
2147pub struct PAU {
2148 _marker: PhantomData<*const ()>,
2149}
2150unsafe impl Send for PAU {}
2151impl PAU {
2152 #[doc = r"Pointer to the register block"]
2153 pub const PTR: *const pau::RegisterBlock = 0x6009_3000 as *const _;
2154 #[doc = r"Return the pointer to the register block"]
2155 #[inline(always)]
2156 pub const fn ptr() -> *const pau::RegisterBlock {
2157 Self::PTR
2158 }
2159 #[doc = r" Steal an instance of this peripheral"]
2160 #[doc = r""]
2161 #[doc = r" # Safety"]
2162 #[doc = r""]
2163 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2164 #[doc = r" that may race with any existing instances, for example by only"]
2165 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2166 #[doc = r" original peripheral and using critical sections to coordinate"]
2167 #[doc = r" access between multiple new instances."]
2168 #[doc = r""]
2169 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2170 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2171 #[doc = r" no stolen instances are passed to such software."]
2172 pub unsafe fn steal() -> Self {
2173 Self {
2174 _marker: PhantomData,
2175 }
2176 }
2177}
2178impl Deref for PAU {
2179 type Target = pau::RegisterBlock;
2180 #[inline(always)]
2181 fn deref(&self) -> &Self::Target {
2182 unsafe { &*Self::PTR }
2183 }
2184}
2185impl core::fmt::Debug for PAU {
2186 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2187 f.debug_struct("PAU").finish()
2188 }
2189}
2190#[doc = "PAU Peripheral"]
2191pub mod pau;
2192#[doc = "Pulse Count Controller"]
2193pub struct PCNT {
2194 _marker: PhantomData<*const ()>,
2195}
2196unsafe impl Send for PCNT {}
2197impl PCNT {
2198 #[doc = r"Pointer to the register block"]
2199 pub const PTR: *const pcnt::RegisterBlock = 0x6001_2000 as *const _;
2200 #[doc = r"Return the pointer to the register block"]
2201 #[inline(always)]
2202 pub const fn ptr() -> *const pcnt::RegisterBlock {
2203 Self::PTR
2204 }
2205 #[doc = r" Steal an instance of this peripheral"]
2206 #[doc = r""]
2207 #[doc = r" # Safety"]
2208 #[doc = r""]
2209 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2210 #[doc = r" that may race with any existing instances, for example by only"]
2211 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2212 #[doc = r" original peripheral and using critical sections to coordinate"]
2213 #[doc = r" access between multiple new instances."]
2214 #[doc = r""]
2215 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2216 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2217 #[doc = r" no stolen instances are passed to such software."]
2218 pub unsafe fn steal() -> Self {
2219 Self {
2220 _marker: PhantomData,
2221 }
2222 }
2223}
2224impl Deref for PCNT {
2225 type Target = pcnt::RegisterBlock;
2226 #[inline(always)]
2227 fn deref(&self) -> &Self::Target {
2228 unsafe { &*Self::PTR }
2229 }
2230}
2231impl core::fmt::Debug for PCNT {
2232 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2233 f.debug_struct("PCNT").finish()
2234 }
2235}
2236#[doc = "Pulse Count Controller"]
2237pub mod pcnt;
2238#[doc = "PCR Peripheral"]
2239pub struct PCR {
2240 _marker: PhantomData<*const ()>,
2241}
2242unsafe impl Send for PCR {}
2243impl PCR {
2244 #[doc = r"Pointer to the register block"]
2245 pub const PTR: *const pcr::RegisterBlock = 0x6009_6000 as *const _;
2246 #[doc = r"Return the pointer to the register block"]
2247 #[inline(always)]
2248 pub const fn ptr() -> *const pcr::RegisterBlock {
2249 Self::PTR
2250 }
2251 #[doc = r" Steal an instance of this peripheral"]
2252 #[doc = r""]
2253 #[doc = r" # Safety"]
2254 #[doc = r""]
2255 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2256 #[doc = r" that may race with any existing instances, for example by only"]
2257 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2258 #[doc = r" original peripheral and using critical sections to coordinate"]
2259 #[doc = r" access between multiple new instances."]
2260 #[doc = r""]
2261 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2262 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2263 #[doc = r" no stolen instances are passed to such software."]
2264 pub unsafe fn steal() -> Self {
2265 Self {
2266 _marker: PhantomData,
2267 }
2268 }
2269}
2270impl Deref for PCR {
2271 type Target = pcr::RegisterBlock;
2272 #[inline(always)]
2273 fn deref(&self) -> &Self::Target {
2274 unsafe { &*Self::PTR }
2275 }
2276}
2277impl core::fmt::Debug for PCR {
2278 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2279 f.debug_struct("PCR").finish()
2280 }
2281}
2282#[doc = "PCR Peripheral"]
2283pub mod pcr;
2284#[doc = "PMU Peripheral"]
2285pub struct PMU {
2286 _marker: PhantomData<*const ()>,
2287}
2288unsafe impl Send for PMU {}
2289impl PMU {
2290 #[doc = r"Pointer to the register block"]
2291 pub const PTR: *const pmu::RegisterBlock = 0x600b_0000 as *const _;
2292 #[doc = r"Return the pointer to the register block"]
2293 #[inline(always)]
2294 pub const fn ptr() -> *const pmu::RegisterBlock {
2295 Self::PTR
2296 }
2297 #[doc = r" Steal an instance of this peripheral"]
2298 #[doc = r""]
2299 #[doc = r" # Safety"]
2300 #[doc = r""]
2301 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2302 #[doc = r" that may race with any existing instances, for example by only"]
2303 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2304 #[doc = r" original peripheral and using critical sections to coordinate"]
2305 #[doc = r" access between multiple new instances."]
2306 #[doc = r""]
2307 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2308 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2309 #[doc = r" no stolen instances are passed to such software."]
2310 pub unsafe fn steal() -> Self {
2311 Self {
2312 _marker: PhantomData,
2313 }
2314 }
2315}
2316impl Deref for PMU {
2317 type Target = pmu::RegisterBlock;
2318 #[inline(always)]
2319 fn deref(&self) -> &Self::Target {
2320 unsafe { &*Self::PTR }
2321 }
2322}
2323impl core::fmt::Debug for PMU {
2324 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2325 f.debug_struct("PMU").finish()
2326 }
2327}
2328#[doc = "PMU Peripheral"]
2329pub mod pmu;
2330#[doc = "Remote Control"]
2331pub struct RMT {
2332 _marker: PhantomData<*const ()>,
2333}
2334unsafe impl Send for RMT {}
2335impl RMT {
2336 #[doc = r"Pointer to the register block"]
2337 pub const PTR: *const rmt::RegisterBlock = 0x6000_6000 as *const _;
2338 #[doc = r"Return the pointer to the register block"]
2339 #[inline(always)]
2340 pub const fn ptr() -> *const rmt::RegisterBlock {
2341 Self::PTR
2342 }
2343 #[doc = r" Steal an instance of this peripheral"]
2344 #[doc = r""]
2345 #[doc = r" # Safety"]
2346 #[doc = r""]
2347 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2348 #[doc = r" that may race with any existing instances, for example by only"]
2349 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2350 #[doc = r" original peripheral and using critical sections to coordinate"]
2351 #[doc = r" access between multiple new instances."]
2352 #[doc = r""]
2353 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2354 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2355 #[doc = r" no stolen instances are passed to such software."]
2356 pub unsafe fn steal() -> Self {
2357 Self {
2358 _marker: PhantomData,
2359 }
2360 }
2361}
2362impl Deref for RMT {
2363 type Target = rmt::RegisterBlock;
2364 #[inline(always)]
2365 fn deref(&self) -> &Self::Target {
2366 unsafe { &*Self::PTR }
2367 }
2368}
2369impl core::fmt::Debug for RMT {
2370 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2371 f.debug_struct("RMT").finish()
2372 }
2373}
2374#[doc = "Remote Control"]
2375pub mod rmt;
2376#[doc = "Hardware Random Number Generator"]
2377pub struct RNG {
2378 _marker: PhantomData<*const ()>,
2379}
2380unsafe impl Send for RNG {}
2381impl RNG {
2382 #[doc = r"Pointer to the register block"]
2383 pub const PTR: *const rng::RegisterBlock = 0x600b_2800 as *const _;
2384 #[doc = r"Return the pointer to the register block"]
2385 #[inline(always)]
2386 pub const fn ptr() -> *const rng::RegisterBlock {
2387 Self::PTR
2388 }
2389 #[doc = r" Steal an instance of this peripheral"]
2390 #[doc = r""]
2391 #[doc = r" # Safety"]
2392 #[doc = r""]
2393 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2394 #[doc = r" that may race with any existing instances, for example by only"]
2395 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2396 #[doc = r" original peripheral and using critical sections to coordinate"]
2397 #[doc = r" access between multiple new instances."]
2398 #[doc = r""]
2399 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2400 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2401 #[doc = r" no stolen instances are passed to such software."]
2402 pub unsafe fn steal() -> Self {
2403 Self {
2404 _marker: PhantomData,
2405 }
2406 }
2407}
2408impl Deref for RNG {
2409 type Target = rng::RegisterBlock;
2410 #[inline(always)]
2411 fn deref(&self) -> &Self::Target {
2412 unsafe { &*Self::PTR }
2413 }
2414}
2415impl core::fmt::Debug for RNG {
2416 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2417 f.debug_struct("RNG").finish()
2418 }
2419}
2420#[doc = "Hardware Random Number Generator"]
2421pub mod rng;
2422#[doc = "RSA (Rivest Shamir Adleman) Accelerator"]
2423pub struct RSA {
2424 _marker: PhantomData<*const ()>,
2425}
2426unsafe impl Send for RSA {}
2427impl RSA {
2428 #[doc = r"Pointer to the register block"]
2429 pub const PTR: *const rsa::RegisterBlock = 0x6008_a000 as *const _;
2430 #[doc = r"Return the pointer to the register block"]
2431 #[inline(always)]
2432 pub const fn ptr() -> *const rsa::RegisterBlock {
2433 Self::PTR
2434 }
2435 #[doc = r" Steal an instance of this peripheral"]
2436 #[doc = r""]
2437 #[doc = r" # Safety"]
2438 #[doc = r""]
2439 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2440 #[doc = r" that may race with any existing instances, for example by only"]
2441 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2442 #[doc = r" original peripheral and using critical sections to coordinate"]
2443 #[doc = r" access between multiple new instances."]
2444 #[doc = r""]
2445 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2446 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2447 #[doc = r" no stolen instances are passed to such software."]
2448 pub unsafe fn steal() -> Self {
2449 Self {
2450 _marker: PhantomData,
2451 }
2452 }
2453}
2454impl Deref for RSA {
2455 type Target = rsa::RegisterBlock;
2456 #[inline(always)]
2457 fn deref(&self) -> &Self::Target {
2458 unsafe { &*Self::PTR }
2459 }
2460}
2461impl core::fmt::Debug for RSA {
2462 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2463 f.debug_struct("RSA").finish()
2464 }
2465}
2466#[doc = "RSA (Rivest Shamir Adleman) Accelerator"]
2467pub mod rsa;
2468#[doc = "SHA (Secure Hash Algorithm) Accelerator"]
2469pub struct SHA {
2470 _marker: PhantomData<*const ()>,
2471}
2472unsafe impl Send for SHA {}
2473impl SHA {
2474 #[doc = r"Pointer to the register block"]
2475 pub const PTR: *const sha::RegisterBlock = 0x6008_9000 as *const _;
2476 #[doc = r"Return the pointer to the register block"]
2477 #[inline(always)]
2478 pub const fn ptr() -> *const sha::RegisterBlock {
2479 Self::PTR
2480 }
2481 #[doc = r" Steal an instance of this peripheral"]
2482 #[doc = r""]
2483 #[doc = r" # Safety"]
2484 #[doc = r""]
2485 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2486 #[doc = r" that may race with any existing instances, for example by only"]
2487 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2488 #[doc = r" original peripheral and using critical sections to coordinate"]
2489 #[doc = r" access between multiple new instances."]
2490 #[doc = r""]
2491 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2492 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2493 #[doc = r" no stolen instances are passed to such software."]
2494 pub unsafe fn steal() -> Self {
2495 Self {
2496 _marker: PhantomData,
2497 }
2498 }
2499}
2500impl Deref for SHA {
2501 type Target = sha::RegisterBlock;
2502 #[inline(always)]
2503 fn deref(&self) -> &Self::Target {
2504 unsafe { &*Self::PTR }
2505 }
2506}
2507impl core::fmt::Debug for SHA {
2508 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2509 f.debug_struct("SHA").finish()
2510 }
2511}
2512#[doc = "SHA (Secure Hash Algorithm) Accelerator"]
2513pub mod sha;
2514#[doc = "SLCHOST Peripheral"]
2515pub struct SLCHOST {
2516 _marker: PhantomData<*const ()>,
2517}
2518unsafe impl Send for SLCHOST {}
2519impl SLCHOST {
2520 #[doc = r"Pointer to the register block"]
2521 pub const PTR: *const slchost::RegisterBlock = 0x6001_8000 as *const _;
2522 #[doc = r"Return the pointer to the register block"]
2523 #[inline(always)]
2524 pub const fn ptr() -> *const slchost::RegisterBlock {
2525 Self::PTR
2526 }
2527 #[doc = r" Steal an instance of this peripheral"]
2528 #[doc = r""]
2529 #[doc = r" # Safety"]
2530 #[doc = r""]
2531 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2532 #[doc = r" that may race with any existing instances, for example by only"]
2533 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2534 #[doc = r" original peripheral and using critical sections to coordinate"]
2535 #[doc = r" access between multiple new instances."]
2536 #[doc = r""]
2537 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2538 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2539 #[doc = r" no stolen instances are passed to such software."]
2540 pub unsafe fn steal() -> Self {
2541 Self {
2542 _marker: PhantomData,
2543 }
2544 }
2545}
2546impl Deref for SLCHOST {
2547 type Target = slchost::RegisterBlock;
2548 #[inline(always)]
2549 fn deref(&self) -> &Self::Target {
2550 unsafe { &*Self::PTR }
2551 }
2552}
2553impl core::fmt::Debug for SLCHOST {
2554 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2555 f.debug_struct("SLCHOST").finish()
2556 }
2557}
2558#[doc = "SLCHOST Peripheral"]
2559pub mod slchost;
2560#[doc = "Event Task Matrix"]
2561pub struct SOC_ETM {
2562 _marker: PhantomData<*const ()>,
2563}
2564unsafe impl Send for SOC_ETM {}
2565impl SOC_ETM {
2566 #[doc = r"Pointer to the register block"]
2567 pub const PTR: *const soc_etm::RegisterBlock = 0x6001_3000 as *const _;
2568 #[doc = r"Return the pointer to the register block"]
2569 #[inline(always)]
2570 pub const fn ptr() -> *const soc_etm::RegisterBlock {
2571 Self::PTR
2572 }
2573 #[doc = r" Steal an instance of this peripheral"]
2574 #[doc = r""]
2575 #[doc = r" # Safety"]
2576 #[doc = r""]
2577 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2578 #[doc = r" that may race with any existing instances, for example by only"]
2579 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2580 #[doc = r" original peripheral and using critical sections to coordinate"]
2581 #[doc = r" access between multiple new instances."]
2582 #[doc = r""]
2583 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2584 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2585 #[doc = r" no stolen instances are passed to such software."]
2586 pub unsafe fn steal() -> Self {
2587 Self {
2588 _marker: PhantomData,
2589 }
2590 }
2591}
2592impl Deref for SOC_ETM {
2593 type Target = soc_etm::RegisterBlock;
2594 #[inline(always)]
2595 fn deref(&self) -> &Self::Target {
2596 unsafe { &*Self::PTR }
2597 }
2598}
2599impl core::fmt::Debug for SOC_ETM {
2600 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2601 f.debug_struct("SOC_ETM").finish()
2602 }
2603}
2604#[doc = "Event Task Matrix"]
2605pub mod soc_etm;
2606#[doc = "SPI (Serial Peripheral Interface) Controller 0"]
2607pub struct SPI0 {
2608 _marker: PhantomData<*const ()>,
2609}
2610unsafe impl Send for SPI0 {}
2611impl SPI0 {
2612 #[doc = r"Pointer to the register block"]
2613 pub const PTR: *const spi0::RegisterBlock = 0x6000_2000 as *const _;
2614 #[doc = r"Return the pointer to the register block"]
2615 #[inline(always)]
2616 pub const fn ptr() -> *const spi0::RegisterBlock {
2617 Self::PTR
2618 }
2619 #[doc = r" Steal an instance of this peripheral"]
2620 #[doc = r""]
2621 #[doc = r" # Safety"]
2622 #[doc = r""]
2623 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2624 #[doc = r" that may race with any existing instances, for example by only"]
2625 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2626 #[doc = r" original peripheral and using critical sections to coordinate"]
2627 #[doc = r" access between multiple new instances."]
2628 #[doc = r""]
2629 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2630 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2631 #[doc = r" no stolen instances are passed to such software."]
2632 pub unsafe fn steal() -> Self {
2633 Self {
2634 _marker: PhantomData,
2635 }
2636 }
2637}
2638impl Deref for SPI0 {
2639 type Target = spi0::RegisterBlock;
2640 #[inline(always)]
2641 fn deref(&self) -> &Self::Target {
2642 unsafe { &*Self::PTR }
2643 }
2644}
2645impl core::fmt::Debug for SPI0 {
2646 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2647 f.debug_struct("SPI0").finish()
2648 }
2649}
2650#[doc = "SPI (Serial Peripheral Interface) Controller 0"]
2651pub mod spi0;
2652#[doc = "SPI (Serial Peripheral Interface) Controller 1"]
2653pub struct SPI1 {
2654 _marker: PhantomData<*const ()>,
2655}
2656unsafe impl Send for SPI1 {}
2657impl SPI1 {
2658 #[doc = r"Pointer to the register block"]
2659 pub const PTR: *const spi1::RegisterBlock = 0x6000_3000 as *const _;
2660 #[doc = r"Return the pointer to the register block"]
2661 #[inline(always)]
2662 pub const fn ptr() -> *const spi1::RegisterBlock {
2663 Self::PTR
2664 }
2665 #[doc = r" Steal an instance of this peripheral"]
2666 #[doc = r""]
2667 #[doc = r" # Safety"]
2668 #[doc = r""]
2669 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2670 #[doc = r" that may race with any existing instances, for example by only"]
2671 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2672 #[doc = r" original peripheral and using critical sections to coordinate"]
2673 #[doc = r" access between multiple new instances."]
2674 #[doc = r""]
2675 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2676 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2677 #[doc = r" no stolen instances are passed to such software."]
2678 pub unsafe fn steal() -> Self {
2679 Self {
2680 _marker: PhantomData,
2681 }
2682 }
2683}
2684impl Deref for SPI1 {
2685 type Target = spi1::RegisterBlock;
2686 #[inline(always)]
2687 fn deref(&self) -> &Self::Target {
2688 unsafe { &*Self::PTR }
2689 }
2690}
2691impl core::fmt::Debug for SPI1 {
2692 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2693 f.debug_struct("SPI1").finish()
2694 }
2695}
2696#[doc = "SPI (Serial Peripheral Interface) Controller 1"]
2697pub mod spi1;
2698#[doc = "SPI (Serial Peripheral Interface) Controller 2"]
2699pub struct SPI2 {
2700 _marker: PhantomData<*const ()>,
2701}
2702unsafe impl Send for SPI2 {}
2703impl SPI2 {
2704 #[doc = r"Pointer to the register block"]
2705 pub const PTR: *const spi2::RegisterBlock = 0x6008_1000 as *const _;
2706 #[doc = r"Return the pointer to the register block"]
2707 #[inline(always)]
2708 pub const fn ptr() -> *const spi2::RegisterBlock {
2709 Self::PTR
2710 }
2711 #[doc = r" Steal an instance of this peripheral"]
2712 #[doc = r""]
2713 #[doc = r" # Safety"]
2714 #[doc = r""]
2715 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2716 #[doc = r" that may race with any existing instances, for example by only"]
2717 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2718 #[doc = r" original peripheral and using critical sections to coordinate"]
2719 #[doc = r" access between multiple new instances."]
2720 #[doc = r""]
2721 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2722 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2723 #[doc = r" no stolen instances are passed to such software."]
2724 pub unsafe fn steal() -> Self {
2725 Self {
2726 _marker: PhantomData,
2727 }
2728 }
2729}
2730impl Deref for SPI2 {
2731 type Target = spi2::RegisterBlock;
2732 #[inline(always)]
2733 fn deref(&self) -> &Self::Target {
2734 unsafe { &*Self::PTR }
2735 }
2736}
2737impl core::fmt::Debug for SPI2 {
2738 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2739 f.debug_struct("SPI2").finish()
2740 }
2741}
2742#[doc = "SPI (Serial Peripheral Interface) Controller 2"]
2743pub mod spi2;
2744#[doc = "System Timer"]
2745pub struct SYSTIMER {
2746 _marker: PhantomData<*const ()>,
2747}
2748unsafe impl Send for SYSTIMER {}
2749impl SYSTIMER {
2750 #[doc = r"Pointer to the register block"]
2751 pub const PTR: *const systimer::RegisterBlock = 0x6000_a000 as *const _;
2752 #[doc = r"Return the pointer to the register block"]
2753 #[inline(always)]
2754 pub const fn ptr() -> *const systimer::RegisterBlock {
2755 Self::PTR
2756 }
2757 #[doc = r" Steal an instance of this peripheral"]
2758 #[doc = r""]
2759 #[doc = r" # Safety"]
2760 #[doc = r""]
2761 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2762 #[doc = r" that may race with any existing instances, for example by only"]
2763 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2764 #[doc = r" original peripheral and using critical sections to coordinate"]
2765 #[doc = r" access between multiple new instances."]
2766 #[doc = r""]
2767 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2768 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2769 #[doc = r" no stolen instances are passed to such software."]
2770 pub unsafe fn steal() -> Self {
2771 Self {
2772 _marker: PhantomData,
2773 }
2774 }
2775}
2776impl Deref for SYSTIMER {
2777 type Target = systimer::RegisterBlock;
2778 #[inline(always)]
2779 fn deref(&self) -> &Self::Target {
2780 unsafe { &*Self::PTR }
2781 }
2782}
2783impl core::fmt::Debug for SYSTIMER {
2784 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2785 f.debug_struct("SYSTIMER").finish()
2786 }
2787}
2788#[doc = "System Timer"]
2789pub mod systimer;
2790#[doc = "TEE Peripheral"]
2791pub struct TEE {
2792 _marker: PhantomData<*const ()>,
2793}
2794unsafe impl Send for TEE {}
2795impl TEE {
2796 #[doc = r"Pointer to the register block"]
2797 pub const PTR: *const tee::RegisterBlock = 0x6009_8000 as *const _;
2798 #[doc = r"Return the pointer to the register block"]
2799 #[inline(always)]
2800 pub const fn ptr() -> *const tee::RegisterBlock {
2801 Self::PTR
2802 }
2803 #[doc = r" Steal an instance of this peripheral"]
2804 #[doc = r""]
2805 #[doc = r" # Safety"]
2806 #[doc = r""]
2807 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2808 #[doc = r" that may race with any existing instances, for example by only"]
2809 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2810 #[doc = r" original peripheral and using critical sections to coordinate"]
2811 #[doc = r" access between multiple new instances."]
2812 #[doc = r""]
2813 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2814 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2815 #[doc = r" no stolen instances are passed to such software."]
2816 pub unsafe fn steal() -> Self {
2817 Self {
2818 _marker: PhantomData,
2819 }
2820 }
2821}
2822impl Deref for TEE {
2823 type Target = tee::RegisterBlock;
2824 #[inline(always)]
2825 fn deref(&self) -> &Self::Target {
2826 unsafe { &*Self::PTR }
2827 }
2828}
2829impl core::fmt::Debug for TEE {
2830 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2831 f.debug_struct("TEE").finish()
2832 }
2833}
2834#[doc = "TEE Peripheral"]
2835pub mod tee;
2836#[doc = "Timer Group 0"]
2837pub struct TIMG0 {
2838 _marker: PhantomData<*const ()>,
2839}
2840unsafe impl Send for TIMG0 {}
2841impl TIMG0 {
2842 #[doc = r"Pointer to the register block"]
2843 pub const PTR: *const timg0::RegisterBlock = 0x6000_8000 as *const _;
2844 #[doc = r"Return the pointer to the register block"]
2845 #[inline(always)]
2846 pub const fn ptr() -> *const timg0::RegisterBlock {
2847 Self::PTR
2848 }
2849 #[doc = r" Steal an instance of this peripheral"]
2850 #[doc = r""]
2851 #[doc = r" # Safety"]
2852 #[doc = r""]
2853 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2854 #[doc = r" that may race with any existing instances, for example by only"]
2855 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2856 #[doc = r" original peripheral and using critical sections to coordinate"]
2857 #[doc = r" access between multiple new instances."]
2858 #[doc = r""]
2859 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2860 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2861 #[doc = r" no stolen instances are passed to such software."]
2862 pub unsafe fn steal() -> Self {
2863 Self {
2864 _marker: PhantomData,
2865 }
2866 }
2867}
2868impl Deref for TIMG0 {
2869 type Target = timg0::RegisterBlock;
2870 #[inline(always)]
2871 fn deref(&self) -> &Self::Target {
2872 unsafe { &*Self::PTR }
2873 }
2874}
2875impl core::fmt::Debug for TIMG0 {
2876 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2877 f.debug_struct("TIMG0").finish()
2878 }
2879}
2880#[doc = "Timer Group 0"]
2881pub mod timg0;
2882#[doc = "Timer Group 1"]
2883pub struct TIMG1 {
2884 _marker: PhantomData<*const ()>,
2885}
2886unsafe impl Send for TIMG1 {}
2887impl TIMG1 {
2888 #[doc = r"Pointer to the register block"]
2889 pub const PTR: *const timg0::RegisterBlock = 0x6000_9000 as *const _;
2890 #[doc = r"Return the pointer to the register block"]
2891 #[inline(always)]
2892 pub const fn ptr() -> *const timg0::RegisterBlock {
2893 Self::PTR
2894 }
2895 #[doc = r" Steal an instance of this peripheral"]
2896 #[doc = r""]
2897 #[doc = r" # Safety"]
2898 #[doc = r""]
2899 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2900 #[doc = r" that may race with any existing instances, for example by only"]
2901 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2902 #[doc = r" original peripheral and using critical sections to coordinate"]
2903 #[doc = r" access between multiple new instances."]
2904 #[doc = r""]
2905 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2906 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2907 #[doc = r" no stolen instances are passed to such software."]
2908 pub unsafe fn steal() -> Self {
2909 Self {
2910 _marker: PhantomData,
2911 }
2912 }
2913}
2914impl Deref for TIMG1 {
2915 type Target = timg0::RegisterBlock;
2916 #[inline(always)]
2917 fn deref(&self) -> &Self::Target {
2918 unsafe { &*Self::PTR }
2919 }
2920}
2921impl core::fmt::Debug for TIMG1 {
2922 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2923 f.debug_struct("TIMG1").finish()
2924 }
2925}
2926#[doc = "Timer Group 1"]
2927pub use self::timg0 as timg1;
2928#[doc = "RISC-V Trace Encoder"]
2929pub struct TRACE {
2930 _marker: PhantomData<*const ()>,
2931}
2932unsafe impl Send for TRACE {}
2933impl TRACE {
2934 #[doc = r"Pointer to the register block"]
2935 pub const PTR: *const trace::RegisterBlock = 0x600c_0000 as *const _;
2936 #[doc = r"Return the pointer to the register block"]
2937 #[inline(always)]
2938 pub const fn ptr() -> *const trace::RegisterBlock {
2939 Self::PTR
2940 }
2941 #[doc = r" Steal an instance of this peripheral"]
2942 #[doc = r""]
2943 #[doc = r" # Safety"]
2944 #[doc = r""]
2945 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2946 #[doc = r" that may race with any existing instances, for example by only"]
2947 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2948 #[doc = r" original peripheral and using critical sections to coordinate"]
2949 #[doc = r" access between multiple new instances."]
2950 #[doc = r""]
2951 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2952 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2953 #[doc = r" no stolen instances are passed to such software."]
2954 pub unsafe fn steal() -> Self {
2955 Self {
2956 _marker: PhantomData,
2957 }
2958 }
2959}
2960impl Deref for TRACE {
2961 type Target = trace::RegisterBlock;
2962 #[inline(always)]
2963 fn deref(&self) -> &Self::Target {
2964 unsafe { &*Self::PTR }
2965 }
2966}
2967impl core::fmt::Debug for TRACE {
2968 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2969 f.debug_struct("TRACE").finish()
2970 }
2971}
2972#[doc = "RISC-V Trace Encoder"]
2973pub mod trace;
2974#[doc = "Two-Wire Automotive Interface"]
2975pub struct TWAI0 {
2976 _marker: PhantomData<*const ()>,
2977}
2978unsafe impl Send for TWAI0 {}
2979impl TWAI0 {
2980 #[doc = r"Pointer to the register block"]
2981 pub const PTR: *const twai0::RegisterBlock = 0x6000_b000 as *const _;
2982 #[doc = r"Return the pointer to the register block"]
2983 #[inline(always)]
2984 pub const fn ptr() -> *const twai0::RegisterBlock {
2985 Self::PTR
2986 }
2987 #[doc = r" Steal an instance of this peripheral"]
2988 #[doc = r""]
2989 #[doc = r" # Safety"]
2990 #[doc = r""]
2991 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2992 #[doc = r" that may race with any existing instances, for example by only"]
2993 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2994 #[doc = r" original peripheral and using critical sections to coordinate"]
2995 #[doc = r" access between multiple new instances."]
2996 #[doc = r""]
2997 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2998 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2999 #[doc = r" no stolen instances are passed to such software."]
3000 pub unsafe fn steal() -> Self {
3001 Self {
3002 _marker: PhantomData,
3003 }
3004 }
3005}
3006impl Deref for TWAI0 {
3007 type Target = twai0::RegisterBlock;
3008 #[inline(always)]
3009 fn deref(&self) -> &Self::Target {
3010 unsafe { &*Self::PTR }
3011 }
3012}
3013impl core::fmt::Debug for TWAI0 {
3014 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3015 f.debug_struct("TWAI0").finish()
3016 }
3017}
3018#[doc = "Two-Wire Automotive Interface"]
3019pub mod twai0;
3020#[doc = "Two-Wire Automotive Interface"]
3021pub struct TWAI1 {
3022 _marker: PhantomData<*const ()>,
3023}
3024unsafe impl Send for TWAI1 {}
3025impl TWAI1 {
3026 #[doc = r"Pointer to the register block"]
3027 pub const PTR: *const twai0::RegisterBlock = 0x6000_d000 as *const _;
3028 #[doc = r"Return the pointer to the register block"]
3029 #[inline(always)]
3030 pub const fn ptr() -> *const twai0::RegisterBlock {
3031 Self::PTR
3032 }
3033 #[doc = r" Steal an instance of this peripheral"]
3034 #[doc = r""]
3035 #[doc = r" # Safety"]
3036 #[doc = r""]
3037 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3038 #[doc = r" that may race with any existing instances, for example by only"]
3039 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3040 #[doc = r" original peripheral and using critical sections to coordinate"]
3041 #[doc = r" access between multiple new instances."]
3042 #[doc = r""]
3043 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3044 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3045 #[doc = r" no stolen instances are passed to such software."]
3046 pub unsafe fn steal() -> Self {
3047 Self {
3048 _marker: PhantomData,
3049 }
3050 }
3051}
3052impl Deref for TWAI1 {
3053 type Target = twai0::RegisterBlock;
3054 #[inline(always)]
3055 fn deref(&self) -> &Self::Target {
3056 unsafe { &*Self::PTR }
3057 }
3058}
3059impl core::fmt::Debug for TWAI1 {
3060 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3061 f.debug_struct("TWAI1").finish()
3062 }
3063}
3064#[doc = "Two-Wire Automotive Interface"]
3065pub use self::twai0 as twai1;
3066#[doc = "UART (Universal Asynchronous Receiver-Transmitter) Controller 0"]
3067pub struct UART0 {
3068 _marker: PhantomData<*const ()>,
3069}
3070unsafe impl Send for UART0 {}
3071impl UART0 {
3072 #[doc = r"Pointer to the register block"]
3073 pub const PTR: *const uart0::RegisterBlock = 0x6000_0000 as *const _;
3074 #[doc = r"Return the pointer to the register block"]
3075 #[inline(always)]
3076 pub const fn ptr() -> *const uart0::RegisterBlock {
3077 Self::PTR
3078 }
3079 #[doc = r" Steal an instance of this peripheral"]
3080 #[doc = r""]
3081 #[doc = r" # Safety"]
3082 #[doc = r""]
3083 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3084 #[doc = r" that may race with any existing instances, for example by only"]
3085 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3086 #[doc = r" original peripheral and using critical sections to coordinate"]
3087 #[doc = r" access between multiple new instances."]
3088 #[doc = r""]
3089 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3090 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3091 #[doc = r" no stolen instances are passed to such software."]
3092 pub unsafe fn steal() -> Self {
3093 Self {
3094 _marker: PhantomData,
3095 }
3096 }
3097}
3098impl Deref for UART0 {
3099 type Target = uart0::RegisterBlock;
3100 #[inline(always)]
3101 fn deref(&self) -> &Self::Target {
3102 unsafe { &*Self::PTR }
3103 }
3104}
3105impl core::fmt::Debug for UART0 {
3106 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3107 f.debug_struct("UART0").finish()
3108 }
3109}
3110#[doc = "UART (Universal Asynchronous Receiver-Transmitter) Controller 0"]
3111pub mod uart0;
3112#[doc = "UART (Universal Asynchronous Receiver-Transmitter) Controller 1"]
3113pub struct UART1 {
3114 _marker: PhantomData<*const ()>,
3115}
3116unsafe impl Send for UART1 {}
3117impl UART1 {
3118 #[doc = r"Pointer to the register block"]
3119 pub const PTR: *const uart0::RegisterBlock = 0x6000_1000 as *const _;
3120 #[doc = r"Return the pointer to the register block"]
3121 #[inline(always)]
3122 pub const fn ptr() -> *const uart0::RegisterBlock {
3123 Self::PTR
3124 }
3125 #[doc = r" Steal an instance of this peripheral"]
3126 #[doc = r""]
3127 #[doc = r" # Safety"]
3128 #[doc = r""]
3129 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3130 #[doc = r" that may race with any existing instances, for example by only"]
3131 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3132 #[doc = r" original peripheral and using critical sections to coordinate"]
3133 #[doc = r" access between multiple new instances."]
3134 #[doc = r""]
3135 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3136 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3137 #[doc = r" no stolen instances are passed to such software."]
3138 pub unsafe fn steal() -> Self {
3139 Self {
3140 _marker: PhantomData,
3141 }
3142 }
3143}
3144impl Deref for UART1 {
3145 type Target = uart0::RegisterBlock;
3146 #[inline(always)]
3147 fn deref(&self) -> &Self::Target {
3148 unsafe { &*Self::PTR }
3149 }
3150}
3151impl core::fmt::Debug for UART1 {
3152 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3153 f.debug_struct("UART1").finish()
3154 }
3155}
3156#[doc = "UART (Universal Asynchronous Receiver-Transmitter) Controller 1"]
3157pub use self::uart0 as uart1;
3158#[doc = "Universal Host Controller Interface 0"]
3159pub struct UHCI0 {
3160 _marker: PhantomData<*const ()>,
3161}
3162unsafe impl Send for UHCI0 {}
3163impl UHCI0 {
3164 #[doc = r"Pointer to the register block"]
3165 pub const PTR: *const uhci0::RegisterBlock = 0x6000_5000 as *const _;
3166 #[doc = r"Return the pointer to the register block"]
3167 #[inline(always)]
3168 pub const fn ptr() -> *const uhci0::RegisterBlock {
3169 Self::PTR
3170 }
3171 #[doc = r" Steal an instance of this peripheral"]
3172 #[doc = r""]
3173 #[doc = r" # Safety"]
3174 #[doc = r""]
3175 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3176 #[doc = r" that may race with any existing instances, for example by only"]
3177 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3178 #[doc = r" original peripheral and using critical sections to coordinate"]
3179 #[doc = r" access between multiple new instances."]
3180 #[doc = r""]
3181 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3182 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3183 #[doc = r" no stolen instances are passed to such software."]
3184 pub unsafe fn steal() -> Self {
3185 Self {
3186 _marker: PhantomData,
3187 }
3188 }
3189}
3190impl Deref for UHCI0 {
3191 type Target = uhci0::RegisterBlock;
3192 #[inline(always)]
3193 fn deref(&self) -> &Self::Target {
3194 unsafe { &*Self::PTR }
3195 }
3196}
3197impl core::fmt::Debug for UHCI0 {
3198 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3199 f.debug_struct("UHCI0").finish()
3200 }
3201}
3202#[doc = "Universal Host Controller Interface 0"]
3203pub mod uhci0;
3204#[doc = "Full-speed USB Serial/JTAG Controller"]
3205pub struct USB_DEVICE {
3206 _marker: PhantomData<*const ()>,
3207}
3208unsafe impl Send for USB_DEVICE {}
3209impl USB_DEVICE {
3210 #[doc = r"Pointer to the register block"]
3211 pub const PTR: *const usb_device::RegisterBlock = 0x6000_f000 as *const _;
3212 #[doc = r"Return the pointer to the register block"]
3213 #[inline(always)]
3214 pub const fn ptr() -> *const usb_device::RegisterBlock {
3215 Self::PTR
3216 }
3217 #[doc = r" Steal an instance of this peripheral"]
3218 #[doc = r""]
3219 #[doc = r" # Safety"]
3220 #[doc = r""]
3221 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3222 #[doc = r" that may race with any existing instances, for example by only"]
3223 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3224 #[doc = r" original peripheral and using critical sections to coordinate"]
3225 #[doc = r" access between multiple new instances."]
3226 #[doc = r""]
3227 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3228 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3229 #[doc = r" no stolen instances are passed to such software."]
3230 pub unsafe fn steal() -> Self {
3231 Self {
3232 _marker: PhantomData,
3233 }
3234 }
3235}
3236impl Deref for USB_DEVICE {
3237 type Target = usb_device::RegisterBlock;
3238 #[inline(always)]
3239 fn deref(&self) -> &Self::Target {
3240 unsafe { &*Self::PTR }
3241 }
3242}
3243impl core::fmt::Debug for USB_DEVICE {
3244 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3245 f.debug_struct("USB_DEVICE").finish()
3246 }
3247}
3248#[doc = "Full-speed USB Serial/JTAG Controller"]
3249pub mod usb_device;
3250#[doc = "Core Local Interrupts"]
3251pub struct CLINT {
3252 _marker: PhantomData<*const ()>,
3253}
3254unsafe impl Send for CLINT {}
3255impl CLINT {
3256 #[doc = r"Pointer to the register block"]
3257 pub const PTR: *const clint::RegisterBlock = 0x2000_0000 as *const _;
3258 #[doc = r"Return the pointer to the register block"]
3259 #[inline(always)]
3260 pub const fn ptr() -> *const clint::RegisterBlock {
3261 Self::PTR
3262 }
3263 #[doc = r" Steal an instance of this peripheral"]
3264 #[doc = r""]
3265 #[doc = r" # Safety"]
3266 #[doc = r""]
3267 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3268 #[doc = r" that may race with any existing instances, for example by only"]
3269 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3270 #[doc = r" original peripheral and using critical sections to coordinate"]
3271 #[doc = r" access between multiple new instances."]
3272 #[doc = r""]
3273 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3274 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3275 #[doc = r" no stolen instances are passed to such software."]
3276 pub unsafe fn steal() -> Self {
3277 Self {
3278 _marker: PhantomData,
3279 }
3280 }
3281}
3282impl Deref for CLINT {
3283 type Target = clint::RegisterBlock;
3284 #[inline(always)]
3285 fn deref(&self) -> &Self::Target {
3286 unsafe { &*Self::PTR }
3287 }
3288}
3289impl core::fmt::Debug for CLINT {
3290 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3291 f.debug_struct("CLINT").finish()
3292 }
3293}
3294#[doc = "Core Local Interrupts"]
3295pub mod clint;
3296#[doc = "PLIC Peripheral"]
3297pub struct PLIC_MX {
3298 _marker: PhantomData<*const ()>,
3299}
3300unsafe impl Send for PLIC_MX {}
3301impl PLIC_MX {
3302 #[doc = r"Pointer to the register block"]
3303 pub const PTR: *const plic_mx::RegisterBlock = 0x2000_1000 as *const _;
3304 #[doc = r"Return the pointer to the register block"]
3305 #[inline(always)]
3306 pub const fn ptr() -> *const plic_mx::RegisterBlock {
3307 Self::PTR
3308 }
3309 #[doc = r" Steal an instance of this peripheral"]
3310 #[doc = r""]
3311 #[doc = r" # Safety"]
3312 #[doc = r""]
3313 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3314 #[doc = r" that may race with any existing instances, for example by only"]
3315 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3316 #[doc = r" original peripheral and using critical sections to coordinate"]
3317 #[doc = r" access between multiple new instances."]
3318 #[doc = r""]
3319 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3320 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3321 #[doc = r" no stolen instances are passed to such software."]
3322 pub unsafe fn steal() -> Self {
3323 Self {
3324 _marker: PhantomData,
3325 }
3326 }
3327}
3328impl Deref for PLIC_MX {
3329 type Target = plic_mx::RegisterBlock;
3330 #[inline(always)]
3331 fn deref(&self) -> &Self::Target {
3332 unsafe { &*Self::PTR }
3333 }
3334}
3335impl core::fmt::Debug for PLIC_MX {
3336 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3337 f.debug_struct("PLIC_MX").finish()
3338 }
3339}
3340#[doc = "PLIC Peripheral"]
3341pub mod plic_mx;
3342#[doc = "PLIC Peripheral"]
3343pub struct PLIC_UX {
3344 _marker: PhantomData<*const ()>,
3345}
3346unsafe impl Send for PLIC_UX {}
3347impl PLIC_UX {
3348 #[doc = r"Pointer to the register block"]
3349 pub const PTR: *const plic_ux::RegisterBlock = 0x2000_1400 as *const _;
3350 #[doc = r"Return the pointer to the register block"]
3351 #[inline(always)]
3352 pub const fn ptr() -> *const plic_ux::RegisterBlock {
3353 Self::PTR
3354 }
3355 #[doc = r" Steal an instance of this peripheral"]
3356 #[doc = r""]
3357 #[doc = r" # Safety"]
3358 #[doc = r""]
3359 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3360 #[doc = r" that may race with any existing instances, for example by only"]
3361 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3362 #[doc = r" original peripheral and using critical sections to coordinate"]
3363 #[doc = r" access between multiple new instances."]
3364 #[doc = r""]
3365 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3366 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3367 #[doc = r" no stolen instances are passed to such software."]
3368 pub unsafe fn steal() -> Self {
3369 Self {
3370 _marker: PhantomData,
3371 }
3372 }
3373}
3374impl Deref for PLIC_UX {
3375 type Target = plic_ux::RegisterBlock;
3376 #[inline(always)]
3377 fn deref(&self) -> &Self::Target {
3378 unsafe { &*Self::PTR }
3379 }
3380}
3381impl core::fmt::Debug for PLIC_UX {
3382 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3383 f.debug_struct("PLIC_UX").finish()
3384 }
3385}
3386#[doc = "PLIC Peripheral"]
3387pub mod plic_ux;
3388#[doc = "I2C_ANA_MST Peripheral"]
3389pub struct I2C_ANA_MST {
3390 _marker: PhantomData<*const ()>,
3391}
3392unsafe impl Send for I2C_ANA_MST {}
3393impl I2C_ANA_MST {
3394 #[doc = r"Pointer to the register block"]
3395 pub const PTR: *const i2c_ana_mst::RegisterBlock = 0x600a_f800 as *const _;
3396 #[doc = r"Return the pointer to the register block"]
3397 #[inline(always)]
3398 pub const fn ptr() -> *const i2c_ana_mst::RegisterBlock {
3399 Self::PTR
3400 }
3401 #[doc = r" Steal an instance of this peripheral"]
3402 #[doc = r""]
3403 #[doc = r" # Safety"]
3404 #[doc = r""]
3405 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3406 #[doc = r" that may race with any existing instances, for example by only"]
3407 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3408 #[doc = r" original peripheral and using critical sections to coordinate"]
3409 #[doc = r" access between multiple new instances."]
3410 #[doc = r""]
3411 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3412 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3413 #[doc = r" no stolen instances are passed to such software."]
3414 pub unsafe fn steal() -> Self {
3415 Self {
3416 _marker: PhantomData,
3417 }
3418 }
3419}
3420impl Deref for I2C_ANA_MST {
3421 type Target = i2c_ana_mst::RegisterBlock;
3422 #[inline(always)]
3423 fn deref(&self) -> &Self::Target {
3424 unsafe { &*Self::PTR }
3425 }
3426}
3427impl core::fmt::Debug for I2C_ANA_MST {
3428 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3429 f.debug_struct("I2C_ANA_MST").finish()
3430 }
3431}
3432#[doc = "I2C_ANA_MST Peripheral"]
3433pub mod i2c_ana_mst;
3434#[doc = "SDIO SLC"]
3435pub struct SLC {
3436 _marker: PhantomData<*const ()>,
3437}
3438unsafe impl Send for SLC {}
3439impl SLC {
3440 #[doc = r"Pointer to the register block"]
3441 pub const PTR: *const slc::RegisterBlock = 0x6001_7000 as *const _;
3442 #[doc = r"Return the pointer to the register block"]
3443 #[inline(always)]
3444 pub const fn ptr() -> *const slc::RegisterBlock {
3445 Self::PTR
3446 }
3447 #[doc = r" Steal an instance of this peripheral"]
3448 #[doc = r""]
3449 #[doc = r" # Safety"]
3450 #[doc = r""]
3451 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3452 #[doc = r" that may race with any existing instances, for example by only"]
3453 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3454 #[doc = r" original peripheral and using critical sections to coordinate"]
3455 #[doc = r" access between multiple new instances."]
3456 #[doc = r""]
3457 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3458 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3459 #[doc = r" no stolen instances are passed to such software."]
3460 pub unsafe fn steal() -> Self {
3461 Self {
3462 _marker: PhantomData,
3463 }
3464 }
3465}
3466impl Deref for SLC {
3467 type Target = slc::RegisterBlock;
3468 #[inline(always)]
3469 fn deref(&self) -> &Self::Target {
3470 unsafe { &*Self::PTR }
3471 }
3472}
3473impl core::fmt::Debug for SLC {
3474 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3475 f.debug_struct("SLC").finish()
3476 }
3477}
3478#[doc = "SDIO SLC"]
3479pub mod slc;
3480#[no_mangle]
3481static mut DEVICE_PERIPHERALS: bool = false;
3482#[doc = r" All the peripherals."]
3483#[allow(non_snake_case)]
3484pub struct Peripherals {
3485 #[doc = "AES"]
3486 pub AES: AES,
3487 #[doc = "APB_SARADC"]
3488 pub APB_SARADC: APB_SARADC,
3489 #[doc = "ASSIST_DEBUG"]
3490 pub ASSIST_DEBUG: ASSIST_DEBUG,
3491 #[doc = "ATOMIC"]
3492 pub ATOMIC: ATOMIC,
3493 #[doc = "DMA"]
3494 pub DMA: DMA,
3495 #[doc = "DS"]
3496 pub DS: DS,
3497 #[doc = "ECC"]
3498 pub ECC: ECC,
3499 #[doc = "EFUSE"]
3500 pub EFUSE: EFUSE,
3501 #[doc = "EXTMEM"]
3502 pub EXTMEM: EXTMEM,
3503 #[doc = "GPIO"]
3504 pub GPIO: GPIO,
3505 #[doc = "GPIO_SD"]
3506 pub GPIO_SD: GPIO_SD,
3507 #[doc = "HINF"]
3508 pub HINF: HINF,
3509 #[doc = "HMAC"]
3510 pub HMAC: HMAC,
3511 #[doc = "HP_APM"]
3512 pub HP_APM: HP_APM,
3513 #[doc = "HP_SYS"]
3514 pub HP_SYS: HP_SYS,
3515 #[doc = "I2C0"]
3516 pub I2C0: I2C0,
3517 #[doc = "I2S0"]
3518 pub I2S0: I2S0,
3519 #[doc = "IEEE802154"]
3520 pub IEEE802154: IEEE802154,
3521 #[doc = "INTERRUPT_CORE0"]
3522 pub INTERRUPT_CORE0: INTERRUPT_CORE0,
3523 #[doc = "INTPRI"]
3524 pub INTPRI: INTPRI,
3525 #[doc = "IO_MUX"]
3526 pub IO_MUX: IO_MUX,
3527 #[doc = "LEDC"]
3528 pub LEDC: LEDC,
3529 #[doc = "LP_PERI"]
3530 pub LP_PERI: LP_PERI,
3531 #[doc = "LP_ANA"]
3532 pub LP_ANA: LP_ANA,
3533 #[doc = "LP_AON"]
3534 pub LP_AON: LP_AON,
3535 #[doc = "LP_APM"]
3536 pub LP_APM: LP_APM,
3537 #[doc = "LP_APM0"]
3538 pub LP_APM0: LP_APM0,
3539 #[doc = "LP_CLKRST"]
3540 pub LP_CLKRST: LP_CLKRST,
3541 #[doc = "LP_I2C0"]
3542 pub LP_I2C0: LP_I2C0,
3543 #[doc = "LP_I2C_ANA_MST"]
3544 pub LP_I2C_ANA_MST: LP_I2C_ANA_MST,
3545 #[doc = "LP_IO"]
3546 pub LP_IO: LP_IO,
3547 #[doc = "LP_TEE"]
3548 pub LP_TEE: LP_TEE,
3549 #[doc = "LP_TIMER"]
3550 pub LP_TIMER: LP_TIMER,
3551 #[doc = "LP_UART"]
3552 pub LP_UART: LP_UART,
3553 #[doc = "LP_WDT"]
3554 pub LP_WDT: LP_WDT,
3555 #[doc = "MCPWM0"]
3556 pub MCPWM0: MCPWM0,
3557 #[doc = "MEM_MONITOR"]
3558 pub MEM_MONITOR: MEM_MONITOR,
3559 #[doc = "MODEM_LPCON"]
3560 pub MODEM_LPCON: MODEM_LPCON,
3561 #[doc = "MODEM_SYSCON"]
3562 pub MODEM_SYSCON: MODEM_SYSCON,
3563 #[doc = "OTP_DEBUG"]
3564 pub OTP_DEBUG: OTP_DEBUG,
3565 #[doc = "PARL_IO"]
3566 pub PARL_IO: PARL_IO,
3567 #[doc = "PAU"]
3568 pub PAU: PAU,
3569 #[doc = "PCNT"]
3570 pub PCNT: PCNT,
3571 #[doc = "PCR"]
3572 pub PCR: PCR,
3573 #[doc = "PMU"]
3574 pub PMU: PMU,
3575 #[doc = "RMT"]
3576 pub RMT: RMT,
3577 #[doc = "RNG"]
3578 pub RNG: RNG,
3579 #[doc = "RSA"]
3580 pub RSA: RSA,
3581 #[doc = "SHA"]
3582 pub SHA: SHA,
3583 #[doc = "SLCHOST"]
3584 pub SLCHOST: SLCHOST,
3585 #[doc = "SOC_ETM"]
3586 pub SOC_ETM: SOC_ETM,
3587 #[doc = "SPI0"]
3588 pub SPI0: SPI0,
3589 #[doc = "SPI1"]
3590 pub SPI1: SPI1,
3591 #[doc = "SPI2"]
3592 pub SPI2: SPI2,
3593 #[doc = "SYSTIMER"]
3594 pub SYSTIMER: SYSTIMER,
3595 #[doc = "TEE"]
3596 pub TEE: TEE,
3597 #[doc = "TIMG0"]
3598 pub TIMG0: TIMG0,
3599 #[doc = "TIMG1"]
3600 pub TIMG1: TIMG1,
3601 #[doc = "TRACE"]
3602 pub TRACE: TRACE,
3603 #[doc = "TWAI0"]
3604 pub TWAI0: TWAI0,
3605 #[doc = "TWAI1"]
3606 pub TWAI1: TWAI1,
3607 #[doc = "UART0"]
3608 pub UART0: UART0,
3609 #[doc = "UART1"]
3610 pub UART1: UART1,
3611 #[doc = "UHCI0"]
3612 pub UHCI0: UHCI0,
3613 #[doc = "USB_DEVICE"]
3614 pub USB_DEVICE: USB_DEVICE,
3615 #[doc = "CLINT"]
3616 pub CLINT: CLINT,
3617 #[doc = "PLIC_MX"]
3618 pub PLIC_MX: PLIC_MX,
3619 #[doc = "PLIC_UX"]
3620 pub PLIC_UX: PLIC_UX,
3621 #[doc = "I2C_ANA_MST"]
3622 pub I2C_ANA_MST: I2C_ANA_MST,
3623 #[doc = "SLC"]
3624 pub SLC: SLC,
3625}
3626impl Peripherals {
3627 #[doc = r" Returns all the peripherals *once*."]
3628 #[cfg(feature = "critical-section")]
3629 #[inline]
3630 pub fn take() -> Option<Self> {
3631 critical_section::with(|_| {
3632 if unsafe { DEVICE_PERIPHERALS } {
3633 return None;
3634 }
3635 Some(unsafe { Peripherals::steal() })
3636 })
3637 }
3638 #[doc = r" Unchecked version of `Peripherals::take`."]
3639 #[doc = r""]
3640 #[doc = r" # Safety"]
3641 #[doc = r""]
3642 #[doc = r" Each of the returned peripherals must be used at most once."]
3643 #[inline]
3644 pub unsafe fn steal() -> Self {
3645 DEVICE_PERIPHERALS = true;
3646 Peripherals {
3647 AES: AES::steal(),
3648 APB_SARADC: APB_SARADC::steal(),
3649 ASSIST_DEBUG: ASSIST_DEBUG::steal(),
3650 ATOMIC: ATOMIC::steal(),
3651 DMA: DMA::steal(),
3652 DS: DS::steal(),
3653 ECC: ECC::steal(),
3654 EFUSE: EFUSE::steal(),
3655 EXTMEM: EXTMEM::steal(),
3656 GPIO: GPIO::steal(),
3657 GPIO_SD: GPIO_SD::steal(),
3658 HINF: HINF::steal(),
3659 HMAC: HMAC::steal(),
3660 HP_APM: HP_APM::steal(),
3661 HP_SYS: HP_SYS::steal(),
3662 I2C0: I2C0::steal(),
3663 I2S0: I2S0::steal(),
3664 IEEE802154: IEEE802154::steal(),
3665 INTERRUPT_CORE0: INTERRUPT_CORE0::steal(),
3666 INTPRI: INTPRI::steal(),
3667 IO_MUX: IO_MUX::steal(),
3668 LEDC: LEDC::steal(),
3669 LP_PERI: LP_PERI::steal(),
3670 LP_ANA: LP_ANA::steal(),
3671 LP_AON: LP_AON::steal(),
3672 LP_APM: LP_APM::steal(),
3673 LP_APM0: LP_APM0::steal(),
3674 LP_CLKRST: LP_CLKRST::steal(),
3675 LP_I2C0: LP_I2C0::steal(),
3676 LP_I2C_ANA_MST: LP_I2C_ANA_MST::steal(),
3677 LP_IO: LP_IO::steal(),
3678 LP_TEE: LP_TEE::steal(),
3679 LP_TIMER: LP_TIMER::steal(),
3680 LP_UART: LP_UART::steal(),
3681 LP_WDT: LP_WDT::steal(),
3682 MCPWM0: MCPWM0::steal(),
3683 MEM_MONITOR: MEM_MONITOR::steal(),
3684 MODEM_LPCON: MODEM_LPCON::steal(),
3685 MODEM_SYSCON: MODEM_SYSCON::steal(),
3686 OTP_DEBUG: OTP_DEBUG::steal(),
3687 PARL_IO: PARL_IO::steal(),
3688 PAU: PAU::steal(),
3689 PCNT: PCNT::steal(),
3690 PCR: PCR::steal(),
3691 PMU: PMU::steal(),
3692 RMT: RMT::steal(),
3693 RNG: RNG::steal(),
3694 RSA: RSA::steal(),
3695 SHA: SHA::steal(),
3696 SLCHOST: SLCHOST::steal(),
3697 SOC_ETM: SOC_ETM::steal(),
3698 SPI0: SPI0::steal(),
3699 SPI1: SPI1::steal(),
3700 SPI2: SPI2::steal(),
3701 SYSTIMER: SYSTIMER::steal(),
3702 TEE: TEE::steal(),
3703 TIMG0: TIMG0::steal(),
3704 TIMG1: TIMG1::steal(),
3705 TRACE: TRACE::steal(),
3706 TWAI0: TWAI0::steal(),
3707 TWAI1: TWAI1::steal(),
3708 UART0: UART0::steal(),
3709 UART1: UART1::steal(),
3710 UHCI0: UHCI0::steal(),
3711 USB_DEVICE: USB_DEVICE::steal(),
3712 CLINT: CLINT::steal(),
3713 PLIC_MX: PLIC_MX::steal(),
3714 PLIC_UX: PLIC_UX::steal(),
3715 I2C_ANA_MST: I2C_ANA_MST::steal(),
3716 SLC: SLC::steal(),
3717 }
3718 }
3719}