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