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