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