1#![doc = "Peripheral access API for EFM32GG12B330F512GL112 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 EMU();
38 fn WDOG0();
39 fn LDMA();
40 fn GPIO_EVEN();
41 fn SMU();
42 fn TIMER0();
43 fn USART0_RX();
44 fn USART0_TX();
45 fn ACMP0();
46 fn ADC0();
47 fn IDAC0();
48 fn I2C0();
49 fn I2C1();
50 fn GPIO_ODD();
51 fn TIMER1();
52 fn TIMER2();
53 fn TIMER3();
54 fn USART1_RX();
55 fn USART1_TX();
56 fn USART2_RX();
57 fn USART2_TX();
58 fn UART0_RX();
59 fn UART0_TX();
60 fn UART1_RX();
61 fn UART1_TX();
62 fn LEUART0();
63 fn LEUART1();
64 fn LETIMER0();
65 fn PCNT0();
66 fn PCNT1();
67 fn PCNT2();
68 fn RTCC();
69 fn CMU();
70 fn MSC();
71 fn CRYPTO0();
72 fn CRYOTIMER();
73 fn FPUEH();
74 fn USART3_RX();
75 fn USART3_TX();
76 fn USART4_RX();
77 fn USART4_TX();
78 fn WTIMER0();
79 fn WTIMER1();
80 fn VDAC0();
81 fn CSEN();
82 fn LESENSE();
83 fn EBI();
84 fn ACMP2();
85 fn ADC1();
86 fn LCD();
87 fn CAN0();
88 fn CAN1();
89 fn RTC();
90 fn WDOG1();
91 fn LETIMER1();
92 fn TRNG0();
93 fn PDM();
94}
95#[doc(hidden)]
96pub union Vector {
97 _handler: unsafe extern "C" fn(),
98 _reserved: u32,
99}
100#[cfg(feature = "rt")]
101#[doc(hidden)]
102#[link_section = ".vector_table.interrupts"]
103#[no_mangle]
104pub static __INTERRUPTS: [Vector; 60] = [
105 Vector { _handler: EMU },
106 Vector { _handler: WDOG0 },
107 Vector { _handler: LDMA },
108 Vector {
109 _handler: GPIO_EVEN,
110 },
111 Vector { _handler: SMU },
112 Vector { _handler: TIMER0 },
113 Vector {
114 _handler: USART0_RX,
115 },
116 Vector {
117 _handler: USART0_TX,
118 },
119 Vector { _handler: ACMP0 },
120 Vector { _handler: ADC0 },
121 Vector { _handler: IDAC0 },
122 Vector { _handler: I2C0 },
123 Vector { _handler: I2C1 },
124 Vector { _handler: GPIO_ODD },
125 Vector { _handler: TIMER1 },
126 Vector { _handler: TIMER2 },
127 Vector { _handler: TIMER3 },
128 Vector {
129 _handler: USART1_RX,
130 },
131 Vector {
132 _handler: USART1_TX,
133 },
134 Vector {
135 _handler: USART2_RX,
136 },
137 Vector {
138 _handler: USART2_TX,
139 },
140 Vector { _handler: UART0_RX },
141 Vector { _handler: UART0_TX },
142 Vector { _handler: UART1_RX },
143 Vector { _handler: UART1_TX },
144 Vector { _handler: LEUART0 },
145 Vector { _handler: LEUART1 },
146 Vector { _handler: LETIMER0 },
147 Vector { _handler: PCNT0 },
148 Vector { _handler: PCNT1 },
149 Vector { _handler: PCNT2 },
150 Vector { _handler: RTCC },
151 Vector { _handler: CMU },
152 Vector { _handler: MSC },
153 Vector { _handler: CRYPTO0 },
154 Vector {
155 _handler: CRYOTIMER,
156 },
157 Vector { _handler: FPUEH },
158 Vector {
159 _handler: USART3_RX,
160 },
161 Vector {
162 _handler: USART3_TX,
163 },
164 Vector {
165 _handler: USART4_RX,
166 },
167 Vector {
168 _handler: USART4_TX,
169 },
170 Vector { _handler: WTIMER0 },
171 Vector { _handler: WTIMER1 },
172 Vector { _handler: VDAC0 },
173 Vector { _handler: CSEN },
174 Vector { _handler: LESENSE },
175 Vector { _handler: EBI },
176 Vector { _handler: ACMP2 },
177 Vector { _handler: ADC1 },
178 Vector { _handler: LCD },
179 Vector { _reserved: 0 },
180 Vector { _handler: CAN0 },
181 Vector { _handler: CAN1 },
182 Vector { _reserved: 0 },
183 Vector { _handler: RTC },
184 Vector { _handler: WDOG1 },
185 Vector { _handler: LETIMER1 },
186 Vector { _handler: TRNG0 },
187 Vector { _reserved: 0 },
188 Vector { _handler: PDM },
189];
190#[doc = r"Enumeration of all the interrupts."]
191#[derive(Copy, Clone, Debug, PartialEq, Eq)]
192#[repr(u16)]
193pub enum Interrupt {
194 #[doc = "0 - EMU"]
195 EMU = 0,
196 #[doc = "1 - WDOG0"]
197 WDOG0 = 1,
198 #[doc = "2 - LDMA"]
199 LDMA = 2,
200 #[doc = "3 - GPIO_EVEN"]
201 GPIO_EVEN = 3,
202 #[doc = "4 - SMU"]
203 SMU = 4,
204 #[doc = "5 - TIMER0"]
205 TIMER0 = 5,
206 #[doc = "6 - USART0_RX"]
207 USART0_RX = 6,
208 #[doc = "7 - USART0_TX"]
209 USART0_TX = 7,
210 #[doc = "8 - ACMP0"]
211 ACMP0 = 8,
212 #[doc = "9 - ADC0"]
213 ADC0 = 9,
214 #[doc = "10 - IDAC0"]
215 IDAC0 = 10,
216 #[doc = "11 - I2C0"]
217 I2C0 = 11,
218 #[doc = "12 - I2C1"]
219 I2C1 = 12,
220 #[doc = "13 - GPIO_ODD"]
221 GPIO_ODD = 13,
222 #[doc = "14 - TIMER1"]
223 TIMER1 = 14,
224 #[doc = "15 - TIMER2"]
225 TIMER2 = 15,
226 #[doc = "16 - TIMER3"]
227 TIMER3 = 16,
228 #[doc = "17 - USART1_RX"]
229 USART1_RX = 17,
230 #[doc = "18 - USART1_TX"]
231 USART1_TX = 18,
232 #[doc = "19 - USART2_RX"]
233 USART2_RX = 19,
234 #[doc = "20 - USART2_TX"]
235 USART2_TX = 20,
236 #[doc = "21 - UART0_RX"]
237 UART0_RX = 21,
238 #[doc = "22 - UART0_TX"]
239 UART0_TX = 22,
240 #[doc = "23 - UART1_RX"]
241 UART1_RX = 23,
242 #[doc = "24 - UART1_TX"]
243 UART1_TX = 24,
244 #[doc = "25 - LEUART0"]
245 LEUART0 = 25,
246 #[doc = "26 - LEUART1"]
247 LEUART1 = 26,
248 #[doc = "27 - LETIMER0"]
249 LETIMER0 = 27,
250 #[doc = "28 - PCNT0"]
251 PCNT0 = 28,
252 #[doc = "29 - PCNT1"]
253 PCNT1 = 29,
254 #[doc = "30 - PCNT2"]
255 PCNT2 = 30,
256 #[doc = "31 - RTCC"]
257 RTCC = 31,
258 #[doc = "32 - CMU"]
259 CMU = 32,
260 #[doc = "33 - MSC"]
261 MSC = 33,
262 #[doc = "34 - CRYPTO0"]
263 CRYPTO0 = 34,
264 #[doc = "35 - CRYOTIMER"]
265 CRYOTIMER = 35,
266 #[doc = "36 - FPUEH"]
267 FPUEH = 36,
268 #[doc = "37 - USART3_RX"]
269 USART3_RX = 37,
270 #[doc = "38 - USART3_TX"]
271 USART3_TX = 38,
272 #[doc = "39 - USART4_RX"]
273 USART4_RX = 39,
274 #[doc = "40 - USART4_TX"]
275 USART4_TX = 40,
276 #[doc = "41 - WTIMER0"]
277 WTIMER0 = 41,
278 #[doc = "42 - WTIMER1"]
279 WTIMER1 = 42,
280 #[doc = "43 - VDAC0"]
281 VDAC0 = 43,
282 #[doc = "44 - CSEN"]
283 CSEN = 44,
284 #[doc = "45 - LESENSE"]
285 LESENSE = 45,
286 #[doc = "46 - EBI"]
287 EBI = 46,
288 #[doc = "47 - ACMP2"]
289 ACMP2 = 47,
290 #[doc = "48 - ADC1"]
291 ADC1 = 48,
292 #[doc = "49 - LCD"]
293 LCD = 49,
294 #[doc = "51 - CAN0"]
295 CAN0 = 51,
296 #[doc = "52 - CAN1"]
297 CAN1 = 52,
298 #[doc = "54 - RTC"]
299 RTC = 54,
300 #[doc = "55 - WDOG1"]
301 WDOG1 = 55,
302 #[doc = "56 - LETIMER1"]
303 LETIMER1 = 56,
304 #[doc = "57 - TRNG0"]
305 TRNG0 = 57,
306 #[doc = "59 - PDM"]
307 PDM = 59,
308}
309unsafe impl cortex_m::interrupt::InterruptNumber for Interrupt {
310 #[inline(always)]
311 fn number(self) -> u16 {
312 self as u16
313 }
314}
315#[doc = "MSC"]
316pub struct MSC {
317 _marker: PhantomData<*const ()>,
318}
319unsafe impl Send for MSC {}
320impl MSC {
321 #[doc = r"Pointer to the register block"]
322 pub const PTR: *const msc::RegisterBlock = 0x4000_0000 as *const _;
323 #[doc = r"Return the pointer to the register block"]
324 #[inline(always)]
325 pub const fn ptr() -> *const msc::RegisterBlock {
326 Self::PTR
327 }
328}
329impl Deref for MSC {
330 type Target = msc::RegisterBlock;
331 #[inline(always)]
332 fn deref(&self) -> &Self::Target {
333 unsafe { &*Self::PTR }
334 }
335}
336impl core::fmt::Debug for MSC {
337 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
338 f.debug_struct("MSC").finish()
339 }
340}
341#[doc = "MSC"]
342pub mod msc;
343#[doc = "EMU"]
344pub struct EMU {
345 _marker: PhantomData<*const ()>,
346}
347unsafe impl Send for EMU {}
348impl EMU {
349 #[doc = r"Pointer to the register block"]
350 pub const PTR: *const emu::RegisterBlock = 0x400e_3000 as *const _;
351 #[doc = r"Return the pointer to the register block"]
352 #[inline(always)]
353 pub const fn ptr() -> *const emu::RegisterBlock {
354 Self::PTR
355 }
356}
357impl Deref for EMU {
358 type Target = emu::RegisterBlock;
359 #[inline(always)]
360 fn deref(&self) -> &Self::Target {
361 unsafe { &*Self::PTR }
362 }
363}
364impl core::fmt::Debug for EMU {
365 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
366 f.debug_struct("EMU").finish()
367 }
368}
369#[doc = "EMU"]
370pub mod emu;
371#[doc = "RMU"]
372pub struct RMU {
373 _marker: PhantomData<*const ()>,
374}
375unsafe impl Send for RMU {}
376impl RMU {
377 #[doc = r"Pointer to the register block"]
378 pub const PTR: *const rmu::RegisterBlock = 0x400e_5000 as *const _;
379 #[doc = r"Return the pointer to the register block"]
380 #[inline(always)]
381 pub const fn ptr() -> *const rmu::RegisterBlock {
382 Self::PTR
383 }
384}
385impl Deref for RMU {
386 type Target = rmu::RegisterBlock;
387 #[inline(always)]
388 fn deref(&self) -> &Self::Target {
389 unsafe { &*Self::PTR }
390 }
391}
392impl core::fmt::Debug for RMU {
393 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
394 f.debug_struct("RMU").finish()
395 }
396}
397#[doc = "RMU"]
398pub mod rmu;
399#[doc = "CMU"]
400pub struct CMU {
401 _marker: PhantomData<*const ()>,
402}
403unsafe impl Send for CMU {}
404impl CMU {
405 #[doc = r"Pointer to the register block"]
406 pub const PTR: *const cmu::RegisterBlock = 0x400e_4000 as *const _;
407 #[doc = r"Return the pointer to the register block"]
408 #[inline(always)]
409 pub const fn ptr() -> *const cmu::RegisterBlock {
410 Self::PTR
411 }
412}
413impl Deref for CMU {
414 type Target = cmu::RegisterBlock;
415 #[inline(always)]
416 fn deref(&self) -> &Self::Target {
417 unsafe { &*Self::PTR }
418 }
419}
420impl core::fmt::Debug for CMU {
421 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
422 f.debug_struct("CMU").finish()
423 }
424}
425#[doc = "CMU"]
426pub mod cmu;
427#[doc = "CRYPTO0"]
428pub struct CRYPTO0 {
429 _marker: PhantomData<*const ()>,
430}
431unsafe impl Send for CRYPTO0 {}
432impl CRYPTO0 {
433 #[doc = r"Pointer to the register block"]
434 pub const PTR: *const crypto0::RegisterBlock = 0x400f_0000 as *const _;
435 #[doc = r"Return the pointer to the register block"]
436 #[inline(always)]
437 pub const fn ptr() -> *const crypto0::RegisterBlock {
438 Self::PTR
439 }
440}
441impl Deref for CRYPTO0 {
442 type Target = crypto0::RegisterBlock;
443 #[inline(always)]
444 fn deref(&self) -> &Self::Target {
445 unsafe { &*Self::PTR }
446 }
447}
448impl core::fmt::Debug for CRYPTO0 {
449 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
450 f.debug_struct("CRYPTO0").finish()
451 }
452}
453#[doc = "CRYPTO0"]
454pub mod crypto0;
455#[doc = "LESENSE"]
456pub struct LESENSE {
457 _marker: PhantomData<*const ()>,
458}
459unsafe impl Send for LESENSE {}
460impl LESENSE {
461 #[doc = r"Pointer to the register block"]
462 pub const PTR: *const lesense::RegisterBlock = 0x4005_5000 as *const _;
463 #[doc = r"Return the pointer to the register block"]
464 #[inline(always)]
465 pub const fn ptr() -> *const lesense::RegisterBlock {
466 Self::PTR
467 }
468}
469impl Deref for LESENSE {
470 type Target = lesense::RegisterBlock;
471 #[inline(always)]
472 fn deref(&self) -> &Self::Target {
473 unsafe { &*Self::PTR }
474 }
475}
476impl core::fmt::Debug for LESENSE {
477 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
478 f.debug_struct("LESENSE").finish()
479 }
480}
481#[doc = "LESENSE"]
482pub mod lesense;
483#[doc = "EBI"]
484pub struct EBI {
485 _marker: PhantomData<*const ()>,
486}
487unsafe impl Send for EBI {}
488impl EBI {
489 #[doc = r"Pointer to the register block"]
490 pub const PTR: *const ebi::RegisterBlock = 0x4000_b000 as *const _;
491 #[doc = r"Return the pointer to the register block"]
492 #[inline(always)]
493 pub const fn ptr() -> *const ebi::RegisterBlock {
494 Self::PTR
495 }
496}
497impl Deref for EBI {
498 type Target = ebi::RegisterBlock;
499 #[inline(always)]
500 fn deref(&self) -> &Self::Target {
501 unsafe { &*Self::PTR }
502 }
503}
504impl core::fmt::Debug for EBI {
505 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
506 f.debug_struct("EBI").finish()
507 }
508}
509#[doc = "EBI"]
510pub mod ebi;
511#[doc = "PDM"]
512pub struct PDM {
513 _marker: PhantomData<*const ()>,
514}
515unsafe impl Send for PDM {}
516impl PDM {
517 #[doc = r"Pointer to the register block"]
518 pub const PTR: *const pdm::RegisterBlock = 0x4002_8000 as *const _;
519 #[doc = r"Return the pointer to the register block"]
520 #[inline(always)]
521 pub const fn ptr() -> *const pdm::RegisterBlock {
522 Self::PTR
523 }
524}
525impl Deref for PDM {
526 type Target = pdm::RegisterBlock;
527 #[inline(always)]
528 fn deref(&self) -> &Self::Target {
529 unsafe { &*Self::PTR }
530 }
531}
532impl core::fmt::Debug for PDM {
533 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
534 f.debug_struct("PDM").finish()
535 }
536}
537#[doc = "PDM"]
538pub mod pdm;
539#[doc = "GPIO"]
540pub struct GPIO {
541 _marker: PhantomData<*const ()>,
542}
543unsafe impl Send for GPIO {}
544impl GPIO {
545 #[doc = r"Pointer to the register block"]
546 pub const PTR: *const gpio::RegisterBlock = 0x4008_8000 as *const _;
547 #[doc = r"Return the pointer to the register block"]
548 #[inline(always)]
549 pub const fn ptr() -> *const gpio::RegisterBlock {
550 Self::PTR
551 }
552}
553impl Deref for GPIO {
554 type Target = gpio::RegisterBlock;
555 #[inline(always)]
556 fn deref(&self) -> &Self::Target {
557 unsafe { &*Self::PTR }
558 }
559}
560impl core::fmt::Debug for GPIO {
561 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
562 f.debug_struct("GPIO").finish()
563 }
564}
565#[doc = "GPIO"]
566pub mod gpio;
567#[doc = "PRS"]
568pub struct PRS {
569 _marker: PhantomData<*const ()>,
570}
571unsafe impl Send for PRS {}
572impl PRS {
573 #[doc = r"Pointer to the register block"]
574 pub const PTR: *const prs::RegisterBlock = 0x400e_6000 as *const _;
575 #[doc = r"Return the pointer to the register block"]
576 #[inline(always)]
577 pub const fn ptr() -> *const prs::RegisterBlock {
578 Self::PTR
579 }
580}
581impl Deref for PRS {
582 type Target = prs::RegisterBlock;
583 #[inline(always)]
584 fn deref(&self) -> &Self::Target {
585 unsafe { &*Self::PTR }
586 }
587}
588impl core::fmt::Debug for PRS {
589 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
590 f.debug_struct("PRS").finish()
591 }
592}
593#[doc = "PRS"]
594pub mod prs;
595#[doc = "LDMA"]
596pub struct LDMA {
597 _marker: PhantomData<*const ()>,
598}
599unsafe impl Send for LDMA {}
600impl LDMA {
601 #[doc = r"Pointer to the register block"]
602 pub const PTR: *const ldma::RegisterBlock = 0x4000_2000 as *const _;
603 #[doc = r"Return the pointer to the register block"]
604 #[inline(always)]
605 pub const fn ptr() -> *const ldma::RegisterBlock {
606 Self::PTR
607 }
608}
609impl Deref for LDMA {
610 type Target = ldma::RegisterBlock;
611 #[inline(always)]
612 fn deref(&self) -> &Self::Target {
613 unsafe { &*Self::PTR }
614 }
615}
616impl core::fmt::Debug for LDMA {
617 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
618 f.debug_struct("LDMA").finish()
619 }
620}
621#[doc = "LDMA"]
622pub mod ldma;
623#[doc = "FPUEH"]
624pub struct FPUEH {
625 _marker: PhantomData<*const ()>,
626}
627unsafe impl Send for FPUEH {}
628impl FPUEH {
629 #[doc = r"Pointer to the register block"]
630 pub const PTR: *const fpueh::RegisterBlock = 0x4000_1000 as *const _;
631 #[doc = r"Return the pointer to the register block"]
632 #[inline(always)]
633 pub const fn ptr() -> *const fpueh::RegisterBlock {
634 Self::PTR
635 }
636}
637impl Deref for FPUEH {
638 type Target = fpueh::RegisterBlock;
639 #[inline(always)]
640 fn deref(&self) -> &Self::Target {
641 unsafe { &*Self::PTR }
642 }
643}
644impl core::fmt::Debug for FPUEH {
645 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
646 f.debug_struct("FPUEH").finish()
647 }
648}
649#[doc = "FPUEH"]
650pub mod fpueh;
651#[doc = "GPCRC"]
652pub struct GPCRC {
653 _marker: PhantomData<*const ()>,
654}
655unsafe impl Send for GPCRC {}
656impl GPCRC {
657 #[doc = r"Pointer to the register block"]
658 pub const PTR: *const gpcrc::RegisterBlock = 0x4001_c000 as *const _;
659 #[doc = r"Return the pointer to the register block"]
660 #[inline(always)]
661 pub const fn ptr() -> *const gpcrc::RegisterBlock {
662 Self::PTR
663 }
664}
665impl Deref for GPCRC {
666 type Target = gpcrc::RegisterBlock;
667 #[inline(always)]
668 fn deref(&self) -> &Self::Target {
669 unsafe { &*Self::PTR }
670 }
671}
672impl core::fmt::Debug for GPCRC {
673 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
674 f.debug_struct("GPCRC").finish()
675 }
676}
677#[doc = "GPCRC"]
678pub mod gpcrc;
679#[doc = "CAN0"]
680pub struct CAN0 {
681 _marker: PhantomData<*const ()>,
682}
683unsafe impl Send for CAN0 {}
684impl CAN0 {
685 #[doc = r"Pointer to the register block"]
686 pub const PTR: *const can0::RegisterBlock = 0x4000_4000 as *const _;
687 #[doc = r"Return the pointer to the register block"]
688 #[inline(always)]
689 pub const fn ptr() -> *const can0::RegisterBlock {
690 Self::PTR
691 }
692}
693impl Deref for CAN0 {
694 type Target = can0::RegisterBlock;
695 #[inline(always)]
696 fn deref(&self) -> &Self::Target {
697 unsafe { &*Self::PTR }
698 }
699}
700impl core::fmt::Debug for CAN0 {
701 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
702 f.debug_struct("CAN0").finish()
703 }
704}
705#[doc = "CAN0"]
706pub mod can0;
707#[doc = "CAN1"]
708pub struct CAN1 {
709 _marker: PhantomData<*const ()>,
710}
711unsafe impl Send for CAN1 {}
712impl CAN1 {
713 #[doc = r"Pointer to the register block"]
714 pub const PTR: *const can1::RegisterBlock = 0x4000_4400 as *const _;
715 #[doc = r"Return the pointer to the register block"]
716 #[inline(always)]
717 pub const fn ptr() -> *const can1::RegisterBlock {
718 Self::PTR
719 }
720}
721impl Deref for CAN1 {
722 type Target = can1::RegisterBlock;
723 #[inline(always)]
724 fn deref(&self) -> &Self::Target {
725 unsafe { &*Self::PTR }
726 }
727}
728impl core::fmt::Debug for CAN1 {
729 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
730 f.debug_struct("CAN1").finish()
731 }
732}
733#[doc = "CAN1"]
734pub mod can1;
735#[doc = "TIMER0"]
736pub struct TIMER0 {
737 _marker: PhantomData<*const ()>,
738}
739unsafe impl Send for TIMER0 {}
740impl TIMER0 {
741 #[doc = r"Pointer to the register block"]
742 pub const PTR: *const timer0::RegisterBlock = 0x4001_8000 as *const _;
743 #[doc = r"Return the pointer to the register block"]
744 #[inline(always)]
745 pub const fn ptr() -> *const timer0::RegisterBlock {
746 Self::PTR
747 }
748}
749impl Deref for TIMER0 {
750 type Target = timer0::RegisterBlock;
751 #[inline(always)]
752 fn deref(&self) -> &Self::Target {
753 unsafe { &*Self::PTR }
754 }
755}
756impl core::fmt::Debug for TIMER0 {
757 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
758 f.debug_struct("TIMER0").finish()
759 }
760}
761#[doc = "TIMER0"]
762pub mod timer0;
763#[doc = "TIMER1"]
764pub struct TIMER1 {
765 _marker: PhantomData<*const ()>,
766}
767unsafe impl Send for TIMER1 {}
768impl TIMER1 {
769 #[doc = r"Pointer to the register block"]
770 pub const PTR: *const timer1::RegisterBlock = 0x4001_8400 as *const _;
771 #[doc = r"Return the pointer to the register block"]
772 #[inline(always)]
773 pub const fn ptr() -> *const timer1::RegisterBlock {
774 Self::PTR
775 }
776}
777impl Deref for TIMER1 {
778 type Target = timer1::RegisterBlock;
779 #[inline(always)]
780 fn deref(&self) -> &Self::Target {
781 unsafe { &*Self::PTR }
782 }
783}
784impl core::fmt::Debug for TIMER1 {
785 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
786 f.debug_struct("TIMER1").finish()
787 }
788}
789#[doc = "TIMER1"]
790pub mod timer1;
791#[doc = "TIMER2"]
792pub struct TIMER2 {
793 _marker: PhantomData<*const ()>,
794}
795unsafe impl Send for TIMER2 {}
796impl TIMER2 {
797 #[doc = r"Pointer to the register block"]
798 pub const PTR: *const timer2::RegisterBlock = 0x4001_8800 as *const _;
799 #[doc = r"Return the pointer to the register block"]
800 #[inline(always)]
801 pub const fn ptr() -> *const timer2::RegisterBlock {
802 Self::PTR
803 }
804}
805impl Deref for TIMER2 {
806 type Target = timer2::RegisterBlock;
807 #[inline(always)]
808 fn deref(&self) -> &Self::Target {
809 unsafe { &*Self::PTR }
810 }
811}
812impl core::fmt::Debug for TIMER2 {
813 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
814 f.debug_struct("TIMER2").finish()
815 }
816}
817#[doc = "TIMER2"]
818pub mod timer2;
819#[doc = "TIMER3"]
820pub struct TIMER3 {
821 _marker: PhantomData<*const ()>,
822}
823unsafe impl Send for TIMER3 {}
824impl TIMER3 {
825 #[doc = r"Pointer to the register block"]
826 pub const PTR: *const timer3::RegisterBlock = 0x4001_8c00 as *const _;
827 #[doc = r"Return the pointer to the register block"]
828 #[inline(always)]
829 pub const fn ptr() -> *const timer3::RegisterBlock {
830 Self::PTR
831 }
832}
833impl Deref for TIMER3 {
834 type Target = timer3::RegisterBlock;
835 #[inline(always)]
836 fn deref(&self) -> &Self::Target {
837 unsafe { &*Self::PTR }
838 }
839}
840impl core::fmt::Debug for TIMER3 {
841 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
842 f.debug_struct("TIMER3").finish()
843 }
844}
845#[doc = "TIMER3"]
846pub mod timer3;
847#[doc = "WTIMER0"]
848pub struct WTIMER0 {
849 _marker: PhantomData<*const ()>,
850}
851unsafe impl Send for WTIMER0 {}
852impl WTIMER0 {
853 #[doc = r"Pointer to the register block"]
854 pub const PTR: *const wtimer0::RegisterBlock = 0x4001_a000 as *const _;
855 #[doc = r"Return the pointer to the register block"]
856 #[inline(always)]
857 pub const fn ptr() -> *const wtimer0::RegisterBlock {
858 Self::PTR
859 }
860}
861impl Deref for WTIMER0 {
862 type Target = wtimer0::RegisterBlock;
863 #[inline(always)]
864 fn deref(&self) -> &Self::Target {
865 unsafe { &*Self::PTR }
866 }
867}
868impl core::fmt::Debug for WTIMER0 {
869 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
870 f.debug_struct("WTIMER0").finish()
871 }
872}
873#[doc = "WTIMER0"]
874pub mod wtimer0;
875#[doc = "WTIMER1"]
876pub struct WTIMER1 {
877 _marker: PhantomData<*const ()>,
878}
879unsafe impl Send for WTIMER1 {}
880impl WTIMER1 {
881 #[doc = r"Pointer to the register block"]
882 pub const PTR: *const wtimer1::RegisterBlock = 0x4001_a400 as *const _;
883 #[doc = r"Return the pointer to the register block"]
884 #[inline(always)]
885 pub const fn ptr() -> *const wtimer1::RegisterBlock {
886 Self::PTR
887 }
888}
889impl Deref for WTIMER1 {
890 type Target = wtimer1::RegisterBlock;
891 #[inline(always)]
892 fn deref(&self) -> &Self::Target {
893 unsafe { &*Self::PTR }
894 }
895}
896impl core::fmt::Debug for WTIMER1 {
897 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
898 f.debug_struct("WTIMER1").finish()
899 }
900}
901#[doc = "WTIMER1"]
902pub mod wtimer1;
903#[doc = "USART0"]
904pub struct USART0 {
905 _marker: PhantomData<*const ()>,
906}
907unsafe impl Send for USART0 {}
908impl USART0 {
909 #[doc = r"Pointer to the register block"]
910 pub const PTR: *const usart0::RegisterBlock = 0x4001_0000 as *const _;
911 #[doc = r"Return the pointer to the register block"]
912 #[inline(always)]
913 pub const fn ptr() -> *const usart0::RegisterBlock {
914 Self::PTR
915 }
916}
917impl Deref for USART0 {
918 type Target = usart0::RegisterBlock;
919 #[inline(always)]
920 fn deref(&self) -> &Self::Target {
921 unsafe { &*Self::PTR }
922 }
923}
924impl core::fmt::Debug for USART0 {
925 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
926 f.debug_struct("USART0").finish()
927 }
928}
929#[doc = "USART0"]
930pub mod usart0;
931#[doc = "USART1"]
932pub struct USART1 {
933 _marker: PhantomData<*const ()>,
934}
935unsafe impl Send for USART1 {}
936impl USART1 {
937 #[doc = r"Pointer to the register block"]
938 pub const PTR: *const usart1::RegisterBlock = 0x4001_0400 as *const _;
939 #[doc = r"Return the pointer to the register block"]
940 #[inline(always)]
941 pub const fn ptr() -> *const usart1::RegisterBlock {
942 Self::PTR
943 }
944}
945impl Deref for USART1 {
946 type Target = usart1::RegisterBlock;
947 #[inline(always)]
948 fn deref(&self) -> &Self::Target {
949 unsafe { &*Self::PTR }
950 }
951}
952impl core::fmt::Debug for USART1 {
953 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
954 f.debug_struct("USART1").finish()
955 }
956}
957#[doc = "USART1"]
958pub mod usart1;
959#[doc = "USART2"]
960pub struct USART2 {
961 _marker: PhantomData<*const ()>,
962}
963unsafe impl Send for USART2 {}
964impl USART2 {
965 #[doc = r"Pointer to the register block"]
966 pub const PTR: *const usart2::RegisterBlock = 0x4001_0800 as *const _;
967 #[doc = r"Return the pointer to the register block"]
968 #[inline(always)]
969 pub const fn ptr() -> *const usart2::RegisterBlock {
970 Self::PTR
971 }
972}
973impl Deref for USART2 {
974 type Target = usart2::RegisterBlock;
975 #[inline(always)]
976 fn deref(&self) -> &Self::Target {
977 unsafe { &*Self::PTR }
978 }
979}
980impl core::fmt::Debug for USART2 {
981 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
982 f.debug_struct("USART2").finish()
983 }
984}
985#[doc = "USART2"]
986pub mod usart2;
987#[doc = "USART3"]
988pub struct USART3 {
989 _marker: PhantomData<*const ()>,
990}
991unsafe impl Send for USART3 {}
992impl USART3 {
993 #[doc = r"Pointer to the register block"]
994 pub const PTR: *const usart3::RegisterBlock = 0x4001_0c00 as *const _;
995 #[doc = r"Return the pointer to the register block"]
996 #[inline(always)]
997 pub const fn ptr() -> *const usart3::RegisterBlock {
998 Self::PTR
999 }
1000}
1001impl Deref for USART3 {
1002 type Target = usart3::RegisterBlock;
1003 #[inline(always)]
1004 fn deref(&self) -> &Self::Target {
1005 unsafe { &*Self::PTR }
1006 }
1007}
1008impl core::fmt::Debug for USART3 {
1009 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1010 f.debug_struct("USART3").finish()
1011 }
1012}
1013#[doc = "USART3"]
1014pub mod usart3;
1015#[doc = "USART4"]
1016pub struct USART4 {
1017 _marker: PhantomData<*const ()>,
1018}
1019unsafe impl Send for USART4 {}
1020impl USART4 {
1021 #[doc = r"Pointer to the register block"]
1022 pub const PTR: *const usart4::RegisterBlock = 0x4001_1000 as *const _;
1023 #[doc = r"Return the pointer to the register block"]
1024 #[inline(always)]
1025 pub const fn ptr() -> *const usart4::RegisterBlock {
1026 Self::PTR
1027 }
1028}
1029impl Deref for USART4 {
1030 type Target = usart4::RegisterBlock;
1031 #[inline(always)]
1032 fn deref(&self) -> &Self::Target {
1033 unsafe { &*Self::PTR }
1034 }
1035}
1036impl core::fmt::Debug for USART4 {
1037 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1038 f.debug_struct("USART4").finish()
1039 }
1040}
1041#[doc = "USART4"]
1042pub mod usart4;
1043#[doc = "UART0"]
1044pub struct UART0 {
1045 _marker: PhantomData<*const ()>,
1046}
1047unsafe impl Send for UART0 {}
1048impl UART0 {
1049 #[doc = r"Pointer to the register block"]
1050 pub const PTR: *const uart0::RegisterBlock = 0x4001_4000 as *const _;
1051 #[doc = r"Return the pointer to the register block"]
1052 #[inline(always)]
1053 pub const fn ptr() -> *const uart0::RegisterBlock {
1054 Self::PTR
1055 }
1056}
1057impl Deref for UART0 {
1058 type Target = uart0::RegisterBlock;
1059 #[inline(always)]
1060 fn deref(&self) -> &Self::Target {
1061 unsafe { &*Self::PTR }
1062 }
1063}
1064impl core::fmt::Debug for UART0 {
1065 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1066 f.debug_struct("UART0").finish()
1067 }
1068}
1069#[doc = "UART0"]
1070pub mod uart0;
1071#[doc = "UART1"]
1072pub struct UART1 {
1073 _marker: PhantomData<*const ()>,
1074}
1075unsafe impl Send for UART1 {}
1076impl UART1 {
1077 #[doc = r"Pointer to the register block"]
1078 pub const PTR: *const uart1::RegisterBlock = 0x4001_4400 as *const _;
1079 #[doc = r"Return the pointer to the register block"]
1080 #[inline(always)]
1081 pub const fn ptr() -> *const uart1::RegisterBlock {
1082 Self::PTR
1083 }
1084}
1085impl Deref for UART1 {
1086 type Target = uart1::RegisterBlock;
1087 #[inline(always)]
1088 fn deref(&self) -> &Self::Target {
1089 unsafe { &*Self::PTR }
1090 }
1091}
1092impl core::fmt::Debug for UART1 {
1093 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1094 f.debug_struct("UART1").finish()
1095 }
1096}
1097#[doc = "UART1"]
1098pub mod uart1;
1099#[doc = "LEUART0"]
1100pub struct LEUART0 {
1101 _marker: PhantomData<*const ()>,
1102}
1103unsafe impl Send for LEUART0 {}
1104impl LEUART0 {
1105 #[doc = r"Pointer to the register block"]
1106 pub const PTR: *const leuart0::RegisterBlock = 0x4006_a000 as *const _;
1107 #[doc = r"Return the pointer to the register block"]
1108 #[inline(always)]
1109 pub const fn ptr() -> *const leuart0::RegisterBlock {
1110 Self::PTR
1111 }
1112}
1113impl Deref for LEUART0 {
1114 type Target = leuart0::RegisterBlock;
1115 #[inline(always)]
1116 fn deref(&self) -> &Self::Target {
1117 unsafe { &*Self::PTR }
1118 }
1119}
1120impl core::fmt::Debug for LEUART0 {
1121 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1122 f.debug_struct("LEUART0").finish()
1123 }
1124}
1125#[doc = "LEUART0"]
1126pub mod leuart0;
1127#[doc = "LEUART1"]
1128pub struct LEUART1 {
1129 _marker: PhantomData<*const ()>,
1130}
1131unsafe impl Send for LEUART1 {}
1132impl LEUART1 {
1133 #[doc = r"Pointer to the register block"]
1134 pub const PTR: *const leuart1::RegisterBlock = 0x4006_a400 as *const _;
1135 #[doc = r"Return the pointer to the register block"]
1136 #[inline(always)]
1137 pub const fn ptr() -> *const leuart1::RegisterBlock {
1138 Self::PTR
1139 }
1140}
1141impl Deref for LEUART1 {
1142 type Target = leuart1::RegisterBlock;
1143 #[inline(always)]
1144 fn deref(&self) -> &Self::Target {
1145 unsafe { &*Self::PTR }
1146 }
1147}
1148impl core::fmt::Debug for LEUART1 {
1149 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1150 f.debug_struct("LEUART1").finish()
1151 }
1152}
1153#[doc = "LEUART1"]
1154pub mod leuart1;
1155#[doc = "LETIMER0"]
1156pub struct LETIMER0 {
1157 _marker: PhantomData<*const ()>,
1158}
1159unsafe impl Send for LETIMER0 {}
1160impl LETIMER0 {
1161 #[doc = r"Pointer to the register block"]
1162 pub const PTR: *const letimer0::RegisterBlock = 0x4006_6000 as *const _;
1163 #[doc = r"Return the pointer to the register block"]
1164 #[inline(always)]
1165 pub const fn ptr() -> *const letimer0::RegisterBlock {
1166 Self::PTR
1167 }
1168}
1169impl Deref for LETIMER0 {
1170 type Target = letimer0::RegisterBlock;
1171 #[inline(always)]
1172 fn deref(&self) -> &Self::Target {
1173 unsafe { &*Self::PTR }
1174 }
1175}
1176impl core::fmt::Debug for LETIMER0 {
1177 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1178 f.debug_struct("LETIMER0").finish()
1179 }
1180}
1181#[doc = "LETIMER0"]
1182pub mod letimer0;
1183#[doc = "LETIMER1"]
1184pub struct LETIMER1 {
1185 _marker: PhantomData<*const ()>,
1186}
1187unsafe impl Send for LETIMER1 {}
1188impl LETIMER1 {
1189 #[doc = r"Pointer to the register block"]
1190 pub const PTR: *const letimer1::RegisterBlock = 0x4006_6400 as *const _;
1191 #[doc = r"Return the pointer to the register block"]
1192 #[inline(always)]
1193 pub const fn ptr() -> *const letimer1::RegisterBlock {
1194 Self::PTR
1195 }
1196}
1197impl Deref for LETIMER1 {
1198 type Target = letimer1::RegisterBlock;
1199 #[inline(always)]
1200 fn deref(&self) -> &Self::Target {
1201 unsafe { &*Self::PTR }
1202 }
1203}
1204impl core::fmt::Debug for LETIMER1 {
1205 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1206 f.debug_struct("LETIMER1").finish()
1207 }
1208}
1209#[doc = "LETIMER1"]
1210pub mod letimer1;
1211#[doc = "CRYOTIMER"]
1212pub struct CRYOTIMER {
1213 _marker: PhantomData<*const ()>,
1214}
1215unsafe impl Send for CRYOTIMER {}
1216impl CRYOTIMER {
1217 #[doc = r"Pointer to the register block"]
1218 pub const PTR: *const cryotimer::RegisterBlock = 0x4008_f000 as *const _;
1219 #[doc = r"Return the pointer to the register block"]
1220 #[inline(always)]
1221 pub const fn ptr() -> *const cryotimer::RegisterBlock {
1222 Self::PTR
1223 }
1224}
1225impl Deref for CRYOTIMER {
1226 type Target = cryotimer::RegisterBlock;
1227 #[inline(always)]
1228 fn deref(&self) -> &Self::Target {
1229 unsafe { &*Self::PTR }
1230 }
1231}
1232impl core::fmt::Debug for CRYOTIMER {
1233 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1234 f.debug_struct("CRYOTIMER").finish()
1235 }
1236}
1237#[doc = "CRYOTIMER"]
1238pub mod cryotimer;
1239#[doc = "PCNT0"]
1240pub struct PCNT0 {
1241 _marker: PhantomData<*const ()>,
1242}
1243unsafe impl Send for PCNT0 {}
1244impl PCNT0 {
1245 #[doc = r"Pointer to the register block"]
1246 pub const PTR: *const pcnt0::RegisterBlock = 0x4006_e000 as *const _;
1247 #[doc = r"Return the pointer to the register block"]
1248 #[inline(always)]
1249 pub const fn ptr() -> *const pcnt0::RegisterBlock {
1250 Self::PTR
1251 }
1252}
1253impl Deref for PCNT0 {
1254 type Target = pcnt0::RegisterBlock;
1255 #[inline(always)]
1256 fn deref(&self) -> &Self::Target {
1257 unsafe { &*Self::PTR }
1258 }
1259}
1260impl core::fmt::Debug for PCNT0 {
1261 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1262 f.debug_struct("PCNT0").finish()
1263 }
1264}
1265#[doc = "PCNT0"]
1266pub mod pcnt0;
1267#[doc = "PCNT1"]
1268pub struct PCNT1 {
1269 _marker: PhantomData<*const ()>,
1270}
1271unsafe impl Send for PCNT1 {}
1272impl PCNT1 {
1273 #[doc = r"Pointer to the register block"]
1274 pub const PTR: *const pcnt1::RegisterBlock = 0x4006_e400 as *const _;
1275 #[doc = r"Return the pointer to the register block"]
1276 #[inline(always)]
1277 pub const fn ptr() -> *const pcnt1::RegisterBlock {
1278 Self::PTR
1279 }
1280}
1281impl Deref for PCNT1 {
1282 type Target = pcnt1::RegisterBlock;
1283 #[inline(always)]
1284 fn deref(&self) -> &Self::Target {
1285 unsafe { &*Self::PTR }
1286 }
1287}
1288impl core::fmt::Debug for PCNT1 {
1289 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1290 f.debug_struct("PCNT1").finish()
1291 }
1292}
1293#[doc = "PCNT1"]
1294pub mod pcnt1;
1295#[doc = "PCNT2"]
1296pub struct PCNT2 {
1297 _marker: PhantomData<*const ()>,
1298}
1299unsafe impl Send for PCNT2 {}
1300impl PCNT2 {
1301 #[doc = r"Pointer to the register block"]
1302 pub const PTR: *const pcnt2::RegisterBlock = 0x4006_e800 as *const _;
1303 #[doc = r"Return the pointer to the register block"]
1304 #[inline(always)]
1305 pub const fn ptr() -> *const pcnt2::RegisterBlock {
1306 Self::PTR
1307 }
1308}
1309impl Deref for PCNT2 {
1310 type Target = pcnt2::RegisterBlock;
1311 #[inline(always)]
1312 fn deref(&self) -> &Self::Target {
1313 unsafe { &*Self::PTR }
1314 }
1315}
1316impl core::fmt::Debug for PCNT2 {
1317 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1318 f.debug_struct("PCNT2").finish()
1319 }
1320}
1321#[doc = "PCNT2"]
1322pub mod pcnt2;
1323#[doc = "I2C0"]
1324pub struct I2C0 {
1325 _marker: PhantomData<*const ()>,
1326}
1327unsafe impl Send for I2C0 {}
1328impl I2C0 {
1329 #[doc = r"Pointer to the register block"]
1330 pub const PTR: *const i2c0::RegisterBlock = 0x4008_9000 as *const _;
1331 #[doc = r"Return the pointer to the register block"]
1332 #[inline(always)]
1333 pub const fn ptr() -> *const i2c0::RegisterBlock {
1334 Self::PTR
1335 }
1336}
1337impl Deref for I2C0 {
1338 type Target = i2c0::RegisterBlock;
1339 #[inline(always)]
1340 fn deref(&self) -> &Self::Target {
1341 unsafe { &*Self::PTR }
1342 }
1343}
1344impl core::fmt::Debug for I2C0 {
1345 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1346 f.debug_struct("I2C0").finish()
1347 }
1348}
1349#[doc = "I2C0"]
1350pub mod i2c0;
1351#[doc = "I2C1"]
1352pub struct I2C1 {
1353 _marker: PhantomData<*const ()>,
1354}
1355unsafe impl Send for I2C1 {}
1356impl I2C1 {
1357 #[doc = r"Pointer to the register block"]
1358 pub const PTR: *const i2c1::RegisterBlock = 0x4008_9400 as *const _;
1359 #[doc = r"Return the pointer to the register block"]
1360 #[inline(always)]
1361 pub const fn ptr() -> *const i2c1::RegisterBlock {
1362 Self::PTR
1363 }
1364}
1365impl Deref for I2C1 {
1366 type Target = i2c1::RegisterBlock;
1367 #[inline(always)]
1368 fn deref(&self) -> &Self::Target {
1369 unsafe { &*Self::PTR }
1370 }
1371}
1372impl core::fmt::Debug for I2C1 {
1373 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1374 f.debug_struct("I2C1").finish()
1375 }
1376}
1377#[doc = "I2C1"]
1378pub mod i2c1;
1379#[doc = "ADC0"]
1380pub struct ADC0 {
1381 _marker: PhantomData<*const ()>,
1382}
1383unsafe impl Send for ADC0 {}
1384impl ADC0 {
1385 #[doc = r"Pointer to the register block"]
1386 pub const PTR: *const adc0::RegisterBlock = 0x4008_2000 as *const _;
1387 #[doc = r"Return the pointer to the register block"]
1388 #[inline(always)]
1389 pub const fn ptr() -> *const adc0::RegisterBlock {
1390 Self::PTR
1391 }
1392}
1393impl Deref for ADC0 {
1394 type Target = adc0::RegisterBlock;
1395 #[inline(always)]
1396 fn deref(&self) -> &Self::Target {
1397 unsafe { &*Self::PTR }
1398 }
1399}
1400impl core::fmt::Debug for ADC0 {
1401 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1402 f.debug_struct("ADC0").finish()
1403 }
1404}
1405#[doc = "ADC0"]
1406pub mod adc0;
1407#[doc = "ADC1"]
1408pub struct ADC1 {
1409 _marker: PhantomData<*const ()>,
1410}
1411unsafe impl Send for ADC1 {}
1412impl ADC1 {
1413 #[doc = r"Pointer to the register block"]
1414 pub const PTR: *const adc1::RegisterBlock = 0x4008_2400 as *const _;
1415 #[doc = r"Return the pointer to the register block"]
1416 #[inline(always)]
1417 pub const fn ptr() -> *const adc1::RegisterBlock {
1418 Self::PTR
1419 }
1420}
1421impl Deref for ADC1 {
1422 type Target = adc1::RegisterBlock;
1423 #[inline(always)]
1424 fn deref(&self) -> &Self::Target {
1425 unsafe { &*Self::PTR }
1426 }
1427}
1428impl core::fmt::Debug for ADC1 {
1429 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1430 f.debug_struct("ADC1").finish()
1431 }
1432}
1433#[doc = "ADC1"]
1434pub mod adc1;
1435#[doc = "ACMP0"]
1436pub struct ACMP0 {
1437 _marker: PhantomData<*const ()>,
1438}
1439unsafe impl Send for ACMP0 {}
1440impl ACMP0 {
1441 #[doc = r"Pointer to the register block"]
1442 pub const PTR: *const acmp0::RegisterBlock = 0x4008_0000 as *const _;
1443 #[doc = r"Return the pointer to the register block"]
1444 #[inline(always)]
1445 pub const fn ptr() -> *const acmp0::RegisterBlock {
1446 Self::PTR
1447 }
1448}
1449impl Deref for ACMP0 {
1450 type Target = acmp0::RegisterBlock;
1451 #[inline(always)]
1452 fn deref(&self) -> &Self::Target {
1453 unsafe { &*Self::PTR }
1454 }
1455}
1456impl core::fmt::Debug for ACMP0 {
1457 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1458 f.debug_struct("ACMP0").finish()
1459 }
1460}
1461#[doc = "ACMP0"]
1462pub mod acmp0;
1463#[doc = "ACMP1"]
1464pub struct ACMP1 {
1465 _marker: PhantomData<*const ()>,
1466}
1467unsafe impl Send for ACMP1 {}
1468impl ACMP1 {
1469 #[doc = r"Pointer to the register block"]
1470 pub const PTR: *const acmp1::RegisterBlock = 0x4008_0400 as *const _;
1471 #[doc = r"Return the pointer to the register block"]
1472 #[inline(always)]
1473 pub const fn ptr() -> *const acmp1::RegisterBlock {
1474 Self::PTR
1475 }
1476}
1477impl Deref for ACMP1 {
1478 type Target = acmp1::RegisterBlock;
1479 #[inline(always)]
1480 fn deref(&self) -> &Self::Target {
1481 unsafe { &*Self::PTR }
1482 }
1483}
1484impl core::fmt::Debug for ACMP1 {
1485 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1486 f.debug_struct("ACMP1").finish()
1487 }
1488}
1489#[doc = "ACMP1"]
1490pub mod acmp1;
1491#[doc = "ACMP2"]
1492pub struct ACMP2 {
1493 _marker: PhantomData<*const ()>,
1494}
1495unsafe impl Send for ACMP2 {}
1496impl ACMP2 {
1497 #[doc = r"Pointer to the register block"]
1498 pub const PTR: *const acmp2::RegisterBlock = 0x4008_0800 as *const _;
1499 #[doc = r"Return the pointer to the register block"]
1500 #[inline(always)]
1501 pub const fn ptr() -> *const acmp2::RegisterBlock {
1502 Self::PTR
1503 }
1504}
1505impl Deref for ACMP2 {
1506 type Target = acmp2::RegisterBlock;
1507 #[inline(always)]
1508 fn deref(&self) -> &Self::Target {
1509 unsafe { &*Self::PTR }
1510 }
1511}
1512impl core::fmt::Debug for ACMP2 {
1513 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1514 f.debug_struct("ACMP2").finish()
1515 }
1516}
1517#[doc = "ACMP2"]
1518pub mod acmp2;
1519#[doc = "VDAC0"]
1520pub struct VDAC0 {
1521 _marker: PhantomData<*const ()>,
1522}
1523unsafe impl Send for VDAC0 {}
1524impl VDAC0 {
1525 #[doc = r"Pointer to the register block"]
1526 pub const PTR: *const vdac0::RegisterBlock = 0x4008_6000 as *const _;
1527 #[doc = r"Return the pointer to the register block"]
1528 #[inline(always)]
1529 pub const fn ptr() -> *const vdac0::RegisterBlock {
1530 Self::PTR
1531 }
1532}
1533impl Deref for VDAC0 {
1534 type Target = vdac0::RegisterBlock;
1535 #[inline(always)]
1536 fn deref(&self) -> &Self::Target {
1537 unsafe { &*Self::PTR }
1538 }
1539}
1540impl core::fmt::Debug for VDAC0 {
1541 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1542 f.debug_struct("VDAC0").finish()
1543 }
1544}
1545#[doc = "VDAC0"]
1546pub mod vdac0;
1547#[doc = "IDAC0"]
1548pub struct IDAC0 {
1549 _marker: PhantomData<*const ()>,
1550}
1551unsafe impl Send for IDAC0 {}
1552impl IDAC0 {
1553 #[doc = r"Pointer to the register block"]
1554 pub const PTR: *const idac0::RegisterBlock = 0x4008_4000 as *const _;
1555 #[doc = r"Return the pointer to the register block"]
1556 #[inline(always)]
1557 pub const fn ptr() -> *const idac0::RegisterBlock {
1558 Self::PTR
1559 }
1560}
1561impl Deref for IDAC0 {
1562 type Target = idac0::RegisterBlock;
1563 #[inline(always)]
1564 fn deref(&self) -> &Self::Target {
1565 unsafe { &*Self::PTR }
1566 }
1567}
1568impl core::fmt::Debug for IDAC0 {
1569 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1570 f.debug_struct("IDAC0").finish()
1571 }
1572}
1573#[doc = "IDAC0"]
1574pub mod idac0;
1575#[doc = "CSEN"]
1576pub struct CSEN {
1577 _marker: PhantomData<*const ()>,
1578}
1579unsafe impl Send for CSEN {}
1580impl CSEN {
1581 #[doc = r"Pointer to the register block"]
1582 pub const PTR: *const csen::RegisterBlock = 0x4008_e000 as *const _;
1583 #[doc = r"Return the pointer to the register block"]
1584 #[inline(always)]
1585 pub const fn ptr() -> *const csen::RegisterBlock {
1586 Self::PTR
1587 }
1588}
1589impl Deref for CSEN {
1590 type Target = csen::RegisterBlock;
1591 #[inline(always)]
1592 fn deref(&self) -> &Self::Target {
1593 unsafe { &*Self::PTR }
1594 }
1595}
1596impl core::fmt::Debug for CSEN {
1597 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1598 f.debug_struct("CSEN").finish()
1599 }
1600}
1601#[doc = "CSEN"]
1602pub mod csen;
1603#[doc = "LCD"]
1604pub struct LCD {
1605 _marker: PhantomData<*const ()>,
1606}
1607unsafe impl Send for LCD {}
1608impl LCD {
1609 #[doc = r"Pointer to the register block"]
1610 pub const PTR: *const lcd::RegisterBlock = 0x4005_4000 as *const _;
1611 #[doc = r"Return the pointer to the register block"]
1612 #[inline(always)]
1613 pub const fn ptr() -> *const lcd::RegisterBlock {
1614 Self::PTR
1615 }
1616}
1617impl Deref for LCD {
1618 type Target = lcd::RegisterBlock;
1619 #[inline(always)]
1620 fn deref(&self) -> &Self::Target {
1621 unsafe { &*Self::PTR }
1622 }
1623}
1624impl core::fmt::Debug for LCD {
1625 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1626 f.debug_struct("LCD").finish()
1627 }
1628}
1629#[doc = "LCD"]
1630pub mod lcd;
1631#[doc = "RTC"]
1632pub struct RTC {
1633 _marker: PhantomData<*const ()>,
1634}
1635unsafe impl Send for RTC {}
1636impl RTC {
1637 #[doc = r"Pointer to the register block"]
1638 pub const PTR: *const rtc::RegisterBlock = 0x4006_0000 as *const _;
1639 #[doc = r"Return the pointer to the register block"]
1640 #[inline(always)]
1641 pub const fn ptr() -> *const rtc::RegisterBlock {
1642 Self::PTR
1643 }
1644}
1645impl Deref for RTC {
1646 type Target = rtc::RegisterBlock;
1647 #[inline(always)]
1648 fn deref(&self) -> &Self::Target {
1649 unsafe { &*Self::PTR }
1650 }
1651}
1652impl core::fmt::Debug for RTC {
1653 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1654 f.debug_struct("RTC").finish()
1655 }
1656}
1657#[doc = "RTC"]
1658pub mod rtc;
1659#[doc = "RTCC"]
1660pub struct RTCC {
1661 _marker: PhantomData<*const ()>,
1662}
1663unsafe impl Send for RTCC {}
1664impl RTCC {
1665 #[doc = r"Pointer to the register block"]
1666 pub const PTR: *const rtcc::RegisterBlock = 0x4006_2000 as *const _;
1667 #[doc = r"Return the pointer to the register block"]
1668 #[inline(always)]
1669 pub const fn ptr() -> *const rtcc::RegisterBlock {
1670 Self::PTR
1671 }
1672}
1673impl Deref for RTCC {
1674 type Target = rtcc::RegisterBlock;
1675 #[inline(always)]
1676 fn deref(&self) -> &Self::Target {
1677 unsafe { &*Self::PTR }
1678 }
1679}
1680impl core::fmt::Debug for RTCC {
1681 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1682 f.debug_struct("RTCC").finish()
1683 }
1684}
1685#[doc = "RTCC"]
1686pub mod rtcc;
1687#[doc = "WDOG0"]
1688pub struct WDOG0 {
1689 _marker: PhantomData<*const ()>,
1690}
1691unsafe impl Send for WDOG0 {}
1692impl WDOG0 {
1693 #[doc = r"Pointer to the register block"]
1694 pub const PTR: *const wdog0::RegisterBlock = 0x4005_2000 as *const _;
1695 #[doc = r"Return the pointer to the register block"]
1696 #[inline(always)]
1697 pub const fn ptr() -> *const wdog0::RegisterBlock {
1698 Self::PTR
1699 }
1700}
1701impl Deref for WDOG0 {
1702 type Target = wdog0::RegisterBlock;
1703 #[inline(always)]
1704 fn deref(&self) -> &Self::Target {
1705 unsafe { &*Self::PTR }
1706 }
1707}
1708impl core::fmt::Debug for WDOG0 {
1709 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1710 f.debug_struct("WDOG0").finish()
1711 }
1712}
1713#[doc = "WDOG0"]
1714pub mod wdog0;
1715#[doc = "WDOG1"]
1716pub struct WDOG1 {
1717 _marker: PhantomData<*const ()>,
1718}
1719unsafe impl Send for WDOG1 {}
1720impl WDOG1 {
1721 #[doc = r"Pointer to the register block"]
1722 pub const PTR: *const wdog1::RegisterBlock = 0x4005_2400 as *const _;
1723 #[doc = r"Return the pointer to the register block"]
1724 #[inline(always)]
1725 pub const fn ptr() -> *const wdog1::RegisterBlock {
1726 Self::PTR
1727 }
1728}
1729impl Deref for WDOG1 {
1730 type Target = wdog1::RegisterBlock;
1731 #[inline(always)]
1732 fn deref(&self) -> &Self::Target {
1733 unsafe { &*Self::PTR }
1734 }
1735}
1736impl core::fmt::Debug for WDOG1 {
1737 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1738 f.debug_struct("WDOG1").finish()
1739 }
1740}
1741#[doc = "WDOG1"]
1742pub mod wdog1;
1743#[doc = "ETM"]
1744pub struct ETM {
1745 _marker: PhantomData<*const ()>,
1746}
1747unsafe impl Send for ETM {}
1748impl ETM {
1749 #[doc = r"Pointer to the register block"]
1750 pub const PTR: *const etm::RegisterBlock = 0xe004_1000 as *const _;
1751 #[doc = r"Return the pointer to the register block"]
1752 #[inline(always)]
1753 pub const fn ptr() -> *const etm::RegisterBlock {
1754 Self::PTR
1755 }
1756}
1757impl Deref for ETM {
1758 type Target = etm::RegisterBlock;
1759 #[inline(always)]
1760 fn deref(&self) -> &Self::Target {
1761 unsafe { &*Self::PTR }
1762 }
1763}
1764impl core::fmt::Debug for ETM {
1765 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1766 f.debug_struct("ETM").finish()
1767 }
1768}
1769#[doc = "ETM"]
1770pub mod etm;
1771#[doc = "SMU"]
1772pub struct SMU {
1773 _marker: PhantomData<*const ()>,
1774}
1775unsafe impl Send for SMU {}
1776impl SMU {
1777 #[doc = r"Pointer to the register block"]
1778 pub const PTR: *const smu::RegisterBlock = 0x4002_0000 as *const _;
1779 #[doc = r"Return the pointer to the register block"]
1780 #[inline(always)]
1781 pub const fn ptr() -> *const smu::RegisterBlock {
1782 Self::PTR
1783 }
1784}
1785impl Deref for SMU {
1786 type Target = smu::RegisterBlock;
1787 #[inline(always)]
1788 fn deref(&self) -> &Self::Target {
1789 unsafe { &*Self::PTR }
1790 }
1791}
1792impl core::fmt::Debug for SMU {
1793 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1794 f.debug_struct("SMU").finish()
1795 }
1796}
1797#[doc = "SMU"]
1798pub mod smu;
1799#[doc = "TRNG0"]
1800pub struct TRNG0 {
1801 _marker: PhantomData<*const ()>,
1802}
1803unsafe impl Send for TRNG0 {}
1804impl TRNG0 {
1805 #[doc = r"Pointer to the register block"]
1806 pub const PTR: *const trng0::RegisterBlock = 0x4001_d000 as *const _;
1807 #[doc = r"Return the pointer to the register block"]
1808 #[inline(always)]
1809 pub const fn ptr() -> *const trng0::RegisterBlock {
1810 Self::PTR
1811 }
1812}
1813impl Deref for TRNG0 {
1814 type Target = trng0::RegisterBlock;
1815 #[inline(always)]
1816 fn deref(&self) -> &Self::Target {
1817 unsafe { &*Self::PTR }
1818 }
1819}
1820impl core::fmt::Debug for TRNG0 {
1821 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1822 f.debug_struct("TRNG0").finish()
1823 }
1824}
1825#[doc = "TRNG0"]
1826pub mod trng0;
1827#[no_mangle]
1828static mut DEVICE_PERIPHERALS: bool = false;
1829#[doc = r"All the peripherals"]
1830#[allow(non_snake_case)]
1831pub struct Peripherals {
1832 #[doc = "MSC"]
1833 pub MSC: MSC,
1834 #[doc = "EMU"]
1835 pub EMU: EMU,
1836 #[doc = "RMU"]
1837 pub RMU: RMU,
1838 #[doc = "CMU"]
1839 pub CMU: CMU,
1840 #[doc = "CRYPTO0"]
1841 pub CRYPTO0: CRYPTO0,
1842 #[doc = "LESENSE"]
1843 pub LESENSE: LESENSE,
1844 #[doc = "EBI"]
1845 pub EBI: EBI,
1846 #[doc = "PDM"]
1847 pub PDM: PDM,
1848 #[doc = "GPIO"]
1849 pub GPIO: GPIO,
1850 #[doc = "PRS"]
1851 pub PRS: PRS,
1852 #[doc = "LDMA"]
1853 pub LDMA: LDMA,
1854 #[doc = "FPUEH"]
1855 pub FPUEH: FPUEH,
1856 #[doc = "GPCRC"]
1857 pub GPCRC: GPCRC,
1858 #[doc = "CAN0"]
1859 pub CAN0: CAN0,
1860 #[doc = "CAN1"]
1861 pub CAN1: CAN1,
1862 #[doc = "TIMER0"]
1863 pub TIMER0: TIMER0,
1864 #[doc = "TIMER1"]
1865 pub TIMER1: TIMER1,
1866 #[doc = "TIMER2"]
1867 pub TIMER2: TIMER2,
1868 #[doc = "TIMER3"]
1869 pub TIMER3: TIMER3,
1870 #[doc = "WTIMER0"]
1871 pub WTIMER0: WTIMER0,
1872 #[doc = "WTIMER1"]
1873 pub WTIMER1: WTIMER1,
1874 #[doc = "USART0"]
1875 pub USART0: USART0,
1876 #[doc = "USART1"]
1877 pub USART1: USART1,
1878 #[doc = "USART2"]
1879 pub USART2: USART2,
1880 #[doc = "USART3"]
1881 pub USART3: USART3,
1882 #[doc = "USART4"]
1883 pub USART4: USART4,
1884 #[doc = "UART0"]
1885 pub UART0: UART0,
1886 #[doc = "UART1"]
1887 pub UART1: UART1,
1888 #[doc = "LEUART0"]
1889 pub LEUART0: LEUART0,
1890 #[doc = "LEUART1"]
1891 pub LEUART1: LEUART1,
1892 #[doc = "LETIMER0"]
1893 pub LETIMER0: LETIMER0,
1894 #[doc = "LETIMER1"]
1895 pub LETIMER1: LETIMER1,
1896 #[doc = "CRYOTIMER"]
1897 pub CRYOTIMER: CRYOTIMER,
1898 #[doc = "PCNT0"]
1899 pub PCNT0: PCNT0,
1900 #[doc = "PCNT1"]
1901 pub PCNT1: PCNT1,
1902 #[doc = "PCNT2"]
1903 pub PCNT2: PCNT2,
1904 #[doc = "I2C0"]
1905 pub I2C0: I2C0,
1906 #[doc = "I2C1"]
1907 pub I2C1: I2C1,
1908 #[doc = "ADC0"]
1909 pub ADC0: ADC0,
1910 #[doc = "ADC1"]
1911 pub ADC1: ADC1,
1912 #[doc = "ACMP0"]
1913 pub ACMP0: ACMP0,
1914 #[doc = "ACMP1"]
1915 pub ACMP1: ACMP1,
1916 #[doc = "ACMP2"]
1917 pub ACMP2: ACMP2,
1918 #[doc = "VDAC0"]
1919 pub VDAC0: VDAC0,
1920 #[doc = "IDAC0"]
1921 pub IDAC0: IDAC0,
1922 #[doc = "CSEN"]
1923 pub CSEN: CSEN,
1924 #[doc = "LCD"]
1925 pub LCD: LCD,
1926 #[doc = "RTC"]
1927 pub RTC: RTC,
1928 #[doc = "RTCC"]
1929 pub RTCC: RTCC,
1930 #[doc = "WDOG0"]
1931 pub WDOG0: WDOG0,
1932 #[doc = "WDOG1"]
1933 pub WDOG1: WDOG1,
1934 #[doc = "ETM"]
1935 pub ETM: ETM,
1936 #[doc = "SMU"]
1937 pub SMU: SMU,
1938 #[doc = "TRNG0"]
1939 pub TRNG0: TRNG0,
1940}
1941impl Peripherals {
1942 #[doc = r"Returns all the peripherals *once*"]
1943 #[inline]
1944 pub fn take() -> Option<Self> {
1945 cortex_m::interrupt::free(|_| {
1946 if unsafe { DEVICE_PERIPHERALS } {
1947 None
1948 } else {
1949 Some(unsafe { Peripherals::steal() })
1950 }
1951 })
1952 }
1953 #[doc = r"Unchecked version of `Peripherals::take`"]
1954 #[inline]
1955 pub unsafe fn steal() -> Self {
1956 DEVICE_PERIPHERALS = true;
1957 Peripherals {
1958 MSC: MSC {
1959 _marker: PhantomData,
1960 },
1961 EMU: EMU {
1962 _marker: PhantomData,
1963 },
1964 RMU: RMU {
1965 _marker: PhantomData,
1966 },
1967 CMU: CMU {
1968 _marker: PhantomData,
1969 },
1970 CRYPTO0: CRYPTO0 {
1971 _marker: PhantomData,
1972 },
1973 LESENSE: LESENSE {
1974 _marker: PhantomData,
1975 },
1976 EBI: EBI {
1977 _marker: PhantomData,
1978 },
1979 PDM: PDM {
1980 _marker: PhantomData,
1981 },
1982 GPIO: GPIO {
1983 _marker: PhantomData,
1984 },
1985 PRS: PRS {
1986 _marker: PhantomData,
1987 },
1988 LDMA: LDMA {
1989 _marker: PhantomData,
1990 },
1991 FPUEH: FPUEH {
1992 _marker: PhantomData,
1993 },
1994 GPCRC: GPCRC {
1995 _marker: PhantomData,
1996 },
1997 CAN0: CAN0 {
1998 _marker: PhantomData,
1999 },
2000 CAN1: CAN1 {
2001 _marker: PhantomData,
2002 },
2003 TIMER0: TIMER0 {
2004 _marker: PhantomData,
2005 },
2006 TIMER1: TIMER1 {
2007 _marker: PhantomData,
2008 },
2009 TIMER2: TIMER2 {
2010 _marker: PhantomData,
2011 },
2012 TIMER3: TIMER3 {
2013 _marker: PhantomData,
2014 },
2015 WTIMER0: WTIMER0 {
2016 _marker: PhantomData,
2017 },
2018 WTIMER1: WTIMER1 {
2019 _marker: PhantomData,
2020 },
2021 USART0: USART0 {
2022 _marker: PhantomData,
2023 },
2024 USART1: USART1 {
2025 _marker: PhantomData,
2026 },
2027 USART2: USART2 {
2028 _marker: PhantomData,
2029 },
2030 USART3: USART3 {
2031 _marker: PhantomData,
2032 },
2033 USART4: USART4 {
2034 _marker: PhantomData,
2035 },
2036 UART0: UART0 {
2037 _marker: PhantomData,
2038 },
2039 UART1: UART1 {
2040 _marker: PhantomData,
2041 },
2042 LEUART0: LEUART0 {
2043 _marker: PhantomData,
2044 },
2045 LEUART1: LEUART1 {
2046 _marker: PhantomData,
2047 },
2048 LETIMER0: LETIMER0 {
2049 _marker: PhantomData,
2050 },
2051 LETIMER1: LETIMER1 {
2052 _marker: PhantomData,
2053 },
2054 CRYOTIMER: CRYOTIMER {
2055 _marker: PhantomData,
2056 },
2057 PCNT0: PCNT0 {
2058 _marker: PhantomData,
2059 },
2060 PCNT1: PCNT1 {
2061 _marker: PhantomData,
2062 },
2063 PCNT2: PCNT2 {
2064 _marker: PhantomData,
2065 },
2066 I2C0: I2C0 {
2067 _marker: PhantomData,
2068 },
2069 I2C1: I2C1 {
2070 _marker: PhantomData,
2071 },
2072 ADC0: ADC0 {
2073 _marker: PhantomData,
2074 },
2075 ADC1: ADC1 {
2076 _marker: PhantomData,
2077 },
2078 ACMP0: ACMP0 {
2079 _marker: PhantomData,
2080 },
2081 ACMP1: ACMP1 {
2082 _marker: PhantomData,
2083 },
2084 ACMP2: ACMP2 {
2085 _marker: PhantomData,
2086 },
2087 VDAC0: VDAC0 {
2088 _marker: PhantomData,
2089 },
2090 IDAC0: IDAC0 {
2091 _marker: PhantomData,
2092 },
2093 CSEN: CSEN {
2094 _marker: PhantomData,
2095 },
2096 LCD: LCD {
2097 _marker: PhantomData,
2098 },
2099 RTC: RTC {
2100 _marker: PhantomData,
2101 },
2102 RTCC: RTCC {
2103 _marker: PhantomData,
2104 },
2105 WDOG0: WDOG0 {
2106 _marker: PhantomData,
2107 },
2108 WDOG1: WDOG1 {
2109 _marker: PhantomData,
2110 },
2111 ETM: ETM {
2112 _marker: PhantomData,
2113 },
2114 SMU: SMU {
2115 _marker: PhantomData,
2116 },
2117 TRNG0: TRNG0 {
2118 _marker: PhantomData,
2119 },
2120 }
2121 }
2122}