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