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