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