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