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