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