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