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