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