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