1#![doc = "Peripheral access API for EFM32PG12B500F1024GL125 microcontrollers (generated using svd2rust v0.24.0 ( ))\n\nYou can find an overview of the generated API [here].\n\nAPI features to be included in the [next]
2svd2rust 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.24.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"]
3#![deny(const_err)]
4#![deny(dead_code)]
5#![deny(improper_ctypes)]
6#![deny(missing_docs)]
7#![deny(no_mangle_generic_items)]
8#![deny(non_shorthand_field_patterns)]
9#![deny(overflowing_literals)]
10#![deny(path_statements)]
11#![deny(patterns_in_fns_without_body)]
12#![deny(private_in_public)]
13#![deny(unconditional_recursion)]
14#![deny(unused_allocation)]
15#![deny(unused_comparisons)]
16#![deny(unused_parens)]
17#![deny(while_true)]
18#![allow(non_camel_case_types)]
19#![allow(non_snake_case)]
20#![no_std]
21use core::marker::PhantomData;
22use core::ops::Deref;
23#[doc = r"Number available in the NVIC for configuring priority"]
24pub const NVIC_PRIO_BITS: u8 = 3;
25#[cfg(feature = "rt")]
26pub use self::Interrupt as interrupt;
27pub use cortex_m::peripheral::Peripherals as CorePeripherals;
28pub use cortex_m::peripheral::{CBP, CPUID, DCB, DWT, FPB, FPU, ITM, MPU, NVIC, SCB, SYST, TPIU};
29#[cfg(feature = "rt")]
30pub use cortex_m_rt::interrupt;
31#[allow(unused_imports)]
32use generic::*;
33#[doc = r"Common register and bit access and modify traits"]
34pub mod generic;
35#[cfg(feature = "rt")]
36extern "C" {
37 fn EMU();
38 fn WDOG0();
39 fn WDOG1();
40 fn LDMA();
41 fn GPIO_EVEN();
42 fn TIMER0();
43 fn USART0_RX();
44 fn USART0_TX();
45 fn ACMP0();
46 fn ADC0();
47 fn IDAC0();
48 fn I2C0();
49 fn GPIO_ODD();
50 fn TIMER1();
51 fn USART1_RX();
52 fn USART1_TX();
53 fn LEUART0();
54 fn PCNT0();
55 fn CMU();
56 fn MSC();
57 fn CRYPTO0();
58 fn LETIMER0();
59 fn RTCC();
60 fn CRYOTIMER();
61 fn FPUEH();
62 fn SMU();
63 fn WTIMER0();
64 fn WTIMER1();
65 fn PCNT1();
66 fn PCNT2();
67 fn USART2_RX();
68 fn USART2_TX();
69 fn I2C1();
70 fn USART3_RX();
71 fn USART3_TX();
72 fn VDAC0();
73 fn CSEN();
74 fn LESENSE();
75 fn CRYPTO1();
76 fn TRNG0();
77}
78#[doc(hidden)]
79pub union Vector {
80 _handler: unsafe extern "C" fn(),
81 _reserved: u32,
82}
83#[cfg(feature = "rt")]
84#[doc(hidden)]
85#[link_section = ".vector_table.interrupts"]
86#[no_mangle]
87pub static __INTERRUPTS: [Vector; 50] = [
88 Vector { _handler: EMU },
89 Vector { _reserved: 0 },
90 Vector { _handler: WDOG0 },
91 Vector { _handler: WDOG1 },
92 Vector { _reserved: 0 },
93 Vector { _reserved: 0 },
94 Vector { _reserved: 0 },
95 Vector { _reserved: 0 },
96 Vector { _reserved: 0 },
97 Vector { _handler: LDMA },
98 Vector {
99 _handler: GPIO_EVEN,
100 },
101 Vector { _handler: TIMER0 },
102 Vector {
103 _handler: USART0_RX,
104 },
105 Vector {
106 _handler: USART0_TX,
107 },
108 Vector { _handler: ACMP0 },
109 Vector { _handler: ADC0 },
110 Vector { _handler: IDAC0 },
111 Vector { _handler: I2C0 },
112 Vector { _handler: GPIO_ODD },
113 Vector { _handler: TIMER1 },
114 Vector {
115 _handler: USART1_RX,
116 },
117 Vector {
118 _handler: USART1_TX,
119 },
120 Vector { _handler: LEUART0 },
121 Vector { _handler: PCNT0 },
122 Vector { _handler: CMU },
123 Vector { _handler: MSC },
124 Vector { _handler: CRYPTO0 },
125 Vector { _handler: LETIMER0 },
126 Vector { _reserved: 0 },
127 Vector { _reserved: 0 },
128 Vector { _handler: RTCC },
129 Vector { _reserved: 0 },
130 Vector {
131 _handler: CRYOTIMER,
132 },
133 Vector { _reserved: 0 },
134 Vector { _handler: FPUEH },
135 Vector { _handler: SMU },
136 Vector { _handler: WTIMER0 },
137 Vector { _handler: WTIMER1 },
138 Vector { _handler: PCNT1 },
139 Vector { _handler: PCNT2 },
140 Vector {
141 _handler: USART2_RX,
142 },
143 Vector {
144 _handler: USART2_TX,
145 },
146 Vector { _handler: I2C1 },
147 Vector {
148 _handler: USART3_RX,
149 },
150 Vector {
151 _handler: USART3_TX,
152 },
153 Vector { _handler: VDAC0 },
154 Vector { _handler: CSEN },
155 Vector { _handler: LESENSE },
156 Vector { _handler: CRYPTO1 },
157 Vector { _handler: TRNG0 },
158];
159#[doc = r"Enumeration of all the interrupts."]
160#[derive(Copy, Clone, Debug, PartialEq, Eq)]
161#[repr(u16)]
162pub enum Interrupt {
163 #[doc = "0 - EMU"]
164 EMU = 0,
165 #[doc = "2 - WDOG0"]
166 WDOG0 = 2,
167 #[doc = "3 - WDOG1"]
168 WDOG1 = 3,
169 #[doc = "9 - LDMA"]
170 LDMA = 9,
171 #[doc = "10 - GPIO_EVEN"]
172 GPIO_EVEN = 10,
173 #[doc = "11 - TIMER0"]
174 TIMER0 = 11,
175 #[doc = "12 - USART0_RX"]
176 USART0_RX = 12,
177 #[doc = "13 - USART0_TX"]
178 USART0_TX = 13,
179 #[doc = "14 - ACMP0"]
180 ACMP0 = 14,
181 #[doc = "15 - ADC0"]
182 ADC0 = 15,
183 #[doc = "16 - IDAC0"]
184 IDAC0 = 16,
185 #[doc = "17 - I2C0"]
186 I2C0 = 17,
187 #[doc = "18 - GPIO_ODD"]
188 GPIO_ODD = 18,
189 #[doc = "19 - TIMER1"]
190 TIMER1 = 19,
191 #[doc = "20 - USART1_RX"]
192 USART1_RX = 20,
193 #[doc = "21 - USART1_TX"]
194 USART1_TX = 21,
195 #[doc = "22 - LEUART0"]
196 LEUART0 = 22,
197 #[doc = "23 - PCNT0"]
198 PCNT0 = 23,
199 #[doc = "24 - CMU"]
200 CMU = 24,
201 #[doc = "25 - MSC"]
202 MSC = 25,
203 #[doc = "26 - CRYPTO0"]
204 CRYPTO0 = 26,
205 #[doc = "27 - LETIMER0"]
206 LETIMER0 = 27,
207 #[doc = "30 - RTCC"]
208 RTCC = 30,
209 #[doc = "32 - CRYOTIMER"]
210 CRYOTIMER = 32,
211 #[doc = "34 - FPUEH"]
212 FPUEH = 34,
213 #[doc = "35 - SMU"]
214 SMU = 35,
215 #[doc = "36 - WTIMER0"]
216 WTIMER0 = 36,
217 #[doc = "37 - WTIMER1"]
218 WTIMER1 = 37,
219 #[doc = "38 - PCNT1"]
220 PCNT1 = 38,
221 #[doc = "39 - PCNT2"]
222 PCNT2 = 39,
223 #[doc = "40 - USART2_RX"]
224 USART2_RX = 40,
225 #[doc = "41 - USART2_TX"]
226 USART2_TX = 41,
227 #[doc = "42 - I2C1"]
228 I2C1 = 42,
229 #[doc = "43 - USART3_RX"]
230 USART3_RX = 43,
231 #[doc = "44 - USART3_TX"]
232 USART3_TX = 44,
233 #[doc = "45 - VDAC0"]
234 VDAC0 = 45,
235 #[doc = "46 - CSEN"]
236 CSEN = 46,
237 #[doc = "47 - LESENSE"]
238 LESENSE = 47,
239 #[doc = "48 - CRYPTO1"]
240 CRYPTO1 = 48,
241 #[doc = "49 - TRNG0"]
242 TRNG0 = 49,
243}
244unsafe impl cortex_m::interrupt::InterruptNumber for Interrupt {
245 #[inline(always)]
246 fn number(self) -> u16 {
247 self as u16
248 }
249}
250#[doc = "MSC"]
251pub struct MSC {
252 _marker: PhantomData<*const ()>,
253}
254unsafe impl Send for MSC {}
255impl MSC {
256 #[doc = r"Pointer to the register block"]
257 pub const PTR: *const msc::RegisterBlock = 0x400e_0000 as *const _;
258 #[doc = r"Return the pointer to the register block"]
259 #[inline(always)]
260 pub const fn ptr() -> *const msc::RegisterBlock {
261 Self::PTR
262 }
263}
264impl Deref for MSC {
265 type Target = msc::RegisterBlock;
266 #[inline(always)]
267 fn deref(&self) -> &Self::Target {
268 unsafe { &*Self::PTR }
269 }
270}
271impl core::fmt::Debug for MSC {
272 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
273 f.debug_struct("MSC").finish()
274 }
275}
276#[doc = "MSC"]
277pub mod msc;
278#[doc = "EMU"]
279pub struct EMU {
280 _marker: PhantomData<*const ()>,
281}
282unsafe impl Send for EMU {}
283impl EMU {
284 #[doc = r"Pointer to the register block"]
285 pub const PTR: *const emu::RegisterBlock = 0x400e_3000 as *const _;
286 #[doc = r"Return the pointer to the register block"]
287 #[inline(always)]
288 pub const fn ptr() -> *const emu::RegisterBlock {
289 Self::PTR
290 }
291}
292impl Deref for EMU {
293 type Target = emu::RegisterBlock;
294 #[inline(always)]
295 fn deref(&self) -> &Self::Target {
296 unsafe { &*Self::PTR }
297 }
298}
299impl core::fmt::Debug for EMU {
300 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
301 f.debug_struct("EMU").finish()
302 }
303}
304#[doc = "EMU"]
305pub mod emu;
306#[doc = "RMU"]
307pub struct RMU {
308 _marker: PhantomData<*const ()>,
309}
310unsafe impl Send for RMU {}
311impl RMU {
312 #[doc = r"Pointer to the register block"]
313 pub const PTR: *const rmu::RegisterBlock = 0x400e_5000 as *const _;
314 #[doc = r"Return the pointer to the register block"]
315 #[inline(always)]
316 pub const fn ptr() -> *const rmu::RegisterBlock {
317 Self::PTR
318 }
319}
320impl Deref for RMU {
321 type Target = rmu::RegisterBlock;
322 #[inline(always)]
323 fn deref(&self) -> &Self::Target {
324 unsafe { &*Self::PTR }
325 }
326}
327impl core::fmt::Debug for RMU {
328 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
329 f.debug_struct("RMU").finish()
330 }
331}
332#[doc = "RMU"]
333pub mod rmu;
334#[doc = "CMU"]
335pub struct CMU {
336 _marker: PhantomData<*const ()>,
337}
338unsafe impl Send for CMU {}
339impl CMU {
340 #[doc = r"Pointer to the register block"]
341 pub const PTR: *const cmu::RegisterBlock = 0x400e_4000 as *const _;
342 #[doc = r"Return the pointer to the register block"]
343 #[inline(always)]
344 pub const fn ptr() -> *const cmu::RegisterBlock {
345 Self::PTR
346 }
347}
348impl Deref for CMU {
349 type Target = cmu::RegisterBlock;
350 #[inline(always)]
351 fn deref(&self) -> &Self::Target {
352 unsafe { &*Self::PTR }
353 }
354}
355impl core::fmt::Debug for CMU {
356 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
357 f.debug_struct("CMU").finish()
358 }
359}
360#[doc = "CMU"]
361pub mod cmu;
362#[doc = "CRYPTO0"]
363pub struct CRYPTO0 {
364 _marker: PhantomData<*const ()>,
365}
366unsafe impl Send for CRYPTO0 {}
367impl CRYPTO0 {
368 #[doc = r"Pointer to the register block"]
369 pub const PTR: *const crypto0::RegisterBlock = 0x400f_0000 as *const _;
370 #[doc = r"Return the pointer to the register block"]
371 #[inline(always)]
372 pub const fn ptr() -> *const crypto0::RegisterBlock {
373 Self::PTR
374 }
375}
376impl Deref for CRYPTO0 {
377 type Target = crypto0::RegisterBlock;
378 #[inline(always)]
379 fn deref(&self) -> &Self::Target {
380 unsafe { &*Self::PTR }
381 }
382}
383impl core::fmt::Debug for CRYPTO0 {
384 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
385 f.debug_struct("CRYPTO0").finish()
386 }
387}
388#[doc = "CRYPTO0"]
389pub mod crypto0;
390#[doc = "CRYPTO1"]
391pub struct CRYPTO1 {
392 _marker: PhantomData<*const ()>,
393}
394unsafe impl Send for CRYPTO1 {}
395impl CRYPTO1 {
396 #[doc = r"Pointer to the register block"]
397 pub const PTR: *const crypto1::RegisterBlock = 0x400f_0400 as *const _;
398 #[doc = r"Return the pointer to the register block"]
399 #[inline(always)]
400 pub const fn ptr() -> *const crypto1::RegisterBlock {
401 Self::PTR
402 }
403}
404impl Deref for CRYPTO1 {
405 type Target = crypto1::RegisterBlock;
406 #[inline(always)]
407 fn deref(&self) -> &Self::Target {
408 unsafe { &*Self::PTR }
409 }
410}
411impl core::fmt::Debug for CRYPTO1 {
412 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
413 f.debug_struct("CRYPTO1").finish()
414 }
415}
416#[doc = "CRYPTO1"]
417pub mod crypto1;
418#[doc = "GPIO"]
419pub struct GPIO {
420 _marker: PhantomData<*const ()>,
421}
422unsafe impl Send for GPIO {}
423impl GPIO {
424 #[doc = r"Pointer to the register block"]
425 pub const PTR: *const gpio::RegisterBlock = 0x4000_a000 as *const _;
426 #[doc = r"Return the pointer to the register block"]
427 #[inline(always)]
428 pub const fn ptr() -> *const gpio::RegisterBlock {
429 Self::PTR
430 }
431}
432impl Deref for GPIO {
433 type Target = gpio::RegisterBlock;
434 #[inline(always)]
435 fn deref(&self) -> &Self::Target {
436 unsafe { &*Self::PTR }
437 }
438}
439impl core::fmt::Debug for GPIO {
440 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
441 f.debug_struct("GPIO").finish()
442 }
443}
444#[doc = "GPIO"]
445pub mod gpio;
446#[doc = "PRS"]
447pub struct PRS {
448 _marker: PhantomData<*const ()>,
449}
450unsafe impl Send for PRS {}
451impl PRS {
452 #[doc = r"Pointer to the register block"]
453 pub const PTR: *const prs::RegisterBlock = 0x400e_6000 as *const _;
454 #[doc = r"Return the pointer to the register block"]
455 #[inline(always)]
456 pub const fn ptr() -> *const prs::RegisterBlock {
457 Self::PTR
458 }
459}
460impl Deref for PRS {
461 type Target = prs::RegisterBlock;
462 #[inline(always)]
463 fn deref(&self) -> &Self::Target {
464 unsafe { &*Self::PTR }
465 }
466}
467impl core::fmt::Debug for PRS {
468 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
469 f.debug_struct("PRS").finish()
470 }
471}
472#[doc = "PRS"]
473pub mod prs;
474#[doc = "LDMA"]
475pub struct LDMA {
476 _marker: PhantomData<*const ()>,
477}
478unsafe impl Send for LDMA {}
479impl LDMA {
480 #[doc = r"Pointer to the register block"]
481 pub const PTR: *const ldma::RegisterBlock = 0x400e_2000 as *const _;
482 #[doc = r"Return the pointer to the register block"]
483 #[inline(always)]
484 pub const fn ptr() -> *const ldma::RegisterBlock {
485 Self::PTR
486 }
487}
488impl Deref for LDMA {
489 type Target = ldma::RegisterBlock;
490 #[inline(always)]
491 fn deref(&self) -> &Self::Target {
492 unsafe { &*Self::PTR }
493 }
494}
495impl core::fmt::Debug for LDMA {
496 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
497 f.debug_struct("LDMA").finish()
498 }
499}
500#[doc = "LDMA"]
501pub mod ldma;
502#[doc = "FPUEH"]
503pub struct FPUEH {
504 _marker: PhantomData<*const ()>,
505}
506unsafe impl Send for FPUEH {}
507impl FPUEH {
508 #[doc = r"Pointer to the register block"]
509 pub const PTR: *const fpueh::RegisterBlock = 0x400e_1000 as *const _;
510 #[doc = r"Return the pointer to the register block"]
511 #[inline(always)]
512 pub const fn ptr() -> *const fpueh::RegisterBlock {
513 Self::PTR
514 }
515}
516impl Deref for FPUEH {
517 type Target = fpueh::RegisterBlock;
518 #[inline(always)]
519 fn deref(&self) -> &Self::Target {
520 unsafe { &*Self::PTR }
521 }
522}
523impl core::fmt::Debug for FPUEH {
524 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
525 f.debug_struct("FPUEH").finish()
526 }
527}
528#[doc = "FPUEH"]
529pub mod fpueh;
530#[doc = "GPCRC"]
531pub struct GPCRC {
532 _marker: PhantomData<*const ()>,
533}
534unsafe impl Send for GPCRC {}
535impl GPCRC {
536 #[doc = r"Pointer to the register block"]
537 pub const PTR: *const gpcrc::RegisterBlock = 0x4001_c000 as *const _;
538 #[doc = r"Return the pointer to the register block"]
539 #[inline(always)]
540 pub const fn ptr() -> *const gpcrc::RegisterBlock {
541 Self::PTR
542 }
543}
544impl Deref for GPCRC {
545 type Target = gpcrc::RegisterBlock;
546 #[inline(always)]
547 fn deref(&self) -> &Self::Target {
548 unsafe { &*Self::PTR }
549 }
550}
551impl core::fmt::Debug for GPCRC {
552 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
553 f.debug_struct("GPCRC").finish()
554 }
555}
556#[doc = "GPCRC"]
557pub mod gpcrc;
558#[doc = "TIMER0"]
559pub struct TIMER0 {
560 _marker: PhantomData<*const ()>,
561}
562unsafe impl Send for TIMER0 {}
563impl TIMER0 {
564 #[doc = r"Pointer to the register block"]
565 pub const PTR: *const timer0::RegisterBlock = 0x4001_8000 as *const _;
566 #[doc = r"Return the pointer to the register block"]
567 #[inline(always)]
568 pub const fn ptr() -> *const timer0::RegisterBlock {
569 Self::PTR
570 }
571}
572impl Deref for TIMER0 {
573 type Target = timer0::RegisterBlock;
574 #[inline(always)]
575 fn deref(&self) -> &Self::Target {
576 unsafe { &*Self::PTR }
577 }
578}
579impl core::fmt::Debug for TIMER0 {
580 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
581 f.debug_struct("TIMER0").finish()
582 }
583}
584#[doc = "TIMER0"]
585pub mod timer0;
586#[doc = "TIMER1"]
587pub struct TIMER1 {
588 _marker: PhantomData<*const ()>,
589}
590unsafe impl Send for TIMER1 {}
591impl TIMER1 {
592 #[doc = r"Pointer to the register block"]
593 pub const PTR: *const timer1::RegisterBlock = 0x4001_8400 as *const _;
594 #[doc = r"Return the pointer to the register block"]
595 #[inline(always)]
596 pub const fn ptr() -> *const timer1::RegisterBlock {
597 Self::PTR
598 }
599}
600impl Deref for TIMER1 {
601 type Target = timer1::RegisterBlock;
602 #[inline(always)]
603 fn deref(&self) -> &Self::Target {
604 unsafe { &*Self::PTR }
605 }
606}
607impl core::fmt::Debug for TIMER1 {
608 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
609 f.debug_struct("TIMER1").finish()
610 }
611}
612#[doc = "TIMER1"]
613pub mod timer1;
614#[doc = "WTIMER0"]
615pub struct WTIMER0 {
616 _marker: PhantomData<*const ()>,
617}
618unsafe impl Send for WTIMER0 {}
619impl WTIMER0 {
620 #[doc = r"Pointer to the register block"]
621 pub const PTR: *const wtimer0::RegisterBlock = 0x4001_a000 as *const _;
622 #[doc = r"Return the pointer to the register block"]
623 #[inline(always)]
624 pub const fn ptr() -> *const wtimer0::RegisterBlock {
625 Self::PTR
626 }
627}
628impl Deref for WTIMER0 {
629 type Target = wtimer0::RegisterBlock;
630 #[inline(always)]
631 fn deref(&self) -> &Self::Target {
632 unsafe { &*Self::PTR }
633 }
634}
635impl core::fmt::Debug for WTIMER0 {
636 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
637 f.debug_struct("WTIMER0").finish()
638 }
639}
640#[doc = "WTIMER0"]
641pub mod wtimer0;
642#[doc = "WTIMER1"]
643pub struct WTIMER1 {
644 _marker: PhantomData<*const ()>,
645}
646unsafe impl Send for WTIMER1 {}
647impl WTIMER1 {
648 #[doc = r"Pointer to the register block"]
649 pub const PTR: *const wtimer1::RegisterBlock = 0x4001_a400 as *const _;
650 #[doc = r"Return the pointer to the register block"]
651 #[inline(always)]
652 pub const fn ptr() -> *const wtimer1::RegisterBlock {
653 Self::PTR
654 }
655}
656impl Deref for WTIMER1 {
657 type Target = wtimer1::RegisterBlock;
658 #[inline(always)]
659 fn deref(&self) -> &Self::Target {
660 unsafe { &*Self::PTR }
661 }
662}
663impl core::fmt::Debug for WTIMER1 {
664 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
665 f.debug_struct("WTIMER1").finish()
666 }
667}
668#[doc = "WTIMER1"]
669pub mod wtimer1;
670#[doc = "USART0"]
671pub struct USART0 {
672 _marker: PhantomData<*const ()>,
673}
674unsafe impl Send for USART0 {}
675impl USART0 {
676 #[doc = r"Pointer to the register block"]
677 pub const PTR: *const usart0::RegisterBlock = 0x4001_0000 as *const _;
678 #[doc = r"Return the pointer to the register block"]
679 #[inline(always)]
680 pub const fn ptr() -> *const usart0::RegisterBlock {
681 Self::PTR
682 }
683}
684impl Deref for USART0 {
685 type Target = usart0::RegisterBlock;
686 #[inline(always)]
687 fn deref(&self) -> &Self::Target {
688 unsafe { &*Self::PTR }
689 }
690}
691impl core::fmt::Debug for USART0 {
692 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
693 f.debug_struct("USART0").finish()
694 }
695}
696#[doc = "USART0"]
697pub mod usart0;
698#[doc = "USART1"]
699pub struct USART1 {
700 _marker: PhantomData<*const ()>,
701}
702unsafe impl Send for USART1 {}
703impl USART1 {
704 #[doc = r"Pointer to the register block"]
705 pub const PTR: *const usart1::RegisterBlock = 0x4001_0400 as *const _;
706 #[doc = r"Return the pointer to the register block"]
707 #[inline(always)]
708 pub const fn ptr() -> *const usart1::RegisterBlock {
709 Self::PTR
710 }
711}
712impl Deref for USART1 {
713 type Target = usart1::RegisterBlock;
714 #[inline(always)]
715 fn deref(&self) -> &Self::Target {
716 unsafe { &*Self::PTR }
717 }
718}
719impl core::fmt::Debug for USART1 {
720 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
721 f.debug_struct("USART1").finish()
722 }
723}
724#[doc = "USART1"]
725pub mod usart1;
726#[doc = "USART2"]
727pub struct USART2 {
728 _marker: PhantomData<*const ()>,
729}
730unsafe impl Send for USART2 {}
731impl USART2 {
732 #[doc = r"Pointer to the register block"]
733 pub const PTR: *const usart2::RegisterBlock = 0x4001_0800 as *const _;
734 #[doc = r"Return the pointer to the register block"]
735 #[inline(always)]
736 pub const fn ptr() -> *const usart2::RegisterBlock {
737 Self::PTR
738 }
739}
740impl Deref for USART2 {
741 type Target = usart2::RegisterBlock;
742 #[inline(always)]
743 fn deref(&self) -> &Self::Target {
744 unsafe { &*Self::PTR }
745 }
746}
747impl core::fmt::Debug for USART2 {
748 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
749 f.debug_struct("USART2").finish()
750 }
751}
752#[doc = "USART2"]
753pub mod usart2;
754#[doc = "USART3"]
755pub struct USART3 {
756 _marker: PhantomData<*const ()>,
757}
758unsafe impl Send for USART3 {}
759impl USART3 {
760 #[doc = r"Pointer to the register block"]
761 pub const PTR: *const usart3::RegisterBlock = 0x4001_0c00 as *const _;
762 #[doc = r"Return the pointer to the register block"]
763 #[inline(always)]
764 pub const fn ptr() -> *const usart3::RegisterBlock {
765 Self::PTR
766 }
767}
768impl Deref for USART3 {
769 type Target = usart3::RegisterBlock;
770 #[inline(always)]
771 fn deref(&self) -> &Self::Target {
772 unsafe { &*Self::PTR }
773 }
774}
775impl core::fmt::Debug for USART3 {
776 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
777 f.debug_struct("USART3").finish()
778 }
779}
780#[doc = "USART3"]
781pub mod usart3;
782#[doc = "LEUART0"]
783pub struct LEUART0 {
784 _marker: PhantomData<*const ()>,
785}
786unsafe impl Send for LEUART0 {}
787impl LEUART0 {
788 #[doc = r"Pointer to the register block"]
789 pub const PTR: *const leuart0::RegisterBlock = 0x4004_a000 as *const _;
790 #[doc = r"Return the pointer to the register block"]
791 #[inline(always)]
792 pub const fn ptr() -> *const leuart0::RegisterBlock {
793 Self::PTR
794 }
795}
796impl Deref for LEUART0 {
797 type Target = leuart0::RegisterBlock;
798 #[inline(always)]
799 fn deref(&self) -> &Self::Target {
800 unsafe { &*Self::PTR }
801 }
802}
803impl core::fmt::Debug for LEUART0 {
804 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
805 f.debug_struct("LEUART0").finish()
806 }
807}
808#[doc = "LEUART0"]
809pub mod leuart0;
810#[doc = "LETIMER0"]
811pub struct LETIMER0 {
812 _marker: PhantomData<*const ()>,
813}
814unsafe impl Send for LETIMER0 {}
815impl LETIMER0 {
816 #[doc = r"Pointer to the register block"]
817 pub const PTR: *const letimer0::RegisterBlock = 0x4004_6000 as *const _;
818 #[doc = r"Return the pointer to the register block"]
819 #[inline(always)]
820 pub const fn ptr() -> *const letimer0::RegisterBlock {
821 Self::PTR
822 }
823}
824impl Deref for LETIMER0 {
825 type Target = letimer0::RegisterBlock;
826 #[inline(always)]
827 fn deref(&self) -> &Self::Target {
828 unsafe { &*Self::PTR }
829 }
830}
831impl core::fmt::Debug for LETIMER0 {
832 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
833 f.debug_struct("LETIMER0").finish()
834 }
835}
836#[doc = "LETIMER0"]
837pub mod letimer0;
838#[doc = "CRYOTIMER"]
839pub struct CRYOTIMER {
840 _marker: PhantomData<*const ()>,
841}
842unsafe impl Send for CRYOTIMER {}
843impl CRYOTIMER {
844 #[doc = r"Pointer to the register block"]
845 pub const PTR: *const cryotimer::RegisterBlock = 0x4001_e000 as *const _;
846 #[doc = r"Return the pointer to the register block"]
847 #[inline(always)]
848 pub const fn ptr() -> *const cryotimer::RegisterBlock {
849 Self::PTR
850 }
851}
852impl Deref for CRYOTIMER {
853 type Target = cryotimer::RegisterBlock;
854 #[inline(always)]
855 fn deref(&self) -> &Self::Target {
856 unsafe { &*Self::PTR }
857 }
858}
859impl core::fmt::Debug for CRYOTIMER {
860 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
861 f.debug_struct("CRYOTIMER").finish()
862 }
863}
864#[doc = "CRYOTIMER"]
865pub mod cryotimer;
866#[doc = "PCNT0"]
867pub struct PCNT0 {
868 _marker: PhantomData<*const ()>,
869}
870unsafe impl Send for PCNT0 {}
871impl PCNT0 {
872 #[doc = r"Pointer to the register block"]
873 pub const PTR: *const pcnt0::RegisterBlock = 0x4004_e000 as *const _;
874 #[doc = r"Return the pointer to the register block"]
875 #[inline(always)]
876 pub const fn ptr() -> *const pcnt0::RegisterBlock {
877 Self::PTR
878 }
879}
880impl Deref for PCNT0 {
881 type Target = pcnt0::RegisterBlock;
882 #[inline(always)]
883 fn deref(&self) -> &Self::Target {
884 unsafe { &*Self::PTR }
885 }
886}
887impl core::fmt::Debug for PCNT0 {
888 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
889 f.debug_struct("PCNT0").finish()
890 }
891}
892#[doc = "PCNT0"]
893pub mod pcnt0;
894#[doc = "PCNT1"]
895pub struct PCNT1 {
896 _marker: PhantomData<*const ()>,
897}
898unsafe impl Send for PCNT1 {}
899impl PCNT1 {
900 #[doc = r"Pointer to the register block"]
901 pub const PTR: *const pcnt1::RegisterBlock = 0x4004_e400 as *const _;
902 #[doc = r"Return the pointer to the register block"]
903 #[inline(always)]
904 pub const fn ptr() -> *const pcnt1::RegisterBlock {
905 Self::PTR
906 }
907}
908impl Deref for PCNT1 {
909 type Target = pcnt1::RegisterBlock;
910 #[inline(always)]
911 fn deref(&self) -> &Self::Target {
912 unsafe { &*Self::PTR }
913 }
914}
915impl core::fmt::Debug for PCNT1 {
916 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
917 f.debug_struct("PCNT1").finish()
918 }
919}
920#[doc = "PCNT1"]
921pub mod pcnt1;
922#[doc = "PCNT2"]
923pub struct PCNT2 {
924 _marker: PhantomData<*const ()>,
925}
926unsafe impl Send for PCNT2 {}
927impl PCNT2 {
928 #[doc = r"Pointer to the register block"]
929 pub const PTR: *const pcnt2::RegisterBlock = 0x4004_e800 as *const _;
930 #[doc = r"Return the pointer to the register block"]
931 #[inline(always)]
932 pub const fn ptr() -> *const pcnt2::RegisterBlock {
933 Self::PTR
934 }
935}
936impl Deref for PCNT2 {
937 type Target = pcnt2::RegisterBlock;
938 #[inline(always)]
939 fn deref(&self) -> &Self::Target {
940 unsafe { &*Self::PTR }
941 }
942}
943impl core::fmt::Debug for PCNT2 {
944 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
945 f.debug_struct("PCNT2").finish()
946 }
947}
948#[doc = "PCNT2"]
949pub mod pcnt2;
950#[doc = "I2C0"]
951pub struct I2C0 {
952 _marker: PhantomData<*const ()>,
953}
954unsafe impl Send for I2C0 {}
955impl I2C0 {
956 #[doc = r"Pointer to the register block"]
957 pub const PTR: *const i2c0::RegisterBlock = 0x4000_c000 as *const _;
958 #[doc = r"Return the pointer to the register block"]
959 #[inline(always)]
960 pub const fn ptr() -> *const i2c0::RegisterBlock {
961 Self::PTR
962 }
963}
964impl Deref for I2C0 {
965 type Target = i2c0::RegisterBlock;
966 #[inline(always)]
967 fn deref(&self) -> &Self::Target {
968 unsafe { &*Self::PTR }
969 }
970}
971impl core::fmt::Debug for I2C0 {
972 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
973 f.debug_struct("I2C0").finish()
974 }
975}
976#[doc = "I2C0"]
977pub mod i2c0;
978#[doc = "I2C1"]
979pub struct I2C1 {
980 _marker: PhantomData<*const ()>,
981}
982unsafe impl Send for I2C1 {}
983impl I2C1 {
984 #[doc = r"Pointer to the register block"]
985 pub const PTR: *const i2c1::RegisterBlock = 0x4000_c400 as *const _;
986 #[doc = r"Return the pointer to the register block"]
987 #[inline(always)]
988 pub const fn ptr() -> *const i2c1::RegisterBlock {
989 Self::PTR
990 }
991}
992impl Deref for I2C1 {
993 type Target = i2c1::RegisterBlock;
994 #[inline(always)]
995 fn deref(&self) -> &Self::Target {
996 unsafe { &*Self::PTR }
997 }
998}
999impl core::fmt::Debug for I2C1 {
1000 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1001 f.debug_struct("I2C1").finish()
1002 }
1003}
1004#[doc = "I2C1"]
1005pub mod i2c1;
1006#[doc = "ADC0"]
1007pub struct ADC0 {
1008 _marker: PhantomData<*const ()>,
1009}
1010unsafe impl Send for ADC0 {}
1011impl ADC0 {
1012 #[doc = r"Pointer to the register block"]
1013 pub const PTR: *const adc0::RegisterBlock = 0x4000_2000 as *const _;
1014 #[doc = r"Return the pointer to the register block"]
1015 #[inline(always)]
1016 pub const fn ptr() -> *const adc0::RegisterBlock {
1017 Self::PTR
1018 }
1019}
1020impl Deref for ADC0 {
1021 type Target = adc0::RegisterBlock;
1022 #[inline(always)]
1023 fn deref(&self) -> &Self::Target {
1024 unsafe { &*Self::PTR }
1025 }
1026}
1027impl core::fmt::Debug for ADC0 {
1028 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1029 f.debug_struct("ADC0").finish()
1030 }
1031}
1032#[doc = "ADC0"]
1033pub mod adc0;
1034#[doc = "ACMP0"]
1035pub struct ACMP0 {
1036 _marker: PhantomData<*const ()>,
1037}
1038unsafe impl Send for ACMP0 {}
1039impl ACMP0 {
1040 #[doc = r"Pointer to the register block"]
1041 pub const PTR: *const acmp0::RegisterBlock = 0x4000_0000 as *const _;
1042 #[doc = r"Return the pointer to the register block"]
1043 #[inline(always)]
1044 pub const fn ptr() -> *const acmp0::RegisterBlock {
1045 Self::PTR
1046 }
1047}
1048impl Deref for ACMP0 {
1049 type Target = acmp0::RegisterBlock;
1050 #[inline(always)]
1051 fn deref(&self) -> &Self::Target {
1052 unsafe { &*Self::PTR }
1053 }
1054}
1055impl core::fmt::Debug for ACMP0 {
1056 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1057 f.debug_struct("ACMP0").finish()
1058 }
1059}
1060#[doc = "ACMP0"]
1061pub mod acmp0;
1062#[doc = "ACMP1"]
1063pub struct ACMP1 {
1064 _marker: PhantomData<*const ()>,
1065}
1066unsafe impl Send for ACMP1 {}
1067impl ACMP1 {
1068 #[doc = r"Pointer to the register block"]
1069 pub const PTR: *const acmp1::RegisterBlock = 0x4000_0400 as *const _;
1070 #[doc = r"Return the pointer to the register block"]
1071 #[inline(always)]
1072 pub const fn ptr() -> *const acmp1::RegisterBlock {
1073 Self::PTR
1074 }
1075}
1076impl Deref for ACMP1 {
1077 type Target = acmp1::RegisterBlock;
1078 #[inline(always)]
1079 fn deref(&self) -> &Self::Target {
1080 unsafe { &*Self::PTR }
1081 }
1082}
1083impl core::fmt::Debug for ACMP1 {
1084 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1085 f.debug_struct("ACMP1").finish()
1086 }
1087}
1088#[doc = "ACMP1"]
1089pub mod acmp1;
1090#[doc = "IDAC0"]
1091pub struct IDAC0 {
1092 _marker: PhantomData<*const ()>,
1093}
1094unsafe impl Send for IDAC0 {}
1095impl IDAC0 {
1096 #[doc = r"Pointer to the register block"]
1097 pub const PTR: *const idac0::RegisterBlock = 0x4000_6000 as *const _;
1098 #[doc = r"Return the pointer to the register block"]
1099 #[inline(always)]
1100 pub const fn ptr() -> *const idac0::RegisterBlock {
1101 Self::PTR
1102 }
1103}
1104impl Deref for IDAC0 {
1105 type Target = idac0::RegisterBlock;
1106 #[inline(always)]
1107 fn deref(&self) -> &Self::Target {
1108 unsafe { &*Self::PTR }
1109 }
1110}
1111impl core::fmt::Debug for IDAC0 {
1112 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1113 f.debug_struct("IDAC0").finish()
1114 }
1115}
1116#[doc = "IDAC0"]
1117pub mod idac0;
1118#[doc = "VDAC0"]
1119pub struct VDAC0 {
1120 _marker: PhantomData<*const ()>,
1121}
1122unsafe impl Send for VDAC0 {}
1123impl VDAC0 {
1124 #[doc = r"Pointer to the register block"]
1125 pub const PTR: *const vdac0::RegisterBlock = 0x4000_8000 as *const _;
1126 #[doc = r"Return the pointer to the register block"]
1127 #[inline(always)]
1128 pub const fn ptr() -> *const vdac0::RegisterBlock {
1129 Self::PTR
1130 }
1131}
1132impl Deref for VDAC0 {
1133 type Target = vdac0::RegisterBlock;
1134 #[inline(always)]
1135 fn deref(&self) -> &Self::Target {
1136 unsafe { &*Self::PTR }
1137 }
1138}
1139impl core::fmt::Debug for VDAC0 {
1140 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1141 f.debug_struct("VDAC0").finish()
1142 }
1143}
1144#[doc = "VDAC0"]
1145pub mod vdac0;
1146#[doc = "CSEN"]
1147pub struct CSEN {
1148 _marker: PhantomData<*const ()>,
1149}
1150unsafe impl Send for CSEN {}
1151impl CSEN {
1152 #[doc = r"Pointer to the register block"]
1153 pub const PTR: *const csen::RegisterBlock = 0x4001_f000 as *const _;
1154 #[doc = r"Return the pointer to the register block"]
1155 #[inline(always)]
1156 pub const fn ptr() -> *const csen::RegisterBlock {
1157 Self::PTR
1158 }
1159}
1160impl Deref for CSEN {
1161 type Target = csen::RegisterBlock;
1162 #[inline(always)]
1163 fn deref(&self) -> &Self::Target {
1164 unsafe { &*Self::PTR }
1165 }
1166}
1167impl core::fmt::Debug for CSEN {
1168 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1169 f.debug_struct("CSEN").finish()
1170 }
1171}
1172#[doc = "CSEN"]
1173pub mod csen;
1174#[doc = "LESENSE"]
1175pub struct LESENSE {
1176 _marker: PhantomData<*const ()>,
1177}
1178unsafe impl Send for LESENSE {}
1179impl LESENSE {
1180 #[doc = r"Pointer to the register block"]
1181 pub const PTR: *const lesense::RegisterBlock = 0x4005_5000 as *const _;
1182 #[doc = r"Return the pointer to the register block"]
1183 #[inline(always)]
1184 pub const fn ptr() -> *const lesense::RegisterBlock {
1185 Self::PTR
1186 }
1187}
1188impl Deref for LESENSE {
1189 type Target = lesense::RegisterBlock;
1190 #[inline(always)]
1191 fn deref(&self) -> &Self::Target {
1192 unsafe { &*Self::PTR }
1193 }
1194}
1195impl core::fmt::Debug for LESENSE {
1196 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1197 f.debug_struct("LESENSE").finish()
1198 }
1199}
1200#[doc = "LESENSE"]
1201pub mod lesense;
1202#[doc = "RTCC"]
1203pub struct RTCC {
1204 _marker: PhantomData<*const ()>,
1205}
1206unsafe impl Send for RTCC {}
1207impl RTCC {
1208 #[doc = r"Pointer to the register block"]
1209 pub const PTR: *const rtcc::RegisterBlock = 0x4004_2000 as *const _;
1210 #[doc = r"Return the pointer to the register block"]
1211 #[inline(always)]
1212 pub const fn ptr() -> *const rtcc::RegisterBlock {
1213 Self::PTR
1214 }
1215}
1216impl Deref for RTCC {
1217 type Target = rtcc::RegisterBlock;
1218 #[inline(always)]
1219 fn deref(&self) -> &Self::Target {
1220 unsafe { &*Self::PTR }
1221 }
1222}
1223impl core::fmt::Debug for RTCC {
1224 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1225 f.debug_struct("RTCC").finish()
1226 }
1227}
1228#[doc = "RTCC"]
1229pub mod rtcc;
1230#[doc = "WDOG0"]
1231pub struct WDOG0 {
1232 _marker: PhantomData<*const ()>,
1233}
1234unsafe impl Send for WDOG0 {}
1235impl WDOG0 {
1236 #[doc = r"Pointer to the register block"]
1237 pub const PTR: *const wdog0::RegisterBlock = 0x4005_2000 as *const _;
1238 #[doc = r"Return the pointer to the register block"]
1239 #[inline(always)]
1240 pub const fn ptr() -> *const wdog0::RegisterBlock {
1241 Self::PTR
1242 }
1243}
1244impl Deref for WDOG0 {
1245 type Target = wdog0::RegisterBlock;
1246 #[inline(always)]
1247 fn deref(&self) -> &Self::Target {
1248 unsafe { &*Self::PTR }
1249 }
1250}
1251impl core::fmt::Debug for WDOG0 {
1252 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1253 f.debug_struct("WDOG0").finish()
1254 }
1255}
1256#[doc = "WDOG0"]
1257pub mod wdog0;
1258#[doc = "WDOG1"]
1259pub struct WDOG1 {
1260 _marker: PhantomData<*const ()>,
1261}
1262unsafe impl Send for WDOG1 {}
1263impl WDOG1 {
1264 #[doc = r"Pointer to the register block"]
1265 pub const PTR: *const wdog1::RegisterBlock = 0x4005_2400 as *const _;
1266 #[doc = r"Return the pointer to the register block"]
1267 #[inline(always)]
1268 pub const fn ptr() -> *const wdog1::RegisterBlock {
1269 Self::PTR
1270 }
1271}
1272impl Deref for WDOG1 {
1273 type Target = wdog1::RegisterBlock;
1274 #[inline(always)]
1275 fn deref(&self) -> &Self::Target {
1276 unsafe { &*Self::PTR }
1277 }
1278}
1279impl core::fmt::Debug for WDOG1 {
1280 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1281 f.debug_struct("WDOG1").finish()
1282 }
1283}
1284#[doc = "WDOG1"]
1285pub mod wdog1;
1286#[doc = "ETM"]
1287pub struct ETM {
1288 _marker: PhantomData<*const ()>,
1289}
1290unsafe impl Send for ETM {}
1291impl ETM {
1292 #[doc = r"Pointer to the register block"]
1293 pub const PTR: *const etm::RegisterBlock = 0xe004_1000 as *const _;
1294 #[doc = r"Return the pointer to the register block"]
1295 #[inline(always)]
1296 pub const fn ptr() -> *const etm::RegisterBlock {
1297 Self::PTR
1298 }
1299}
1300impl Deref for ETM {
1301 type Target = etm::RegisterBlock;
1302 #[inline(always)]
1303 fn deref(&self) -> &Self::Target {
1304 unsafe { &*Self::PTR }
1305 }
1306}
1307impl core::fmt::Debug for ETM {
1308 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1309 f.debug_struct("ETM").finish()
1310 }
1311}
1312#[doc = "ETM"]
1313pub mod etm;
1314#[doc = "SMU"]
1315pub struct SMU {
1316 _marker: PhantomData<*const ()>,
1317}
1318unsafe impl Send for SMU {}
1319impl SMU {
1320 #[doc = r"Pointer to the register block"]
1321 pub const PTR: *const smu::RegisterBlock = 0x4002_2000 as *const _;
1322 #[doc = r"Return the pointer to the register block"]
1323 #[inline(always)]
1324 pub const fn ptr() -> *const smu::RegisterBlock {
1325 Self::PTR
1326 }
1327}
1328impl Deref for SMU {
1329 type Target = smu::RegisterBlock;
1330 #[inline(always)]
1331 fn deref(&self) -> &Self::Target {
1332 unsafe { &*Self::PTR }
1333 }
1334}
1335impl core::fmt::Debug for SMU {
1336 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1337 f.debug_struct("SMU").finish()
1338 }
1339}
1340#[doc = "SMU"]
1341pub mod smu;
1342#[doc = "TRNG0"]
1343pub struct TRNG0 {
1344 _marker: PhantomData<*const ()>,
1345}
1346unsafe impl Send for TRNG0 {}
1347impl TRNG0 {
1348 #[doc = r"Pointer to the register block"]
1349 pub const PTR: *const trng0::RegisterBlock = 0x4001_d000 as *const _;
1350 #[doc = r"Return the pointer to the register block"]
1351 #[inline(always)]
1352 pub const fn ptr() -> *const trng0::RegisterBlock {
1353 Self::PTR
1354 }
1355}
1356impl Deref for TRNG0 {
1357 type Target = trng0::RegisterBlock;
1358 #[inline(always)]
1359 fn deref(&self) -> &Self::Target {
1360 unsafe { &*Self::PTR }
1361 }
1362}
1363impl core::fmt::Debug for TRNG0 {
1364 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1365 f.debug_struct("TRNG0").finish()
1366 }
1367}
1368#[doc = "TRNG0"]
1369pub mod trng0;
1370#[no_mangle]
1371static mut DEVICE_PERIPHERALS: bool = false;
1372#[doc = r"All the peripherals"]
1373#[allow(non_snake_case)]
1374pub struct Peripherals {
1375 #[doc = "MSC"]
1376 pub MSC: MSC,
1377 #[doc = "EMU"]
1378 pub EMU: EMU,
1379 #[doc = "RMU"]
1380 pub RMU: RMU,
1381 #[doc = "CMU"]
1382 pub CMU: CMU,
1383 #[doc = "CRYPTO0"]
1384 pub CRYPTO0: CRYPTO0,
1385 #[doc = "CRYPTO1"]
1386 pub CRYPTO1: CRYPTO1,
1387 #[doc = "GPIO"]
1388 pub GPIO: GPIO,
1389 #[doc = "PRS"]
1390 pub PRS: PRS,
1391 #[doc = "LDMA"]
1392 pub LDMA: LDMA,
1393 #[doc = "FPUEH"]
1394 pub FPUEH: FPUEH,
1395 #[doc = "GPCRC"]
1396 pub GPCRC: GPCRC,
1397 #[doc = "TIMER0"]
1398 pub TIMER0: TIMER0,
1399 #[doc = "TIMER1"]
1400 pub TIMER1: TIMER1,
1401 #[doc = "WTIMER0"]
1402 pub WTIMER0: WTIMER0,
1403 #[doc = "WTIMER1"]
1404 pub WTIMER1: WTIMER1,
1405 #[doc = "USART0"]
1406 pub USART0: USART0,
1407 #[doc = "USART1"]
1408 pub USART1: USART1,
1409 #[doc = "USART2"]
1410 pub USART2: USART2,
1411 #[doc = "USART3"]
1412 pub USART3: USART3,
1413 #[doc = "LEUART0"]
1414 pub LEUART0: LEUART0,
1415 #[doc = "LETIMER0"]
1416 pub LETIMER0: LETIMER0,
1417 #[doc = "CRYOTIMER"]
1418 pub CRYOTIMER: CRYOTIMER,
1419 #[doc = "PCNT0"]
1420 pub PCNT0: PCNT0,
1421 #[doc = "PCNT1"]
1422 pub PCNT1: PCNT1,
1423 #[doc = "PCNT2"]
1424 pub PCNT2: PCNT2,
1425 #[doc = "I2C0"]
1426 pub I2C0: I2C0,
1427 #[doc = "I2C1"]
1428 pub I2C1: I2C1,
1429 #[doc = "ADC0"]
1430 pub ADC0: ADC0,
1431 #[doc = "ACMP0"]
1432 pub ACMP0: ACMP0,
1433 #[doc = "ACMP1"]
1434 pub ACMP1: ACMP1,
1435 #[doc = "IDAC0"]
1436 pub IDAC0: IDAC0,
1437 #[doc = "VDAC0"]
1438 pub VDAC0: VDAC0,
1439 #[doc = "CSEN"]
1440 pub CSEN: CSEN,
1441 #[doc = "LESENSE"]
1442 pub LESENSE: LESENSE,
1443 #[doc = "RTCC"]
1444 pub RTCC: RTCC,
1445 #[doc = "WDOG0"]
1446 pub WDOG0: WDOG0,
1447 #[doc = "WDOG1"]
1448 pub WDOG1: WDOG1,
1449 #[doc = "ETM"]
1450 pub ETM: ETM,
1451 #[doc = "SMU"]
1452 pub SMU: SMU,
1453 #[doc = "TRNG0"]
1454 pub TRNG0: TRNG0,
1455}
1456impl Peripherals {
1457 #[doc = r"Returns all the peripherals *once*"]
1458 #[inline]
1459 pub fn take() -> Option<Self> {
1460 cortex_m::interrupt::free(|_| {
1461 if unsafe { DEVICE_PERIPHERALS } {
1462 None
1463 } else {
1464 Some(unsafe { Peripherals::steal() })
1465 }
1466 })
1467 }
1468 #[doc = r"Unchecked version of `Peripherals::take`"]
1469 #[inline]
1470 pub unsafe fn steal() -> Self {
1471 DEVICE_PERIPHERALS = true;
1472 Peripherals {
1473 MSC: MSC {
1474 _marker: PhantomData,
1475 },
1476 EMU: EMU {
1477 _marker: PhantomData,
1478 },
1479 RMU: RMU {
1480 _marker: PhantomData,
1481 },
1482 CMU: CMU {
1483 _marker: PhantomData,
1484 },
1485 CRYPTO0: CRYPTO0 {
1486 _marker: PhantomData,
1487 },
1488 CRYPTO1: CRYPTO1 {
1489 _marker: PhantomData,
1490 },
1491 GPIO: GPIO {
1492 _marker: PhantomData,
1493 },
1494 PRS: PRS {
1495 _marker: PhantomData,
1496 },
1497 LDMA: LDMA {
1498 _marker: PhantomData,
1499 },
1500 FPUEH: FPUEH {
1501 _marker: PhantomData,
1502 },
1503 GPCRC: GPCRC {
1504 _marker: PhantomData,
1505 },
1506 TIMER0: TIMER0 {
1507 _marker: PhantomData,
1508 },
1509 TIMER1: TIMER1 {
1510 _marker: PhantomData,
1511 },
1512 WTIMER0: WTIMER0 {
1513 _marker: PhantomData,
1514 },
1515 WTIMER1: WTIMER1 {
1516 _marker: PhantomData,
1517 },
1518 USART0: USART0 {
1519 _marker: PhantomData,
1520 },
1521 USART1: USART1 {
1522 _marker: PhantomData,
1523 },
1524 USART2: USART2 {
1525 _marker: PhantomData,
1526 },
1527 USART3: USART3 {
1528 _marker: PhantomData,
1529 },
1530 LEUART0: LEUART0 {
1531 _marker: PhantomData,
1532 },
1533 LETIMER0: LETIMER0 {
1534 _marker: PhantomData,
1535 },
1536 CRYOTIMER: CRYOTIMER {
1537 _marker: PhantomData,
1538 },
1539 PCNT0: PCNT0 {
1540 _marker: PhantomData,
1541 },
1542 PCNT1: PCNT1 {
1543 _marker: PhantomData,
1544 },
1545 PCNT2: PCNT2 {
1546 _marker: PhantomData,
1547 },
1548 I2C0: I2C0 {
1549 _marker: PhantomData,
1550 },
1551 I2C1: I2C1 {
1552 _marker: PhantomData,
1553 },
1554 ADC0: ADC0 {
1555 _marker: PhantomData,
1556 },
1557 ACMP0: ACMP0 {
1558 _marker: PhantomData,
1559 },
1560 ACMP1: ACMP1 {
1561 _marker: PhantomData,
1562 },
1563 IDAC0: IDAC0 {
1564 _marker: PhantomData,
1565 },
1566 VDAC0: VDAC0 {
1567 _marker: PhantomData,
1568 },
1569 CSEN: CSEN {
1570 _marker: PhantomData,
1571 },
1572 LESENSE: LESENSE {
1573 _marker: PhantomData,
1574 },
1575 RTCC: RTCC {
1576 _marker: PhantomData,
1577 },
1578 WDOG0: WDOG0 {
1579 _marker: PhantomData,
1580 },
1581 WDOG1: WDOG1 {
1582 _marker: PhantomData,
1583 },
1584 ETM: ETM {
1585 _marker: PhantomData,
1586 },
1587 SMU: SMU {
1588 _marker: PhantomData,
1589 },
1590 TRNG0: TRNG0 {
1591 _marker: PhantomData,
1592 },
1593 }
1594 }
1595}