1#![doc = "Peripheral access API for EFM32GG12B130F512GM64 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 LDMA();
40 fn GPIO_EVEN();
41 fn SMU();
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 I2C1();
50 fn GPIO_ODD();
51 fn TIMER1();
52 fn TIMER2();
53 fn TIMER3();
54 fn USART1_RX();
55 fn USART1_TX();
56 fn USART2_RX();
57 fn USART2_TX();
58 fn UART0_RX();
59 fn UART0_TX();
60 fn UART1_RX();
61 fn UART1_TX();
62 fn LEUART0();
63 fn LEUART1();
64 fn LETIMER0();
65 fn PCNT0();
66 fn PCNT1();
67 fn PCNT2();
68 fn RTCC();
69 fn CMU();
70 fn MSC();
71 fn CRYPTO0();
72 fn CRYOTIMER();
73 fn FPUEH();
74 fn USART3_RX();
75 fn USART3_TX();
76 fn USART4_RX();
77 fn USART4_TX();
78 fn WTIMER0();
79 fn WTIMER1();
80 fn VDAC0();
81 fn CSEN();
82 fn LESENSE();
83 fn EBI();
84 fn ACMP2();
85 fn ADC1();
86 fn CAN0();
87 fn CAN1();
88 fn RTC();
89 fn WDOG1();
90 fn LETIMER1();
91 fn TRNG0();
92 fn PDM();
93}
94#[doc(hidden)]
95pub union Vector {
96 _handler: unsafe extern "C" fn(),
97 _reserved: u32,
98}
99#[cfg(feature = "rt")]
100#[doc(hidden)]
101#[link_section = ".vector_table.interrupts"]
102#[no_mangle]
103pub static __INTERRUPTS: [Vector; 60] = [
104 Vector { _handler: EMU },
105 Vector { _handler: WDOG0 },
106 Vector { _handler: LDMA },
107 Vector {
108 _handler: GPIO_EVEN,
109 },
110 Vector { _handler: SMU },
111 Vector { _handler: TIMER0 },
112 Vector {
113 _handler: USART0_RX,
114 },
115 Vector {
116 _handler: USART0_TX,
117 },
118 Vector { _handler: ACMP0 },
119 Vector { _handler: ADC0 },
120 Vector { _handler: IDAC0 },
121 Vector { _handler: I2C0 },
122 Vector { _handler: I2C1 },
123 Vector { _handler: GPIO_ODD },
124 Vector { _handler: TIMER1 },
125 Vector { _handler: TIMER2 },
126 Vector { _handler: TIMER3 },
127 Vector {
128 _handler: USART1_RX,
129 },
130 Vector {
131 _handler: USART1_TX,
132 },
133 Vector {
134 _handler: USART2_RX,
135 },
136 Vector {
137 _handler: USART2_TX,
138 },
139 Vector { _handler: UART0_RX },
140 Vector { _handler: UART0_TX },
141 Vector { _handler: UART1_RX },
142 Vector { _handler: UART1_TX },
143 Vector { _handler: LEUART0 },
144 Vector { _handler: LEUART1 },
145 Vector { _handler: LETIMER0 },
146 Vector { _handler: PCNT0 },
147 Vector { _handler: PCNT1 },
148 Vector { _handler: PCNT2 },
149 Vector { _handler: RTCC },
150 Vector { _handler: CMU },
151 Vector { _handler: MSC },
152 Vector { _handler: CRYPTO0 },
153 Vector {
154 _handler: CRYOTIMER,
155 },
156 Vector { _handler: FPUEH },
157 Vector {
158 _handler: USART3_RX,
159 },
160 Vector {
161 _handler: USART3_TX,
162 },
163 Vector {
164 _handler: USART4_RX,
165 },
166 Vector {
167 _handler: USART4_TX,
168 },
169 Vector { _handler: WTIMER0 },
170 Vector { _handler: WTIMER1 },
171 Vector { _handler: VDAC0 },
172 Vector { _handler: CSEN },
173 Vector { _handler: LESENSE },
174 Vector { _handler: EBI },
175 Vector { _handler: ACMP2 },
176 Vector { _handler: ADC1 },
177 Vector { _reserved: 0 },
178 Vector { _reserved: 0 },
179 Vector { _handler: CAN0 },
180 Vector { _handler: CAN1 },
181 Vector { _reserved: 0 },
182 Vector { _handler: RTC },
183 Vector { _handler: WDOG1 },
184 Vector { _handler: LETIMER1 },
185 Vector { _handler: TRNG0 },
186 Vector { _reserved: 0 },
187 Vector { _handler: PDM },
188];
189#[doc = r"Enumeration of all the interrupts."]
190#[derive(Copy, Clone, Debug, PartialEq, Eq)]
191#[repr(u16)]
192pub enum Interrupt {
193 #[doc = "0 - EMU"]
194 EMU = 0,
195 #[doc = "1 - WDOG0"]
196 WDOG0 = 1,
197 #[doc = "2 - LDMA"]
198 LDMA = 2,
199 #[doc = "3 - GPIO_EVEN"]
200 GPIO_EVEN = 3,
201 #[doc = "4 - SMU"]
202 SMU = 4,
203 #[doc = "5 - TIMER0"]
204 TIMER0 = 5,
205 #[doc = "6 - USART0_RX"]
206 USART0_RX = 6,
207 #[doc = "7 - USART0_TX"]
208 USART0_TX = 7,
209 #[doc = "8 - ACMP0"]
210 ACMP0 = 8,
211 #[doc = "9 - ADC0"]
212 ADC0 = 9,
213 #[doc = "10 - IDAC0"]
214 IDAC0 = 10,
215 #[doc = "11 - I2C0"]
216 I2C0 = 11,
217 #[doc = "12 - I2C1"]
218 I2C1 = 12,
219 #[doc = "13 - GPIO_ODD"]
220 GPIO_ODD = 13,
221 #[doc = "14 - TIMER1"]
222 TIMER1 = 14,
223 #[doc = "15 - TIMER2"]
224 TIMER2 = 15,
225 #[doc = "16 - TIMER3"]
226 TIMER3 = 16,
227 #[doc = "17 - USART1_RX"]
228 USART1_RX = 17,
229 #[doc = "18 - USART1_TX"]
230 USART1_TX = 18,
231 #[doc = "19 - USART2_RX"]
232 USART2_RX = 19,
233 #[doc = "20 - USART2_TX"]
234 USART2_TX = 20,
235 #[doc = "21 - UART0_RX"]
236 UART0_RX = 21,
237 #[doc = "22 - UART0_TX"]
238 UART0_TX = 22,
239 #[doc = "23 - UART1_RX"]
240 UART1_RX = 23,
241 #[doc = "24 - UART1_TX"]
242 UART1_TX = 24,
243 #[doc = "25 - LEUART0"]
244 LEUART0 = 25,
245 #[doc = "26 - LEUART1"]
246 LEUART1 = 26,
247 #[doc = "27 - LETIMER0"]
248 LETIMER0 = 27,
249 #[doc = "28 - PCNT0"]
250 PCNT0 = 28,
251 #[doc = "29 - PCNT1"]
252 PCNT1 = 29,
253 #[doc = "30 - PCNT2"]
254 PCNT2 = 30,
255 #[doc = "31 - RTCC"]
256 RTCC = 31,
257 #[doc = "32 - CMU"]
258 CMU = 32,
259 #[doc = "33 - MSC"]
260 MSC = 33,
261 #[doc = "34 - CRYPTO0"]
262 CRYPTO0 = 34,
263 #[doc = "35 - CRYOTIMER"]
264 CRYOTIMER = 35,
265 #[doc = "36 - FPUEH"]
266 FPUEH = 36,
267 #[doc = "37 - USART3_RX"]
268 USART3_RX = 37,
269 #[doc = "38 - USART3_TX"]
270 USART3_TX = 38,
271 #[doc = "39 - USART4_RX"]
272 USART4_RX = 39,
273 #[doc = "40 - USART4_TX"]
274 USART4_TX = 40,
275 #[doc = "41 - WTIMER0"]
276 WTIMER0 = 41,
277 #[doc = "42 - WTIMER1"]
278 WTIMER1 = 42,
279 #[doc = "43 - VDAC0"]
280 VDAC0 = 43,
281 #[doc = "44 - CSEN"]
282 CSEN = 44,
283 #[doc = "45 - LESENSE"]
284 LESENSE = 45,
285 #[doc = "46 - EBI"]
286 EBI = 46,
287 #[doc = "47 - ACMP2"]
288 ACMP2 = 47,
289 #[doc = "48 - ADC1"]
290 ADC1 = 48,
291 #[doc = "51 - CAN0"]
292 CAN0 = 51,
293 #[doc = "52 - CAN1"]
294 CAN1 = 52,
295 #[doc = "54 - RTC"]
296 RTC = 54,
297 #[doc = "55 - WDOG1"]
298 WDOG1 = 55,
299 #[doc = "56 - LETIMER1"]
300 LETIMER1 = 56,
301 #[doc = "57 - TRNG0"]
302 TRNG0 = 57,
303 #[doc = "59 - PDM"]
304 PDM = 59,
305}
306unsafe impl cortex_m::interrupt::InterruptNumber for Interrupt {
307 #[inline(always)]
308 fn number(self) -> u16 {
309 self as u16
310 }
311}
312#[doc = "MSC"]
313pub struct MSC {
314 _marker: PhantomData<*const ()>,
315}
316unsafe impl Send for MSC {}
317impl MSC {
318 #[doc = r"Pointer to the register block"]
319 pub const PTR: *const msc::RegisterBlock = 0x4000_0000 as *const _;
320 #[doc = r"Return the pointer to the register block"]
321 #[inline(always)]
322 pub const fn ptr() -> *const msc::RegisterBlock {
323 Self::PTR
324 }
325}
326impl Deref for MSC {
327 type Target = msc::RegisterBlock;
328 #[inline(always)]
329 fn deref(&self) -> &Self::Target {
330 unsafe { &*Self::PTR }
331 }
332}
333impl core::fmt::Debug for MSC {
334 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
335 f.debug_struct("MSC").finish()
336 }
337}
338#[doc = "MSC"]
339pub mod msc;
340#[doc = "EMU"]
341pub struct EMU {
342 _marker: PhantomData<*const ()>,
343}
344unsafe impl Send for EMU {}
345impl EMU {
346 #[doc = r"Pointer to the register block"]
347 pub const PTR: *const emu::RegisterBlock = 0x400e_3000 as *const _;
348 #[doc = r"Return the pointer to the register block"]
349 #[inline(always)]
350 pub const fn ptr() -> *const emu::RegisterBlock {
351 Self::PTR
352 }
353}
354impl Deref for EMU {
355 type Target = emu::RegisterBlock;
356 #[inline(always)]
357 fn deref(&self) -> &Self::Target {
358 unsafe { &*Self::PTR }
359 }
360}
361impl core::fmt::Debug for EMU {
362 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
363 f.debug_struct("EMU").finish()
364 }
365}
366#[doc = "EMU"]
367pub mod emu;
368#[doc = "RMU"]
369pub struct RMU {
370 _marker: PhantomData<*const ()>,
371}
372unsafe impl Send for RMU {}
373impl RMU {
374 #[doc = r"Pointer to the register block"]
375 pub const PTR: *const rmu::RegisterBlock = 0x400e_5000 as *const _;
376 #[doc = r"Return the pointer to the register block"]
377 #[inline(always)]
378 pub const fn ptr() -> *const rmu::RegisterBlock {
379 Self::PTR
380 }
381}
382impl Deref for RMU {
383 type Target = rmu::RegisterBlock;
384 #[inline(always)]
385 fn deref(&self) -> &Self::Target {
386 unsafe { &*Self::PTR }
387 }
388}
389impl core::fmt::Debug for RMU {
390 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
391 f.debug_struct("RMU").finish()
392 }
393}
394#[doc = "RMU"]
395pub mod rmu;
396#[doc = "CMU"]
397pub struct CMU {
398 _marker: PhantomData<*const ()>,
399}
400unsafe impl Send for CMU {}
401impl CMU {
402 #[doc = r"Pointer to the register block"]
403 pub const PTR: *const cmu::RegisterBlock = 0x400e_4000 as *const _;
404 #[doc = r"Return the pointer to the register block"]
405 #[inline(always)]
406 pub const fn ptr() -> *const cmu::RegisterBlock {
407 Self::PTR
408 }
409}
410impl Deref for CMU {
411 type Target = cmu::RegisterBlock;
412 #[inline(always)]
413 fn deref(&self) -> &Self::Target {
414 unsafe { &*Self::PTR }
415 }
416}
417impl core::fmt::Debug for CMU {
418 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
419 f.debug_struct("CMU").finish()
420 }
421}
422#[doc = "CMU"]
423pub mod cmu;
424#[doc = "CRYPTO0"]
425pub struct CRYPTO0 {
426 _marker: PhantomData<*const ()>,
427}
428unsafe impl Send for CRYPTO0 {}
429impl CRYPTO0 {
430 #[doc = r"Pointer to the register block"]
431 pub const PTR: *const crypto0::RegisterBlock = 0x400f_0000 as *const _;
432 #[doc = r"Return the pointer to the register block"]
433 #[inline(always)]
434 pub const fn ptr() -> *const crypto0::RegisterBlock {
435 Self::PTR
436 }
437}
438impl Deref for CRYPTO0 {
439 type Target = crypto0::RegisterBlock;
440 #[inline(always)]
441 fn deref(&self) -> &Self::Target {
442 unsafe { &*Self::PTR }
443 }
444}
445impl core::fmt::Debug for CRYPTO0 {
446 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
447 f.debug_struct("CRYPTO0").finish()
448 }
449}
450#[doc = "CRYPTO0"]
451pub mod crypto0;
452#[doc = "LESENSE"]
453pub struct LESENSE {
454 _marker: PhantomData<*const ()>,
455}
456unsafe impl Send for LESENSE {}
457impl LESENSE {
458 #[doc = r"Pointer to the register block"]
459 pub const PTR: *const lesense::RegisterBlock = 0x4005_5000 as *const _;
460 #[doc = r"Return the pointer to the register block"]
461 #[inline(always)]
462 pub const fn ptr() -> *const lesense::RegisterBlock {
463 Self::PTR
464 }
465}
466impl Deref for LESENSE {
467 type Target = lesense::RegisterBlock;
468 #[inline(always)]
469 fn deref(&self) -> &Self::Target {
470 unsafe { &*Self::PTR }
471 }
472}
473impl core::fmt::Debug for LESENSE {
474 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
475 f.debug_struct("LESENSE").finish()
476 }
477}
478#[doc = "LESENSE"]
479pub mod lesense;
480#[doc = "EBI"]
481pub struct EBI {
482 _marker: PhantomData<*const ()>,
483}
484unsafe impl Send for EBI {}
485impl EBI {
486 #[doc = r"Pointer to the register block"]
487 pub const PTR: *const ebi::RegisterBlock = 0x4000_b000 as *const _;
488 #[doc = r"Return the pointer to the register block"]
489 #[inline(always)]
490 pub const fn ptr() -> *const ebi::RegisterBlock {
491 Self::PTR
492 }
493}
494impl Deref for EBI {
495 type Target = ebi::RegisterBlock;
496 #[inline(always)]
497 fn deref(&self) -> &Self::Target {
498 unsafe { &*Self::PTR }
499 }
500}
501impl core::fmt::Debug for EBI {
502 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
503 f.debug_struct("EBI").finish()
504 }
505}
506#[doc = "EBI"]
507pub mod ebi;
508#[doc = "PDM"]
509pub struct PDM {
510 _marker: PhantomData<*const ()>,
511}
512unsafe impl Send for PDM {}
513impl PDM {
514 #[doc = r"Pointer to the register block"]
515 pub const PTR: *const pdm::RegisterBlock = 0x4002_8000 as *const _;
516 #[doc = r"Return the pointer to the register block"]
517 #[inline(always)]
518 pub const fn ptr() -> *const pdm::RegisterBlock {
519 Self::PTR
520 }
521}
522impl Deref for PDM {
523 type Target = pdm::RegisterBlock;
524 #[inline(always)]
525 fn deref(&self) -> &Self::Target {
526 unsafe { &*Self::PTR }
527 }
528}
529impl core::fmt::Debug for PDM {
530 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
531 f.debug_struct("PDM").finish()
532 }
533}
534#[doc = "PDM"]
535pub mod pdm;
536#[doc = "GPIO"]
537pub struct GPIO {
538 _marker: PhantomData<*const ()>,
539}
540unsafe impl Send for GPIO {}
541impl GPIO {
542 #[doc = r"Pointer to the register block"]
543 pub const PTR: *const gpio::RegisterBlock = 0x4008_8000 as *const _;
544 #[doc = r"Return the pointer to the register block"]
545 #[inline(always)]
546 pub const fn ptr() -> *const gpio::RegisterBlock {
547 Self::PTR
548 }
549}
550impl Deref for GPIO {
551 type Target = gpio::RegisterBlock;
552 #[inline(always)]
553 fn deref(&self) -> &Self::Target {
554 unsafe { &*Self::PTR }
555 }
556}
557impl core::fmt::Debug for GPIO {
558 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
559 f.debug_struct("GPIO").finish()
560 }
561}
562#[doc = "GPIO"]
563pub mod gpio;
564#[doc = "PRS"]
565pub struct PRS {
566 _marker: PhantomData<*const ()>,
567}
568unsafe impl Send for PRS {}
569impl PRS {
570 #[doc = r"Pointer to the register block"]
571 pub const PTR: *const prs::RegisterBlock = 0x400e_6000 as *const _;
572 #[doc = r"Return the pointer to the register block"]
573 #[inline(always)]
574 pub const fn ptr() -> *const prs::RegisterBlock {
575 Self::PTR
576 }
577}
578impl Deref for PRS {
579 type Target = prs::RegisterBlock;
580 #[inline(always)]
581 fn deref(&self) -> &Self::Target {
582 unsafe { &*Self::PTR }
583 }
584}
585impl core::fmt::Debug for PRS {
586 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
587 f.debug_struct("PRS").finish()
588 }
589}
590#[doc = "PRS"]
591pub mod prs;
592#[doc = "LDMA"]
593pub struct LDMA {
594 _marker: PhantomData<*const ()>,
595}
596unsafe impl Send for LDMA {}
597impl LDMA {
598 #[doc = r"Pointer to the register block"]
599 pub const PTR: *const ldma::RegisterBlock = 0x4000_2000 as *const _;
600 #[doc = r"Return the pointer to the register block"]
601 #[inline(always)]
602 pub const fn ptr() -> *const ldma::RegisterBlock {
603 Self::PTR
604 }
605}
606impl Deref for LDMA {
607 type Target = ldma::RegisterBlock;
608 #[inline(always)]
609 fn deref(&self) -> &Self::Target {
610 unsafe { &*Self::PTR }
611 }
612}
613impl core::fmt::Debug for LDMA {
614 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
615 f.debug_struct("LDMA").finish()
616 }
617}
618#[doc = "LDMA"]
619pub mod ldma;
620#[doc = "FPUEH"]
621pub struct FPUEH {
622 _marker: PhantomData<*const ()>,
623}
624unsafe impl Send for FPUEH {}
625impl FPUEH {
626 #[doc = r"Pointer to the register block"]
627 pub const PTR: *const fpueh::RegisterBlock = 0x4000_1000 as *const _;
628 #[doc = r"Return the pointer to the register block"]
629 #[inline(always)]
630 pub const fn ptr() -> *const fpueh::RegisterBlock {
631 Self::PTR
632 }
633}
634impl Deref for FPUEH {
635 type Target = fpueh::RegisterBlock;
636 #[inline(always)]
637 fn deref(&self) -> &Self::Target {
638 unsafe { &*Self::PTR }
639 }
640}
641impl core::fmt::Debug for FPUEH {
642 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
643 f.debug_struct("FPUEH").finish()
644 }
645}
646#[doc = "FPUEH"]
647pub mod fpueh;
648#[doc = "GPCRC"]
649pub struct GPCRC {
650 _marker: PhantomData<*const ()>,
651}
652unsafe impl Send for GPCRC {}
653impl GPCRC {
654 #[doc = r"Pointer to the register block"]
655 pub const PTR: *const gpcrc::RegisterBlock = 0x4001_c000 as *const _;
656 #[doc = r"Return the pointer to the register block"]
657 #[inline(always)]
658 pub const fn ptr() -> *const gpcrc::RegisterBlock {
659 Self::PTR
660 }
661}
662impl Deref for GPCRC {
663 type Target = gpcrc::RegisterBlock;
664 #[inline(always)]
665 fn deref(&self) -> &Self::Target {
666 unsafe { &*Self::PTR }
667 }
668}
669impl core::fmt::Debug for GPCRC {
670 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
671 f.debug_struct("GPCRC").finish()
672 }
673}
674#[doc = "GPCRC"]
675pub mod gpcrc;
676#[doc = "CAN0"]
677pub struct CAN0 {
678 _marker: PhantomData<*const ()>,
679}
680unsafe impl Send for CAN0 {}
681impl CAN0 {
682 #[doc = r"Pointer to the register block"]
683 pub const PTR: *const can0::RegisterBlock = 0x4000_4000 as *const _;
684 #[doc = r"Return the pointer to the register block"]
685 #[inline(always)]
686 pub const fn ptr() -> *const can0::RegisterBlock {
687 Self::PTR
688 }
689}
690impl Deref for CAN0 {
691 type Target = can0::RegisterBlock;
692 #[inline(always)]
693 fn deref(&self) -> &Self::Target {
694 unsafe { &*Self::PTR }
695 }
696}
697impl core::fmt::Debug for CAN0 {
698 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
699 f.debug_struct("CAN0").finish()
700 }
701}
702#[doc = "CAN0"]
703pub mod can0;
704#[doc = "CAN1"]
705pub struct CAN1 {
706 _marker: PhantomData<*const ()>,
707}
708unsafe impl Send for CAN1 {}
709impl CAN1 {
710 #[doc = r"Pointer to the register block"]
711 pub const PTR: *const can1::RegisterBlock = 0x4000_4400 as *const _;
712 #[doc = r"Return the pointer to the register block"]
713 #[inline(always)]
714 pub const fn ptr() -> *const can1::RegisterBlock {
715 Self::PTR
716 }
717}
718impl Deref for CAN1 {
719 type Target = can1::RegisterBlock;
720 #[inline(always)]
721 fn deref(&self) -> &Self::Target {
722 unsafe { &*Self::PTR }
723 }
724}
725impl core::fmt::Debug for CAN1 {
726 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
727 f.debug_struct("CAN1").finish()
728 }
729}
730#[doc = "CAN1"]
731pub mod can1;
732#[doc = "TIMER0"]
733pub struct TIMER0 {
734 _marker: PhantomData<*const ()>,
735}
736unsafe impl Send for TIMER0 {}
737impl TIMER0 {
738 #[doc = r"Pointer to the register block"]
739 pub const PTR: *const timer0::RegisterBlock = 0x4001_8000 as *const _;
740 #[doc = r"Return the pointer to the register block"]
741 #[inline(always)]
742 pub const fn ptr() -> *const timer0::RegisterBlock {
743 Self::PTR
744 }
745}
746impl Deref for TIMER0 {
747 type Target = timer0::RegisterBlock;
748 #[inline(always)]
749 fn deref(&self) -> &Self::Target {
750 unsafe { &*Self::PTR }
751 }
752}
753impl core::fmt::Debug for TIMER0 {
754 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
755 f.debug_struct("TIMER0").finish()
756 }
757}
758#[doc = "TIMER0"]
759pub mod timer0;
760#[doc = "TIMER1"]
761pub struct TIMER1 {
762 _marker: PhantomData<*const ()>,
763}
764unsafe impl Send for TIMER1 {}
765impl TIMER1 {
766 #[doc = r"Pointer to the register block"]
767 pub const PTR: *const timer1::RegisterBlock = 0x4001_8400 as *const _;
768 #[doc = r"Return the pointer to the register block"]
769 #[inline(always)]
770 pub const fn ptr() -> *const timer1::RegisterBlock {
771 Self::PTR
772 }
773}
774impl Deref for TIMER1 {
775 type Target = timer1::RegisterBlock;
776 #[inline(always)]
777 fn deref(&self) -> &Self::Target {
778 unsafe { &*Self::PTR }
779 }
780}
781impl core::fmt::Debug for TIMER1 {
782 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
783 f.debug_struct("TIMER1").finish()
784 }
785}
786#[doc = "TIMER1"]
787pub mod timer1;
788#[doc = "TIMER2"]
789pub struct TIMER2 {
790 _marker: PhantomData<*const ()>,
791}
792unsafe impl Send for TIMER2 {}
793impl TIMER2 {
794 #[doc = r"Pointer to the register block"]
795 pub const PTR: *const timer2::RegisterBlock = 0x4001_8800 as *const _;
796 #[doc = r"Return the pointer to the register block"]
797 #[inline(always)]
798 pub const fn ptr() -> *const timer2::RegisterBlock {
799 Self::PTR
800 }
801}
802impl Deref for TIMER2 {
803 type Target = timer2::RegisterBlock;
804 #[inline(always)]
805 fn deref(&self) -> &Self::Target {
806 unsafe { &*Self::PTR }
807 }
808}
809impl core::fmt::Debug for TIMER2 {
810 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
811 f.debug_struct("TIMER2").finish()
812 }
813}
814#[doc = "TIMER2"]
815pub mod timer2;
816#[doc = "TIMER3"]
817pub struct TIMER3 {
818 _marker: PhantomData<*const ()>,
819}
820unsafe impl Send for TIMER3 {}
821impl TIMER3 {
822 #[doc = r"Pointer to the register block"]
823 pub const PTR: *const timer3::RegisterBlock = 0x4001_8c00 as *const _;
824 #[doc = r"Return the pointer to the register block"]
825 #[inline(always)]
826 pub const fn ptr() -> *const timer3::RegisterBlock {
827 Self::PTR
828 }
829}
830impl Deref for TIMER3 {
831 type Target = timer3::RegisterBlock;
832 #[inline(always)]
833 fn deref(&self) -> &Self::Target {
834 unsafe { &*Self::PTR }
835 }
836}
837impl core::fmt::Debug for TIMER3 {
838 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
839 f.debug_struct("TIMER3").finish()
840 }
841}
842#[doc = "TIMER3"]
843pub mod timer3;
844#[doc = "WTIMER0"]
845pub struct WTIMER0 {
846 _marker: PhantomData<*const ()>,
847}
848unsafe impl Send for WTIMER0 {}
849impl WTIMER0 {
850 #[doc = r"Pointer to the register block"]
851 pub const PTR: *const wtimer0::RegisterBlock = 0x4001_a000 as *const _;
852 #[doc = r"Return the pointer to the register block"]
853 #[inline(always)]
854 pub const fn ptr() -> *const wtimer0::RegisterBlock {
855 Self::PTR
856 }
857}
858impl Deref for WTIMER0 {
859 type Target = wtimer0::RegisterBlock;
860 #[inline(always)]
861 fn deref(&self) -> &Self::Target {
862 unsafe { &*Self::PTR }
863 }
864}
865impl core::fmt::Debug for WTIMER0 {
866 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
867 f.debug_struct("WTIMER0").finish()
868 }
869}
870#[doc = "WTIMER0"]
871pub mod wtimer0;
872#[doc = "WTIMER1"]
873pub struct WTIMER1 {
874 _marker: PhantomData<*const ()>,
875}
876unsafe impl Send for WTIMER1 {}
877impl WTIMER1 {
878 #[doc = r"Pointer to the register block"]
879 pub const PTR: *const wtimer1::RegisterBlock = 0x4001_a400 as *const _;
880 #[doc = r"Return the pointer to the register block"]
881 #[inline(always)]
882 pub const fn ptr() -> *const wtimer1::RegisterBlock {
883 Self::PTR
884 }
885}
886impl Deref for WTIMER1 {
887 type Target = wtimer1::RegisterBlock;
888 #[inline(always)]
889 fn deref(&self) -> &Self::Target {
890 unsafe { &*Self::PTR }
891 }
892}
893impl core::fmt::Debug for WTIMER1 {
894 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
895 f.debug_struct("WTIMER1").finish()
896 }
897}
898#[doc = "WTIMER1"]
899pub mod wtimer1;
900#[doc = "USART0"]
901pub struct USART0 {
902 _marker: PhantomData<*const ()>,
903}
904unsafe impl Send for USART0 {}
905impl USART0 {
906 #[doc = r"Pointer to the register block"]
907 pub const PTR: *const usart0::RegisterBlock = 0x4001_0000 as *const _;
908 #[doc = r"Return the pointer to the register block"]
909 #[inline(always)]
910 pub const fn ptr() -> *const usart0::RegisterBlock {
911 Self::PTR
912 }
913}
914impl Deref for USART0 {
915 type Target = usart0::RegisterBlock;
916 #[inline(always)]
917 fn deref(&self) -> &Self::Target {
918 unsafe { &*Self::PTR }
919 }
920}
921impl core::fmt::Debug for USART0 {
922 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
923 f.debug_struct("USART0").finish()
924 }
925}
926#[doc = "USART0"]
927pub mod usart0;
928#[doc = "USART1"]
929pub struct USART1 {
930 _marker: PhantomData<*const ()>,
931}
932unsafe impl Send for USART1 {}
933impl USART1 {
934 #[doc = r"Pointer to the register block"]
935 pub const PTR: *const usart1::RegisterBlock = 0x4001_0400 as *const _;
936 #[doc = r"Return the pointer to the register block"]
937 #[inline(always)]
938 pub const fn ptr() -> *const usart1::RegisterBlock {
939 Self::PTR
940 }
941}
942impl Deref for USART1 {
943 type Target = usart1::RegisterBlock;
944 #[inline(always)]
945 fn deref(&self) -> &Self::Target {
946 unsafe { &*Self::PTR }
947 }
948}
949impl core::fmt::Debug for USART1 {
950 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
951 f.debug_struct("USART1").finish()
952 }
953}
954#[doc = "USART1"]
955pub mod usart1;
956#[doc = "USART2"]
957pub struct USART2 {
958 _marker: PhantomData<*const ()>,
959}
960unsafe impl Send for USART2 {}
961impl USART2 {
962 #[doc = r"Pointer to the register block"]
963 pub const PTR: *const usart2::RegisterBlock = 0x4001_0800 as *const _;
964 #[doc = r"Return the pointer to the register block"]
965 #[inline(always)]
966 pub const fn ptr() -> *const usart2::RegisterBlock {
967 Self::PTR
968 }
969}
970impl Deref for USART2 {
971 type Target = usart2::RegisterBlock;
972 #[inline(always)]
973 fn deref(&self) -> &Self::Target {
974 unsafe { &*Self::PTR }
975 }
976}
977impl core::fmt::Debug for USART2 {
978 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
979 f.debug_struct("USART2").finish()
980 }
981}
982#[doc = "USART2"]
983pub mod usart2;
984#[doc = "USART3"]
985pub struct USART3 {
986 _marker: PhantomData<*const ()>,
987}
988unsafe impl Send for USART3 {}
989impl USART3 {
990 #[doc = r"Pointer to the register block"]
991 pub const PTR: *const usart3::RegisterBlock = 0x4001_0c00 as *const _;
992 #[doc = r"Return the pointer to the register block"]
993 #[inline(always)]
994 pub const fn ptr() -> *const usart3::RegisterBlock {
995 Self::PTR
996 }
997}
998impl Deref for USART3 {
999 type Target = usart3::RegisterBlock;
1000 #[inline(always)]
1001 fn deref(&self) -> &Self::Target {
1002 unsafe { &*Self::PTR }
1003 }
1004}
1005impl core::fmt::Debug for USART3 {
1006 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1007 f.debug_struct("USART3").finish()
1008 }
1009}
1010#[doc = "USART3"]
1011pub mod usart3;
1012#[doc = "USART4"]
1013pub struct USART4 {
1014 _marker: PhantomData<*const ()>,
1015}
1016unsafe impl Send for USART4 {}
1017impl USART4 {
1018 #[doc = r"Pointer to the register block"]
1019 pub const PTR: *const usart4::RegisterBlock = 0x4001_1000 as *const _;
1020 #[doc = r"Return the pointer to the register block"]
1021 #[inline(always)]
1022 pub const fn ptr() -> *const usart4::RegisterBlock {
1023 Self::PTR
1024 }
1025}
1026impl Deref for USART4 {
1027 type Target = usart4::RegisterBlock;
1028 #[inline(always)]
1029 fn deref(&self) -> &Self::Target {
1030 unsafe { &*Self::PTR }
1031 }
1032}
1033impl core::fmt::Debug for USART4 {
1034 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1035 f.debug_struct("USART4").finish()
1036 }
1037}
1038#[doc = "USART4"]
1039pub mod usart4;
1040#[doc = "UART0"]
1041pub struct UART0 {
1042 _marker: PhantomData<*const ()>,
1043}
1044unsafe impl Send for UART0 {}
1045impl UART0 {
1046 #[doc = r"Pointer to the register block"]
1047 pub const PTR: *const uart0::RegisterBlock = 0x4001_4000 as *const _;
1048 #[doc = r"Return the pointer to the register block"]
1049 #[inline(always)]
1050 pub const fn ptr() -> *const uart0::RegisterBlock {
1051 Self::PTR
1052 }
1053}
1054impl Deref for UART0 {
1055 type Target = uart0::RegisterBlock;
1056 #[inline(always)]
1057 fn deref(&self) -> &Self::Target {
1058 unsafe { &*Self::PTR }
1059 }
1060}
1061impl core::fmt::Debug for UART0 {
1062 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1063 f.debug_struct("UART0").finish()
1064 }
1065}
1066#[doc = "UART0"]
1067pub mod uart0;
1068#[doc = "UART1"]
1069pub struct UART1 {
1070 _marker: PhantomData<*const ()>,
1071}
1072unsafe impl Send for UART1 {}
1073impl UART1 {
1074 #[doc = r"Pointer to the register block"]
1075 pub const PTR: *const uart1::RegisterBlock = 0x4001_4400 as *const _;
1076 #[doc = r"Return the pointer to the register block"]
1077 #[inline(always)]
1078 pub const fn ptr() -> *const uart1::RegisterBlock {
1079 Self::PTR
1080 }
1081}
1082impl Deref for UART1 {
1083 type Target = uart1::RegisterBlock;
1084 #[inline(always)]
1085 fn deref(&self) -> &Self::Target {
1086 unsafe { &*Self::PTR }
1087 }
1088}
1089impl core::fmt::Debug for UART1 {
1090 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1091 f.debug_struct("UART1").finish()
1092 }
1093}
1094#[doc = "UART1"]
1095pub mod uart1;
1096#[doc = "LEUART0"]
1097pub struct LEUART0 {
1098 _marker: PhantomData<*const ()>,
1099}
1100unsafe impl Send for LEUART0 {}
1101impl LEUART0 {
1102 #[doc = r"Pointer to the register block"]
1103 pub const PTR: *const leuart0::RegisterBlock = 0x4006_a000 as *const _;
1104 #[doc = r"Return the pointer to the register block"]
1105 #[inline(always)]
1106 pub const fn ptr() -> *const leuart0::RegisterBlock {
1107 Self::PTR
1108 }
1109}
1110impl Deref for LEUART0 {
1111 type Target = leuart0::RegisterBlock;
1112 #[inline(always)]
1113 fn deref(&self) -> &Self::Target {
1114 unsafe { &*Self::PTR }
1115 }
1116}
1117impl core::fmt::Debug for LEUART0 {
1118 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1119 f.debug_struct("LEUART0").finish()
1120 }
1121}
1122#[doc = "LEUART0"]
1123pub mod leuart0;
1124#[doc = "LEUART1"]
1125pub struct LEUART1 {
1126 _marker: PhantomData<*const ()>,
1127}
1128unsafe impl Send for LEUART1 {}
1129impl LEUART1 {
1130 #[doc = r"Pointer to the register block"]
1131 pub const PTR: *const leuart1::RegisterBlock = 0x4006_a400 as *const _;
1132 #[doc = r"Return the pointer to the register block"]
1133 #[inline(always)]
1134 pub const fn ptr() -> *const leuart1::RegisterBlock {
1135 Self::PTR
1136 }
1137}
1138impl Deref for LEUART1 {
1139 type Target = leuart1::RegisterBlock;
1140 #[inline(always)]
1141 fn deref(&self) -> &Self::Target {
1142 unsafe { &*Self::PTR }
1143 }
1144}
1145impl core::fmt::Debug for LEUART1 {
1146 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1147 f.debug_struct("LEUART1").finish()
1148 }
1149}
1150#[doc = "LEUART1"]
1151pub mod leuart1;
1152#[doc = "LETIMER0"]
1153pub struct LETIMER0 {
1154 _marker: PhantomData<*const ()>,
1155}
1156unsafe impl Send for LETIMER0 {}
1157impl LETIMER0 {
1158 #[doc = r"Pointer to the register block"]
1159 pub const PTR: *const letimer0::RegisterBlock = 0x4006_6000 as *const _;
1160 #[doc = r"Return the pointer to the register block"]
1161 #[inline(always)]
1162 pub const fn ptr() -> *const letimer0::RegisterBlock {
1163 Self::PTR
1164 }
1165}
1166impl Deref for LETIMER0 {
1167 type Target = letimer0::RegisterBlock;
1168 #[inline(always)]
1169 fn deref(&self) -> &Self::Target {
1170 unsafe { &*Self::PTR }
1171 }
1172}
1173impl core::fmt::Debug for LETIMER0 {
1174 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1175 f.debug_struct("LETIMER0").finish()
1176 }
1177}
1178#[doc = "LETIMER0"]
1179pub mod letimer0;
1180#[doc = "LETIMER1"]
1181pub struct LETIMER1 {
1182 _marker: PhantomData<*const ()>,
1183}
1184unsafe impl Send for LETIMER1 {}
1185impl LETIMER1 {
1186 #[doc = r"Pointer to the register block"]
1187 pub const PTR: *const letimer1::RegisterBlock = 0x4006_6400 as *const _;
1188 #[doc = r"Return the pointer to the register block"]
1189 #[inline(always)]
1190 pub const fn ptr() -> *const letimer1::RegisterBlock {
1191 Self::PTR
1192 }
1193}
1194impl Deref for LETIMER1 {
1195 type Target = letimer1::RegisterBlock;
1196 #[inline(always)]
1197 fn deref(&self) -> &Self::Target {
1198 unsafe { &*Self::PTR }
1199 }
1200}
1201impl core::fmt::Debug for LETIMER1 {
1202 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1203 f.debug_struct("LETIMER1").finish()
1204 }
1205}
1206#[doc = "LETIMER1"]
1207pub mod letimer1;
1208#[doc = "CRYOTIMER"]
1209pub struct CRYOTIMER {
1210 _marker: PhantomData<*const ()>,
1211}
1212unsafe impl Send for CRYOTIMER {}
1213impl CRYOTIMER {
1214 #[doc = r"Pointer to the register block"]
1215 pub const PTR: *const cryotimer::RegisterBlock = 0x4008_f000 as *const _;
1216 #[doc = r"Return the pointer to the register block"]
1217 #[inline(always)]
1218 pub const fn ptr() -> *const cryotimer::RegisterBlock {
1219 Self::PTR
1220 }
1221}
1222impl Deref for CRYOTIMER {
1223 type Target = cryotimer::RegisterBlock;
1224 #[inline(always)]
1225 fn deref(&self) -> &Self::Target {
1226 unsafe { &*Self::PTR }
1227 }
1228}
1229impl core::fmt::Debug for CRYOTIMER {
1230 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1231 f.debug_struct("CRYOTIMER").finish()
1232 }
1233}
1234#[doc = "CRYOTIMER"]
1235pub mod cryotimer;
1236#[doc = "PCNT0"]
1237pub struct PCNT0 {
1238 _marker: PhantomData<*const ()>,
1239}
1240unsafe impl Send for PCNT0 {}
1241impl PCNT0 {
1242 #[doc = r"Pointer to the register block"]
1243 pub const PTR: *const pcnt0::RegisterBlock = 0x4006_e000 as *const _;
1244 #[doc = r"Return the pointer to the register block"]
1245 #[inline(always)]
1246 pub const fn ptr() -> *const pcnt0::RegisterBlock {
1247 Self::PTR
1248 }
1249}
1250impl Deref for PCNT0 {
1251 type Target = pcnt0::RegisterBlock;
1252 #[inline(always)]
1253 fn deref(&self) -> &Self::Target {
1254 unsafe { &*Self::PTR }
1255 }
1256}
1257impl core::fmt::Debug for PCNT0 {
1258 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1259 f.debug_struct("PCNT0").finish()
1260 }
1261}
1262#[doc = "PCNT0"]
1263pub mod pcnt0;
1264#[doc = "PCNT1"]
1265pub struct PCNT1 {
1266 _marker: PhantomData<*const ()>,
1267}
1268unsafe impl Send for PCNT1 {}
1269impl PCNT1 {
1270 #[doc = r"Pointer to the register block"]
1271 pub const PTR: *const pcnt1::RegisterBlock = 0x4006_e400 as *const _;
1272 #[doc = r"Return the pointer to the register block"]
1273 #[inline(always)]
1274 pub const fn ptr() -> *const pcnt1::RegisterBlock {
1275 Self::PTR
1276 }
1277}
1278impl Deref for PCNT1 {
1279 type Target = pcnt1::RegisterBlock;
1280 #[inline(always)]
1281 fn deref(&self) -> &Self::Target {
1282 unsafe { &*Self::PTR }
1283 }
1284}
1285impl core::fmt::Debug for PCNT1 {
1286 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1287 f.debug_struct("PCNT1").finish()
1288 }
1289}
1290#[doc = "PCNT1"]
1291pub mod pcnt1;
1292#[doc = "PCNT2"]
1293pub struct PCNT2 {
1294 _marker: PhantomData<*const ()>,
1295}
1296unsafe impl Send for PCNT2 {}
1297impl PCNT2 {
1298 #[doc = r"Pointer to the register block"]
1299 pub const PTR: *const pcnt2::RegisterBlock = 0x4006_e800 as *const _;
1300 #[doc = r"Return the pointer to the register block"]
1301 #[inline(always)]
1302 pub const fn ptr() -> *const pcnt2::RegisterBlock {
1303 Self::PTR
1304 }
1305}
1306impl Deref for PCNT2 {
1307 type Target = pcnt2::RegisterBlock;
1308 #[inline(always)]
1309 fn deref(&self) -> &Self::Target {
1310 unsafe { &*Self::PTR }
1311 }
1312}
1313impl core::fmt::Debug for PCNT2 {
1314 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1315 f.debug_struct("PCNT2").finish()
1316 }
1317}
1318#[doc = "PCNT2"]
1319pub mod pcnt2;
1320#[doc = "I2C0"]
1321pub struct I2C0 {
1322 _marker: PhantomData<*const ()>,
1323}
1324unsafe impl Send for I2C0 {}
1325impl I2C0 {
1326 #[doc = r"Pointer to the register block"]
1327 pub const PTR: *const i2c0::RegisterBlock = 0x4008_9000 as *const _;
1328 #[doc = r"Return the pointer to the register block"]
1329 #[inline(always)]
1330 pub const fn ptr() -> *const i2c0::RegisterBlock {
1331 Self::PTR
1332 }
1333}
1334impl Deref for I2C0 {
1335 type Target = i2c0::RegisterBlock;
1336 #[inline(always)]
1337 fn deref(&self) -> &Self::Target {
1338 unsafe { &*Self::PTR }
1339 }
1340}
1341impl core::fmt::Debug for I2C0 {
1342 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1343 f.debug_struct("I2C0").finish()
1344 }
1345}
1346#[doc = "I2C0"]
1347pub mod i2c0;
1348#[doc = "I2C1"]
1349pub struct I2C1 {
1350 _marker: PhantomData<*const ()>,
1351}
1352unsafe impl Send for I2C1 {}
1353impl I2C1 {
1354 #[doc = r"Pointer to the register block"]
1355 pub const PTR: *const i2c1::RegisterBlock = 0x4008_9400 as *const _;
1356 #[doc = r"Return the pointer to the register block"]
1357 #[inline(always)]
1358 pub const fn ptr() -> *const i2c1::RegisterBlock {
1359 Self::PTR
1360 }
1361}
1362impl Deref for I2C1 {
1363 type Target = i2c1::RegisterBlock;
1364 #[inline(always)]
1365 fn deref(&self) -> &Self::Target {
1366 unsafe { &*Self::PTR }
1367 }
1368}
1369impl core::fmt::Debug for I2C1 {
1370 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1371 f.debug_struct("I2C1").finish()
1372 }
1373}
1374#[doc = "I2C1"]
1375pub mod i2c1;
1376#[doc = "ADC0"]
1377pub struct ADC0 {
1378 _marker: PhantomData<*const ()>,
1379}
1380unsafe impl Send for ADC0 {}
1381impl ADC0 {
1382 #[doc = r"Pointer to the register block"]
1383 pub const PTR: *const adc0::RegisterBlock = 0x4008_2000 as *const _;
1384 #[doc = r"Return the pointer to the register block"]
1385 #[inline(always)]
1386 pub const fn ptr() -> *const adc0::RegisterBlock {
1387 Self::PTR
1388 }
1389}
1390impl Deref for ADC0 {
1391 type Target = adc0::RegisterBlock;
1392 #[inline(always)]
1393 fn deref(&self) -> &Self::Target {
1394 unsafe { &*Self::PTR }
1395 }
1396}
1397impl core::fmt::Debug for ADC0 {
1398 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1399 f.debug_struct("ADC0").finish()
1400 }
1401}
1402#[doc = "ADC0"]
1403pub mod adc0;
1404#[doc = "ADC1"]
1405pub struct ADC1 {
1406 _marker: PhantomData<*const ()>,
1407}
1408unsafe impl Send for ADC1 {}
1409impl ADC1 {
1410 #[doc = r"Pointer to the register block"]
1411 pub const PTR: *const adc1::RegisterBlock = 0x4008_2400 as *const _;
1412 #[doc = r"Return the pointer to the register block"]
1413 #[inline(always)]
1414 pub const fn ptr() -> *const adc1::RegisterBlock {
1415 Self::PTR
1416 }
1417}
1418impl Deref for ADC1 {
1419 type Target = adc1::RegisterBlock;
1420 #[inline(always)]
1421 fn deref(&self) -> &Self::Target {
1422 unsafe { &*Self::PTR }
1423 }
1424}
1425impl core::fmt::Debug for ADC1 {
1426 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1427 f.debug_struct("ADC1").finish()
1428 }
1429}
1430#[doc = "ADC1"]
1431pub mod adc1;
1432#[doc = "ACMP0"]
1433pub struct ACMP0 {
1434 _marker: PhantomData<*const ()>,
1435}
1436unsafe impl Send for ACMP0 {}
1437impl ACMP0 {
1438 #[doc = r"Pointer to the register block"]
1439 pub const PTR: *const acmp0::RegisterBlock = 0x4008_0000 as *const _;
1440 #[doc = r"Return the pointer to the register block"]
1441 #[inline(always)]
1442 pub const fn ptr() -> *const acmp0::RegisterBlock {
1443 Self::PTR
1444 }
1445}
1446impl Deref for ACMP0 {
1447 type Target = acmp0::RegisterBlock;
1448 #[inline(always)]
1449 fn deref(&self) -> &Self::Target {
1450 unsafe { &*Self::PTR }
1451 }
1452}
1453impl core::fmt::Debug for ACMP0 {
1454 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1455 f.debug_struct("ACMP0").finish()
1456 }
1457}
1458#[doc = "ACMP0"]
1459pub mod acmp0;
1460#[doc = "ACMP1"]
1461pub struct ACMP1 {
1462 _marker: PhantomData<*const ()>,
1463}
1464unsafe impl Send for ACMP1 {}
1465impl ACMP1 {
1466 #[doc = r"Pointer to the register block"]
1467 pub const PTR: *const acmp1::RegisterBlock = 0x4008_0400 as *const _;
1468 #[doc = r"Return the pointer to the register block"]
1469 #[inline(always)]
1470 pub const fn ptr() -> *const acmp1::RegisterBlock {
1471 Self::PTR
1472 }
1473}
1474impl Deref for ACMP1 {
1475 type Target = acmp1::RegisterBlock;
1476 #[inline(always)]
1477 fn deref(&self) -> &Self::Target {
1478 unsafe { &*Self::PTR }
1479 }
1480}
1481impl core::fmt::Debug for ACMP1 {
1482 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1483 f.debug_struct("ACMP1").finish()
1484 }
1485}
1486#[doc = "ACMP1"]
1487pub mod acmp1;
1488#[doc = "ACMP2"]
1489pub struct ACMP2 {
1490 _marker: PhantomData<*const ()>,
1491}
1492unsafe impl Send for ACMP2 {}
1493impl ACMP2 {
1494 #[doc = r"Pointer to the register block"]
1495 pub const PTR: *const acmp2::RegisterBlock = 0x4008_0800 as *const _;
1496 #[doc = r"Return the pointer to the register block"]
1497 #[inline(always)]
1498 pub const fn ptr() -> *const acmp2::RegisterBlock {
1499 Self::PTR
1500 }
1501}
1502impl Deref for ACMP2 {
1503 type Target = acmp2::RegisterBlock;
1504 #[inline(always)]
1505 fn deref(&self) -> &Self::Target {
1506 unsafe { &*Self::PTR }
1507 }
1508}
1509impl core::fmt::Debug for ACMP2 {
1510 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1511 f.debug_struct("ACMP2").finish()
1512 }
1513}
1514#[doc = "ACMP2"]
1515pub mod acmp2;
1516#[doc = "VDAC0"]
1517pub struct VDAC0 {
1518 _marker: PhantomData<*const ()>,
1519}
1520unsafe impl Send for VDAC0 {}
1521impl VDAC0 {
1522 #[doc = r"Pointer to the register block"]
1523 pub const PTR: *const vdac0::RegisterBlock = 0x4008_6000 as *const _;
1524 #[doc = r"Return the pointer to the register block"]
1525 #[inline(always)]
1526 pub const fn ptr() -> *const vdac0::RegisterBlock {
1527 Self::PTR
1528 }
1529}
1530impl Deref for VDAC0 {
1531 type Target = vdac0::RegisterBlock;
1532 #[inline(always)]
1533 fn deref(&self) -> &Self::Target {
1534 unsafe { &*Self::PTR }
1535 }
1536}
1537impl core::fmt::Debug for VDAC0 {
1538 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1539 f.debug_struct("VDAC0").finish()
1540 }
1541}
1542#[doc = "VDAC0"]
1543pub mod vdac0;
1544#[doc = "IDAC0"]
1545pub struct IDAC0 {
1546 _marker: PhantomData<*const ()>,
1547}
1548unsafe impl Send for IDAC0 {}
1549impl IDAC0 {
1550 #[doc = r"Pointer to the register block"]
1551 pub const PTR: *const idac0::RegisterBlock = 0x4008_4000 as *const _;
1552 #[doc = r"Return the pointer to the register block"]
1553 #[inline(always)]
1554 pub const fn ptr() -> *const idac0::RegisterBlock {
1555 Self::PTR
1556 }
1557}
1558impl Deref for IDAC0 {
1559 type Target = idac0::RegisterBlock;
1560 #[inline(always)]
1561 fn deref(&self) -> &Self::Target {
1562 unsafe { &*Self::PTR }
1563 }
1564}
1565impl core::fmt::Debug for IDAC0 {
1566 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1567 f.debug_struct("IDAC0").finish()
1568 }
1569}
1570#[doc = "IDAC0"]
1571pub mod idac0;
1572#[doc = "CSEN"]
1573pub struct CSEN {
1574 _marker: PhantomData<*const ()>,
1575}
1576unsafe impl Send for CSEN {}
1577impl CSEN {
1578 #[doc = r"Pointer to the register block"]
1579 pub const PTR: *const csen::RegisterBlock = 0x4008_e000 as *const _;
1580 #[doc = r"Return the pointer to the register block"]
1581 #[inline(always)]
1582 pub const fn ptr() -> *const csen::RegisterBlock {
1583 Self::PTR
1584 }
1585}
1586impl Deref for CSEN {
1587 type Target = csen::RegisterBlock;
1588 #[inline(always)]
1589 fn deref(&self) -> &Self::Target {
1590 unsafe { &*Self::PTR }
1591 }
1592}
1593impl core::fmt::Debug for CSEN {
1594 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1595 f.debug_struct("CSEN").finish()
1596 }
1597}
1598#[doc = "CSEN"]
1599pub mod csen;
1600#[doc = "RTC"]
1601pub struct RTC {
1602 _marker: PhantomData<*const ()>,
1603}
1604unsafe impl Send for RTC {}
1605impl RTC {
1606 #[doc = r"Pointer to the register block"]
1607 pub const PTR: *const rtc::RegisterBlock = 0x4006_0000 as *const _;
1608 #[doc = r"Return the pointer to the register block"]
1609 #[inline(always)]
1610 pub const fn ptr() -> *const rtc::RegisterBlock {
1611 Self::PTR
1612 }
1613}
1614impl Deref for RTC {
1615 type Target = rtc::RegisterBlock;
1616 #[inline(always)]
1617 fn deref(&self) -> &Self::Target {
1618 unsafe { &*Self::PTR }
1619 }
1620}
1621impl core::fmt::Debug for RTC {
1622 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1623 f.debug_struct("RTC").finish()
1624 }
1625}
1626#[doc = "RTC"]
1627pub mod rtc;
1628#[doc = "RTCC"]
1629pub struct RTCC {
1630 _marker: PhantomData<*const ()>,
1631}
1632unsafe impl Send for RTCC {}
1633impl RTCC {
1634 #[doc = r"Pointer to the register block"]
1635 pub const PTR: *const rtcc::RegisterBlock = 0x4006_2000 as *const _;
1636 #[doc = r"Return the pointer to the register block"]
1637 #[inline(always)]
1638 pub const fn ptr() -> *const rtcc::RegisterBlock {
1639 Self::PTR
1640 }
1641}
1642impl Deref for RTCC {
1643 type Target = rtcc::RegisterBlock;
1644 #[inline(always)]
1645 fn deref(&self) -> &Self::Target {
1646 unsafe { &*Self::PTR }
1647 }
1648}
1649impl core::fmt::Debug for RTCC {
1650 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1651 f.debug_struct("RTCC").finish()
1652 }
1653}
1654#[doc = "RTCC"]
1655pub mod rtcc;
1656#[doc = "WDOG0"]
1657pub struct WDOG0 {
1658 _marker: PhantomData<*const ()>,
1659}
1660unsafe impl Send for WDOG0 {}
1661impl WDOG0 {
1662 #[doc = r"Pointer to the register block"]
1663 pub const PTR: *const wdog0::RegisterBlock = 0x4005_2000 as *const _;
1664 #[doc = r"Return the pointer to the register block"]
1665 #[inline(always)]
1666 pub const fn ptr() -> *const wdog0::RegisterBlock {
1667 Self::PTR
1668 }
1669}
1670impl Deref for WDOG0 {
1671 type Target = wdog0::RegisterBlock;
1672 #[inline(always)]
1673 fn deref(&self) -> &Self::Target {
1674 unsafe { &*Self::PTR }
1675 }
1676}
1677impl core::fmt::Debug for WDOG0 {
1678 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1679 f.debug_struct("WDOG0").finish()
1680 }
1681}
1682#[doc = "WDOG0"]
1683pub mod wdog0;
1684#[doc = "WDOG1"]
1685pub struct WDOG1 {
1686 _marker: PhantomData<*const ()>,
1687}
1688unsafe impl Send for WDOG1 {}
1689impl WDOG1 {
1690 #[doc = r"Pointer to the register block"]
1691 pub const PTR: *const wdog1::RegisterBlock = 0x4005_2400 as *const _;
1692 #[doc = r"Return the pointer to the register block"]
1693 #[inline(always)]
1694 pub const fn ptr() -> *const wdog1::RegisterBlock {
1695 Self::PTR
1696 }
1697}
1698impl Deref for WDOG1 {
1699 type Target = wdog1::RegisterBlock;
1700 #[inline(always)]
1701 fn deref(&self) -> &Self::Target {
1702 unsafe { &*Self::PTR }
1703 }
1704}
1705impl core::fmt::Debug for WDOG1 {
1706 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1707 f.debug_struct("WDOG1").finish()
1708 }
1709}
1710#[doc = "WDOG1"]
1711pub mod wdog1;
1712#[doc = "ETM"]
1713pub struct ETM {
1714 _marker: PhantomData<*const ()>,
1715}
1716unsafe impl Send for ETM {}
1717impl ETM {
1718 #[doc = r"Pointer to the register block"]
1719 pub const PTR: *const etm::RegisterBlock = 0xe004_1000 as *const _;
1720 #[doc = r"Return the pointer to the register block"]
1721 #[inline(always)]
1722 pub const fn ptr() -> *const etm::RegisterBlock {
1723 Self::PTR
1724 }
1725}
1726impl Deref for ETM {
1727 type Target = etm::RegisterBlock;
1728 #[inline(always)]
1729 fn deref(&self) -> &Self::Target {
1730 unsafe { &*Self::PTR }
1731 }
1732}
1733impl core::fmt::Debug for ETM {
1734 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1735 f.debug_struct("ETM").finish()
1736 }
1737}
1738#[doc = "ETM"]
1739pub mod etm;
1740#[doc = "SMU"]
1741pub struct SMU {
1742 _marker: PhantomData<*const ()>,
1743}
1744unsafe impl Send for SMU {}
1745impl SMU {
1746 #[doc = r"Pointer to the register block"]
1747 pub const PTR: *const smu::RegisterBlock = 0x4002_0000 as *const _;
1748 #[doc = r"Return the pointer to the register block"]
1749 #[inline(always)]
1750 pub const fn ptr() -> *const smu::RegisterBlock {
1751 Self::PTR
1752 }
1753}
1754impl Deref for SMU {
1755 type Target = smu::RegisterBlock;
1756 #[inline(always)]
1757 fn deref(&self) -> &Self::Target {
1758 unsafe { &*Self::PTR }
1759 }
1760}
1761impl core::fmt::Debug for SMU {
1762 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1763 f.debug_struct("SMU").finish()
1764 }
1765}
1766#[doc = "SMU"]
1767pub mod smu;
1768#[doc = "TRNG0"]
1769pub struct TRNG0 {
1770 _marker: PhantomData<*const ()>,
1771}
1772unsafe impl Send for TRNG0 {}
1773impl TRNG0 {
1774 #[doc = r"Pointer to the register block"]
1775 pub const PTR: *const trng0::RegisterBlock = 0x4001_d000 as *const _;
1776 #[doc = r"Return the pointer to the register block"]
1777 #[inline(always)]
1778 pub const fn ptr() -> *const trng0::RegisterBlock {
1779 Self::PTR
1780 }
1781}
1782impl Deref for TRNG0 {
1783 type Target = trng0::RegisterBlock;
1784 #[inline(always)]
1785 fn deref(&self) -> &Self::Target {
1786 unsafe { &*Self::PTR }
1787 }
1788}
1789impl core::fmt::Debug for TRNG0 {
1790 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1791 f.debug_struct("TRNG0").finish()
1792 }
1793}
1794#[doc = "TRNG0"]
1795pub mod trng0;
1796#[no_mangle]
1797static mut DEVICE_PERIPHERALS: bool = false;
1798#[doc = r"All the peripherals"]
1799#[allow(non_snake_case)]
1800pub struct Peripherals {
1801 #[doc = "MSC"]
1802 pub MSC: MSC,
1803 #[doc = "EMU"]
1804 pub EMU: EMU,
1805 #[doc = "RMU"]
1806 pub RMU: RMU,
1807 #[doc = "CMU"]
1808 pub CMU: CMU,
1809 #[doc = "CRYPTO0"]
1810 pub CRYPTO0: CRYPTO0,
1811 #[doc = "LESENSE"]
1812 pub LESENSE: LESENSE,
1813 #[doc = "EBI"]
1814 pub EBI: EBI,
1815 #[doc = "PDM"]
1816 pub PDM: PDM,
1817 #[doc = "GPIO"]
1818 pub GPIO: GPIO,
1819 #[doc = "PRS"]
1820 pub PRS: PRS,
1821 #[doc = "LDMA"]
1822 pub LDMA: LDMA,
1823 #[doc = "FPUEH"]
1824 pub FPUEH: FPUEH,
1825 #[doc = "GPCRC"]
1826 pub GPCRC: GPCRC,
1827 #[doc = "CAN0"]
1828 pub CAN0: CAN0,
1829 #[doc = "CAN1"]
1830 pub CAN1: CAN1,
1831 #[doc = "TIMER0"]
1832 pub TIMER0: TIMER0,
1833 #[doc = "TIMER1"]
1834 pub TIMER1: TIMER1,
1835 #[doc = "TIMER2"]
1836 pub TIMER2: TIMER2,
1837 #[doc = "TIMER3"]
1838 pub TIMER3: TIMER3,
1839 #[doc = "WTIMER0"]
1840 pub WTIMER0: WTIMER0,
1841 #[doc = "WTIMER1"]
1842 pub WTIMER1: WTIMER1,
1843 #[doc = "USART0"]
1844 pub USART0: USART0,
1845 #[doc = "USART1"]
1846 pub USART1: USART1,
1847 #[doc = "USART2"]
1848 pub USART2: USART2,
1849 #[doc = "USART3"]
1850 pub USART3: USART3,
1851 #[doc = "USART4"]
1852 pub USART4: USART4,
1853 #[doc = "UART0"]
1854 pub UART0: UART0,
1855 #[doc = "UART1"]
1856 pub UART1: UART1,
1857 #[doc = "LEUART0"]
1858 pub LEUART0: LEUART0,
1859 #[doc = "LEUART1"]
1860 pub LEUART1: LEUART1,
1861 #[doc = "LETIMER0"]
1862 pub LETIMER0: LETIMER0,
1863 #[doc = "LETIMER1"]
1864 pub LETIMER1: LETIMER1,
1865 #[doc = "CRYOTIMER"]
1866 pub CRYOTIMER: CRYOTIMER,
1867 #[doc = "PCNT0"]
1868 pub PCNT0: PCNT0,
1869 #[doc = "PCNT1"]
1870 pub PCNT1: PCNT1,
1871 #[doc = "PCNT2"]
1872 pub PCNT2: PCNT2,
1873 #[doc = "I2C0"]
1874 pub I2C0: I2C0,
1875 #[doc = "I2C1"]
1876 pub I2C1: I2C1,
1877 #[doc = "ADC0"]
1878 pub ADC0: ADC0,
1879 #[doc = "ADC1"]
1880 pub ADC1: ADC1,
1881 #[doc = "ACMP0"]
1882 pub ACMP0: ACMP0,
1883 #[doc = "ACMP1"]
1884 pub ACMP1: ACMP1,
1885 #[doc = "ACMP2"]
1886 pub ACMP2: ACMP2,
1887 #[doc = "VDAC0"]
1888 pub VDAC0: VDAC0,
1889 #[doc = "IDAC0"]
1890 pub IDAC0: IDAC0,
1891 #[doc = "CSEN"]
1892 pub CSEN: CSEN,
1893 #[doc = "RTC"]
1894 pub RTC: RTC,
1895 #[doc = "RTCC"]
1896 pub RTCC: RTCC,
1897 #[doc = "WDOG0"]
1898 pub WDOG0: WDOG0,
1899 #[doc = "WDOG1"]
1900 pub WDOG1: WDOG1,
1901 #[doc = "ETM"]
1902 pub ETM: ETM,
1903 #[doc = "SMU"]
1904 pub SMU: SMU,
1905 #[doc = "TRNG0"]
1906 pub TRNG0: TRNG0,
1907}
1908impl Peripherals {
1909 #[doc = r"Returns all the peripherals *once*"]
1910 #[inline]
1911 pub fn take() -> Option<Self> {
1912 cortex_m::interrupt::free(|_| {
1913 if unsafe { DEVICE_PERIPHERALS } {
1914 None
1915 } else {
1916 Some(unsafe { Peripherals::steal() })
1917 }
1918 })
1919 }
1920 #[doc = r"Unchecked version of `Peripherals::take`"]
1921 #[inline]
1922 pub unsafe fn steal() -> Self {
1923 DEVICE_PERIPHERALS = true;
1924 Peripherals {
1925 MSC: MSC {
1926 _marker: PhantomData,
1927 },
1928 EMU: EMU {
1929 _marker: PhantomData,
1930 },
1931 RMU: RMU {
1932 _marker: PhantomData,
1933 },
1934 CMU: CMU {
1935 _marker: PhantomData,
1936 },
1937 CRYPTO0: CRYPTO0 {
1938 _marker: PhantomData,
1939 },
1940 LESENSE: LESENSE {
1941 _marker: PhantomData,
1942 },
1943 EBI: EBI {
1944 _marker: PhantomData,
1945 },
1946 PDM: PDM {
1947 _marker: PhantomData,
1948 },
1949 GPIO: GPIO {
1950 _marker: PhantomData,
1951 },
1952 PRS: PRS {
1953 _marker: PhantomData,
1954 },
1955 LDMA: LDMA {
1956 _marker: PhantomData,
1957 },
1958 FPUEH: FPUEH {
1959 _marker: PhantomData,
1960 },
1961 GPCRC: GPCRC {
1962 _marker: PhantomData,
1963 },
1964 CAN0: CAN0 {
1965 _marker: PhantomData,
1966 },
1967 CAN1: CAN1 {
1968 _marker: PhantomData,
1969 },
1970 TIMER0: TIMER0 {
1971 _marker: PhantomData,
1972 },
1973 TIMER1: TIMER1 {
1974 _marker: PhantomData,
1975 },
1976 TIMER2: TIMER2 {
1977 _marker: PhantomData,
1978 },
1979 TIMER3: TIMER3 {
1980 _marker: PhantomData,
1981 },
1982 WTIMER0: WTIMER0 {
1983 _marker: PhantomData,
1984 },
1985 WTIMER1: WTIMER1 {
1986 _marker: PhantomData,
1987 },
1988 USART0: USART0 {
1989 _marker: PhantomData,
1990 },
1991 USART1: USART1 {
1992 _marker: PhantomData,
1993 },
1994 USART2: USART2 {
1995 _marker: PhantomData,
1996 },
1997 USART3: USART3 {
1998 _marker: PhantomData,
1999 },
2000 USART4: USART4 {
2001 _marker: PhantomData,
2002 },
2003 UART0: UART0 {
2004 _marker: PhantomData,
2005 },
2006 UART1: UART1 {
2007 _marker: PhantomData,
2008 },
2009 LEUART0: LEUART0 {
2010 _marker: PhantomData,
2011 },
2012 LEUART1: LEUART1 {
2013 _marker: PhantomData,
2014 },
2015 LETIMER0: LETIMER0 {
2016 _marker: PhantomData,
2017 },
2018 LETIMER1: LETIMER1 {
2019 _marker: PhantomData,
2020 },
2021 CRYOTIMER: CRYOTIMER {
2022 _marker: PhantomData,
2023 },
2024 PCNT0: PCNT0 {
2025 _marker: PhantomData,
2026 },
2027 PCNT1: PCNT1 {
2028 _marker: PhantomData,
2029 },
2030 PCNT2: PCNT2 {
2031 _marker: PhantomData,
2032 },
2033 I2C0: I2C0 {
2034 _marker: PhantomData,
2035 },
2036 I2C1: I2C1 {
2037 _marker: PhantomData,
2038 },
2039 ADC0: ADC0 {
2040 _marker: PhantomData,
2041 },
2042 ADC1: ADC1 {
2043 _marker: PhantomData,
2044 },
2045 ACMP0: ACMP0 {
2046 _marker: PhantomData,
2047 },
2048 ACMP1: ACMP1 {
2049 _marker: PhantomData,
2050 },
2051 ACMP2: ACMP2 {
2052 _marker: PhantomData,
2053 },
2054 VDAC0: VDAC0 {
2055 _marker: PhantomData,
2056 },
2057 IDAC0: IDAC0 {
2058 _marker: PhantomData,
2059 },
2060 CSEN: CSEN {
2061 _marker: PhantomData,
2062 },
2063 RTC: RTC {
2064 _marker: PhantomData,
2065 },
2066 RTCC: RTCC {
2067 _marker: PhantomData,
2068 },
2069 WDOG0: WDOG0 {
2070 _marker: PhantomData,
2071 },
2072 WDOG1: WDOG1 {
2073 _marker: PhantomData,
2074 },
2075 ETM: ETM {
2076 _marker: PhantomData,
2077 },
2078 SMU: SMU {
2079 _marker: PhantomData,
2080 },
2081 TRNG0: TRNG0 {
2082 _marker: PhantomData,
2083 },
2084 }
2085 }
2086}