1#![doc = "Peripheral access API for ATSAMV71N21 microcontrollers (generated using svd2rust v0.21.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.21.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 SUPC();
38 fn RSTC();
39 fn RTC();
40 fn RTT();
41 fn WDT();
42 fn PMC();
43 fn EFC();
44 fn UART0();
45 fn UART1();
46 fn PIOA();
47 fn PIOB();
48 fn USART0();
49 fn USART1();
50 fn USART2();
51 fn PIOD();
52 fn HSMCI();
53 fn TWIHS0();
54 fn TWIHS1();
55 fn SPI0();
56 fn SSC();
57 fn TC0();
58 fn TC1();
59 fn TC2();
60 fn TC3();
61 fn TC4();
62 fn TC5();
63 fn AFEC0();
64 fn PWM0();
65 fn ICM();
66 fn ACC();
67 fn USBHS();
68 fn MCAN0_INT0();
69 fn MCAN0_INT1();
70 fn MCAN1_INT0();
71 fn MCAN1_INT1();
72 fn GMAC();
73 fn AFEC1();
74 fn TWIHS2();
75 fn QSPI();
76 fn UART2();
77 fn UART3();
78 fn UART4();
79 fn TC6();
80 fn TC7();
81 fn TC8();
82 fn TC9();
83 fn TC10();
84 fn TC11();
85 fn MLB();
86 fn AES();
87 fn TRNG();
88 fn XDMAC();
89 fn ISI();
90 fn PWM1();
91 fn FPU();
92 fn RSWDT();
93 fn GMAC_Q1();
94 fn GMAC_Q2();
95 fn IXC();
96}
97#[doc(hidden)]
98pub union Vector {
99 _handler: unsafe extern "C" fn(),
100 _reserved: u32,
101}
102#[cfg(feature = "rt")]
103#[doc(hidden)]
104#[link_section = ".vector_table.interrupts"]
105#[no_mangle]
106pub static __INTERRUPTS: [Vector; 69] = [
107 Vector { _handler: SUPC },
108 Vector { _handler: RSTC },
109 Vector { _handler: RTC },
110 Vector { _handler: RTT },
111 Vector { _handler: WDT },
112 Vector { _handler: PMC },
113 Vector { _handler: EFC },
114 Vector { _handler: UART0 },
115 Vector { _handler: UART1 },
116 Vector { _reserved: 0 },
117 Vector { _handler: PIOA },
118 Vector { _handler: PIOB },
119 Vector { _reserved: 0 },
120 Vector { _handler: USART0 },
121 Vector { _handler: USART1 },
122 Vector { _handler: USART2 },
123 Vector { _handler: PIOD },
124 Vector { _reserved: 0 },
125 Vector { _handler: HSMCI },
126 Vector { _handler: TWIHS0 },
127 Vector { _handler: TWIHS1 },
128 Vector { _handler: SPI0 },
129 Vector { _handler: SSC },
130 Vector { _handler: TC0 },
131 Vector { _handler: TC1 },
132 Vector { _handler: TC2 },
133 Vector { _handler: TC3 },
134 Vector { _handler: TC4 },
135 Vector { _handler: TC5 },
136 Vector { _handler: AFEC0 },
137 Vector { _reserved: 0 },
138 Vector { _handler: PWM0 },
139 Vector { _handler: ICM },
140 Vector { _handler: ACC },
141 Vector { _handler: USBHS },
142 Vector {
143 _handler: MCAN0_INT0,
144 },
145 Vector {
146 _handler: MCAN0_INT1,
147 },
148 Vector {
149 _handler: MCAN1_INT0,
150 },
151 Vector {
152 _handler: MCAN1_INT1,
153 },
154 Vector { _handler: GMAC },
155 Vector { _handler: AFEC1 },
156 Vector { _handler: TWIHS2 },
157 Vector { _reserved: 0 },
158 Vector { _handler: QSPI },
159 Vector { _handler: UART2 },
160 Vector { _handler: UART3 },
161 Vector { _handler: UART4 },
162 Vector { _handler: TC6 },
163 Vector { _handler: TC7 },
164 Vector { _handler: TC8 },
165 Vector { _handler: TC9 },
166 Vector { _handler: TC10 },
167 Vector { _handler: TC11 },
168 Vector { _handler: MLB },
169 Vector { _reserved: 0 },
170 Vector { _reserved: 0 },
171 Vector { _handler: AES },
172 Vector { _handler: TRNG },
173 Vector { _handler: XDMAC },
174 Vector { _handler: ISI },
175 Vector { _handler: PWM1 },
176 Vector { _handler: FPU },
177 Vector { _reserved: 0 },
178 Vector { _handler: RSWDT },
179 Vector { _reserved: 0 },
180 Vector { _reserved: 0 },
181 Vector { _handler: GMAC_Q1 },
182 Vector { _handler: GMAC_Q2 },
183 Vector { _handler: IXC },
184];
185#[doc = r"Enumeration of all the interrupts."]
186#[derive(Copy, Clone, Debug, PartialEq, Eq)]
187#[repr(u16)]
188pub enum Interrupt {
189 #[doc = "0 - SUPC"]
190 SUPC = 0,
191 #[doc = "1 - RSTC"]
192 RSTC = 1,
193 #[doc = "2 - RTC"]
194 RTC = 2,
195 #[doc = "3 - RTT"]
196 RTT = 3,
197 #[doc = "4 - WDT"]
198 WDT = 4,
199 #[doc = "5 - PMC"]
200 PMC = 5,
201 #[doc = "6 - EFC"]
202 EFC = 6,
203 #[doc = "7 - UART0"]
204 UART0 = 7,
205 #[doc = "8 - UART1"]
206 UART1 = 8,
207 #[doc = "10 - PIOA"]
208 PIOA = 10,
209 #[doc = "11 - PIOB"]
210 PIOB = 11,
211 #[doc = "13 - USART0"]
212 USART0 = 13,
213 #[doc = "14 - USART1"]
214 USART1 = 14,
215 #[doc = "15 - USART2"]
216 USART2 = 15,
217 #[doc = "16 - PIOD"]
218 PIOD = 16,
219 #[doc = "18 - HSMCI"]
220 HSMCI = 18,
221 #[doc = "19 - TWIHS0"]
222 TWIHS0 = 19,
223 #[doc = "20 - TWIHS1"]
224 TWIHS1 = 20,
225 #[doc = "21 - SPI0"]
226 SPI0 = 21,
227 #[doc = "22 - SSC"]
228 SSC = 22,
229 #[doc = "23 - TC0"]
230 TC0 = 23,
231 #[doc = "24 - TC1"]
232 TC1 = 24,
233 #[doc = "25 - TC2"]
234 TC2 = 25,
235 #[doc = "26 - TC3"]
236 TC3 = 26,
237 #[doc = "27 - TC4"]
238 TC4 = 27,
239 #[doc = "28 - TC5"]
240 TC5 = 28,
241 #[doc = "29 - AFEC0"]
242 AFEC0 = 29,
243 #[doc = "31 - PWM0"]
244 PWM0 = 31,
245 #[doc = "32 - ICM"]
246 ICM = 32,
247 #[doc = "33 - ACC"]
248 ACC = 33,
249 #[doc = "34 - USBHS"]
250 USBHS = 34,
251 #[doc = "35 - MCAN0_INT0"]
252 MCAN0_INT0 = 35,
253 #[doc = "36 - MCAN0_INT1"]
254 MCAN0_INT1 = 36,
255 #[doc = "37 - MCAN1_INT0"]
256 MCAN1_INT0 = 37,
257 #[doc = "38 - MCAN1_INT1"]
258 MCAN1_INT1 = 38,
259 #[doc = "39 - GMAC"]
260 GMAC = 39,
261 #[doc = "40 - AFEC1"]
262 AFEC1 = 40,
263 #[doc = "41 - TWIHS2"]
264 TWIHS2 = 41,
265 #[doc = "43 - QSPI"]
266 QSPI = 43,
267 #[doc = "44 - UART2"]
268 UART2 = 44,
269 #[doc = "45 - UART3"]
270 UART3 = 45,
271 #[doc = "46 - UART4"]
272 UART4 = 46,
273 #[doc = "47 - TC6"]
274 TC6 = 47,
275 #[doc = "48 - TC7"]
276 TC7 = 48,
277 #[doc = "49 - TC8"]
278 TC8 = 49,
279 #[doc = "50 - TC9"]
280 TC9 = 50,
281 #[doc = "51 - TC10"]
282 TC10 = 51,
283 #[doc = "52 - TC11"]
284 TC11 = 52,
285 #[doc = "53 - MLB"]
286 MLB = 53,
287 #[doc = "56 - AES"]
288 AES = 56,
289 #[doc = "57 - TRNG"]
290 TRNG = 57,
291 #[doc = "58 - XDMAC"]
292 XDMAC = 58,
293 #[doc = "59 - ISI"]
294 ISI = 59,
295 #[doc = "60 - PWM1"]
296 PWM1 = 60,
297 #[doc = "61 - FPU"]
298 FPU = 61,
299 #[doc = "63 - RSWDT"]
300 RSWDT = 63,
301 #[doc = "66 - GMAC_Q1"]
302 GMAC_Q1 = 66,
303 #[doc = "67 - GMAC_Q2"]
304 GMAC_Q2 = 67,
305 #[doc = "68 - IXC"]
306 IXC = 68,
307}
308unsafe impl cortex_m::interrupt::InterruptNumber for Interrupt {
309 #[inline(always)]
310 fn number(self) -> u16 {
311 self as u16
312 }
313}
314#[doc = "Analog Comparator Controller"]
315pub struct ACC {
316 _marker: PhantomData<*const ()>,
317}
318unsafe impl Send for ACC {}
319impl ACC {
320 #[doc = r"Pointer to the register block"]
321 pub const PTR: *const acc::RegisterBlock = 0x4004_4000 as *const _;
322 #[doc = r"Return the pointer to the register block"]
323 #[inline(always)]
324 pub const fn ptr() -> *const acc::RegisterBlock {
325 Self::PTR
326 }
327}
328impl Deref for ACC {
329 type Target = acc::RegisterBlock;
330 #[inline(always)]
331 fn deref(&self) -> &Self::Target {
332 unsafe { &*Self::PTR }
333 }
334}
335impl core::fmt::Debug for ACC {
336 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
337 f.debug_struct("ACC").finish()
338 }
339}
340#[doc = "Analog Comparator Controller"]
341pub mod acc;
342#[doc = "Advanced Encryption Standard"]
343pub struct AES {
344 _marker: PhantomData<*const ()>,
345}
346unsafe impl Send for AES {}
347impl AES {
348 #[doc = r"Pointer to the register block"]
349 pub const PTR: *const aes::RegisterBlock = 0x4006_c000 as *const _;
350 #[doc = r"Return the pointer to the register block"]
351 #[inline(always)]
352 pub const fn ptr() -> *const aes::RegisterBlock {
353 Self::PTR
354 }
355}
356impl Deref for AES {
357 type Target = aes::RegisterBlock;
358 #[inline(always)]
359 fn deref(&self) -> &Self::Target {
360 unsafe { &*Self::PTR }
361 }
362}
363impl core::fmt::Debug for AES {
364 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
365 f.debug_struct("AES").finish()
366 }
367}
368#[doc = "Advanced Encryption Standard"]
369pub mod aes;
370#[doc = "Analog Front-End Controller"]
371pub struct AFEC0 {
372 _marker: PhantomData<*const ()>,
373}
374unsafe impl Send for AFEC0 {}
375impl AFEC0 {
376 #[doc = r"Pointer to the register block"]
377 pub const PTR: *const afec0::RegisterBlock = 0x4003_c000 as *const _;
378 #[doc = r"Return the pointer to the register block"]
379 #[inline(always)]
380 pub const fn ptr() -> *const afec0::RegisterBlock {
381 Self::PTR
382 }
383}
384impl Deref for AFEC0 {
385 type Target = afec0::RegisterBlock;
386 #[inline(always)]
387 fn deref(&self) -> &Self::Target {
388 unsafe { &*Self::PTR }
389 }
390}
391impl core::fmt::Debug for AFEC0 {
392 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
393 f.debug_struct("AFEC0").finish()
394 }
395}
396#[doc = "Analog Front-End Controller"]
397pub mod afec0;
398#[doc = "Analog Front-End Controller"]
399pub struct AFEC1 {
400 _marker: PhantomData<*const ()>,
401}
402unsafe impl Send for AFEC1 {}
403impl AFEC1 {
404 #[doc = r"Pointer to the register block"]
405 pub const PTR: *const afec0::RegisterBlock = 0x4006_4000 as *const _;
406 #[doc = r"Return the pointer to the register block"]
407 #[inline(always)]
408 pub const fn ptr() -> *const afec0::RegisterBlock {
409 Self::PTR
410 }
411}
412impl Deref for AFEC1 {
413 type Target = afec0::RegisterBlock;
414 #[inline(always)]
415 fn deref(&self) -> &Self::Target {
416 unsafe { &*Self::PTR }
417 }
418}
419impl core::fmt::Debug for AFEC1 {
420 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
421 f.debug_struct("AFEC1").finish()
422 }
423}
424#[doc = "Analog Front-End Controller"]
425pub use afec0 as afec1;
426#[doc = "Chip Identifier"]
427pub struct CHIPID {
428 _marker: PhantomData<*const ()>,
429}
430unsafe impl Send for CHIPID {}
431impl CHIPID {
432 #[doc = r"Pointer to the register block"]
433 pub const PTR: *const chipid::RegisterBlock = 0x400e_0940 as *const _;
434 #[doc = r"Return the pointer to the register block"]
435 #[inline(always)]
436 pub const fn ptr() -> *const chipid::RegisterBlock {
437 Self::PTR
438 }
439}
440impl Deref for CHIPID {
441 type Target = chipid::RegisterBlock;
442 #[inline(always)]
443 fn deref(&self) -> &Self::Target {
444 unsafe { &*Self::PTR }
445 }
446}
447impl core::fmt::Debug for CHIPID {
448 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
449 f.debug_struct("CHIPID").finish()
450 }
451}
452#[doc = "Chip Identifier"]
453pub mod chipid;
454#[doc = "Embedded Flash Controller"]
455pub struct EFC {
456 _marker: PhantomData<*const ()>,
457}
458unsafe impl Send for EFC {}
459impl EFC {
460 #[doc = r"Pointer to the register block"]
461 pub const PTR: *const efc::RegisterBlock = 0x400e_0c00 as *const _;
462 #[doc = r"Return the pointer to the register block"]
463 #[inline(always)]
464 pub const fn ptr() -> *const efc::RegisterBlock {
465 Self::PTR
466 }
467}
468impl Deref for EFC {
469 type Target = efc::RegisterBlock;
470 #[inline(always)]
471 fn deref(&self) -> &Self::Target {
472 unsafe { &*Self::PTR }
473 }
474}
475impl core::fmt::Debug for EFC {
476 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
477 f.debug_struct("EFC").finish()
478 }
479}
480#[doc = "Embedded Flash Controller"]
481pub mod efc;
482#[doc = "Gigabit Ethernet MAC"]
483pub struct GMAC {
484 _marker: PhantomData<*const ()>,
485}
486unsafe impl Send for GMAC {}
487impl GMAC {
488 #[doc = r"Pointer to the register block"]
489 pub const PTR: *const gmac::RegisterBlock = 0x4005_0000 as *const _;
490 #[doc = r"Return the pointer to the register block"]
491 #[inline(always)]
492 pub const fn ptr() -> *const gmac::RegisterBlock {
493 Self::PTR
494 }
495}
496impl Deref for GMAC {
497 type Target = gmac::RegisterBlock;
498 #[inline(always)]
499 fn deref(&self) -> &Self::Target {
500 unsafe { &*Self::PTR }
501 }
502}
503impl core::fmt::Debug for GMAC {
504 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
505 f.debug_struct("GMAC").finish()
506 }
507}
508#[doc = "Gigabit Ethernet MAC"]
509pub mod gmac;
510#[doc = "General Purpose Backup Registers"]
511pub struct GPBR {
512 _marker: PhantomData<*const ()>,
513}
514unsafe impl Send for GPBR {}
515impl GPBR {
516 #[doc = r"Pointer to the register block"]
517 pub const PTR: *const gpbr::RegisterBlock = 0x400e_1890 as *const _;
518 #[doc = r"Return the pointer to the register block"]
519 #[inline(always)]
520 pub const fn ptr() -> *const gpbr::RegisterBlock {
521 Self::PTR
522 }
523}
524impl Deref for GPBR {
525 type Target = gpbr::RegisterBlock;
526 #[inline(always)]
527 fn deref(&self) -> &Self::Target {
528 unsafe { &*Self::PTR }
529 }
530}
531impl core::fmt::Debug for GPBR {
532 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
533 f.debug_struct("GPBR").finish()
534 }
535}
536#[doc = "General Purpose Backup Registers"]
537pub mod gpbr;
538#[doc = "High Speed MultiMedia Card Interface"]
539pub struct HSMCI {
540 _marker: PhantomData<*const ()>,
541}
542unsafe impl Send for HSMCI {}
543impl HSMCI {
544 #[doc = r"Pointer to the register block"]
545 pub const PTR: *const hsmci::RegisterBlock = 0x4000_0000 as *const _;
546 #[doc = r"Return the pointer to the register block"]
547 #[inline(always)]
548 pub const fn ptr() -> *const hsmci::RegisterBlock {
549 Self::PTR
550 }
551}
552impl Deref for HSMCI {
553 type Target = hsmci::RegisterBlock;
554 #[inline(always)]
555 fn deref(&self) -> &Self::Target {
556 unsafe { &*Self::PTR }
557 }
558}
559impl core::fmt::Debug for HSMCI {
560 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
561 f.debug_struct("HSMCI").finish()
562 }
563}
564#[doc = "High Speed MultiMedia Card Interface"]
565pub mod hsmci;
566#[doc = "Integrity Check Monitor"]
567pub struct ICM {
568 _marker: PhantomData<*const ()>,
569}
570unsafe impl Send for ICM {}
571impl ICM {
572 #[doc = r"Pointer to the register block"]
573 pub const PTR: *const icm::RegisterBlock = 0x4004_8000 as *const _;
574 #[doc = r"Return the pointer to the register block"]
575 #[inline(always)]
576 pub const fn ptr() -> *const icm::RegisterBlock {
577 Self::PTR
578 }
579}
580impl Deref for ICM {
581 type Target = icm::RegisterBlock;
582 #[inline(always)]
583 fn deref(&self) -> &Self::Target {
584 unsafe { &*Self::PTR }
585 }
586}
587impl core::fmt::Debug for ICM {
588 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
589 f.debug_struct("ICM").finish()
590 }
591}
592#[doc = "Integrity Check Monitor"]
593pub mod icm;
594#[doc = "Image Sensor Interface"]
595pub struct ISI {
596 _marker: PhantomData<*const ()>,
597}
598unsafe impl Send for ISI {}
599impl ISI {
600 #[doc = r"Pointer to the register block"]
601 pub const PTR: *const isi::RegisterBlock = 0x4004_c000 as *const _;
602 #[doc = r"Return the pointer to the register block"]
603 #[inline(always)]
604 pub const fn ptr() -> *const isi::RegisterBlock {
605 Self::PTR
606 }
607}
608impl Deref for ISI {
609 type Target = isi::RegisterBlock;
610 #[inline(always)]
611 fn deref(&self) -> &Self::Target {
612 unsafe { &*Self::PTR }
613 }
614}
615impl core::fmt::Debug for ISI {
616 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
617 f.debug_struct("ISI").finish()
618 }
619}
620#[doc = "Image Sensor Interface"]
621pub mod isi;
622#[doc = "AHB Bus Matrix"]
623pub struct MATRIX {
624 _marker: PhantomData<*const ()>,
625}
626unsafe impl Send for MATRIX {}
627impl MATRIX {
628 #[doc = r"Pointer to the register block"]
629 pub const PTR: *const matrix::RegisterBlock = 0x4008_8000 as *const _;
630 #[doc = r"Return the pointer to the register block"]
631 #[inline(always)]
632 pub const fn ptr() -> *const matrix::RegisterBlock {
633 Self::PTR
634 }
635}
636impl Deref for MATRIX {
637 type Target = matrix::RegisterBlock;
638 #[inline(always)]
639 fn deref(&self) -> &Self::Target {
640 unsafe { &*Self::PTR }
641 }
642}
643impl core::fmt::Debug for MATRIX {
644 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
645 f.debug_struct("MATRIX").finish()
646 }
647}
648#[doc = "AHB Bus Matrix"]
649pub mod matrix;
650#[doc = "Controller Area Network"]
651pub struct MCAN0 {
652 _marker: PhantomData<*const ()>,
653}
654unsafe impl Send for MCAN0 {}
655impl MCAN0 {
656 #[doc = r"Pointer to the register block"]
657 pub const PTR: *const mcan0::RegisterBlock = 0x4003_0000 as *const _;
658 #[doc = r"Return the pointer to the register block"]
659 #[inline(always)]
660 pub const fn ptr() -> *const mcan0::RegisterBlock {
661 Self::PTR
662 }
663}
664impl Deref for MCAN0 {
665 type Target = mcan0::RegisterBlock;
666 #[inline(always)]
667 fn deref(&self) -> &Self::Target {
668 unsafe { &*Self::PTR }
669 }
670}
671impl core::fmt::Debug for MCAN0 {
672 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
673 f.debug_struct("MCAN0").finish()
674 }
675}
676#[doc = "Controller Area Network"]
677pub mod mcan0;
678#[doc = "Controller Area Network"]
679pub struct MCAN1 {
680 _marker: PhantomData<*const ()>,
681}
682unsafe impl Send for MCAN1 {}
683impl MCAN1 {
684 #[doc = r"Pointer to the register block"]
685 pub const PTR: *const mcan0::RegisterBlock = 0x4003_4000 as *const _;
686 #[doc = r"Return the pointer to the register block"]
687 #[inline(always)]
688 pub const fn ptr() -> *const mcan0::RegisterBlock {
689 Self::PTR
690 }
691}
692impl Deref for MCAN1 {
693 type Target = mcan0::RegisterBlock;
694 #[inline(always)]
695 fn deref(&self) -> &Self::Target {
696 unsafe { &*Self::PTR }
697 }
698}
699impl core::fmt::Debug for MCAN1 {
700 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
701 f.debug_struct("MCAN1").finish()
702 }
703}
704#[doc = "Controller Area Network"]
705pub use mcan0 as mcan1;
706#[doc = "MediaLB"]
707pub struct MLB {
708 _marker: PhantomData<*const ()>,
709}
710unsafe impl Send for MLB {}
711impl MLB {
712 #[doc = r"Pointer to the register block"]
713 pub const PTR: *const mlb::RegisterBlock = 0x4006_8000 as *const _;
714 #[doc = r"Return the pointer to the register block"]
715 #[inline(always)]
716 pub const fn ptr() -> *const mlb::RegisterBlock {
717 Self::PTR
718 }
719}
720impl Deref for MLB {
721 type Target = mlb::RegisterBlock;
722 #[inline(always)]
723 fn deref(&self) -> &Self::Target {
724 unsafe { &*Self::PTR }
725 }
726}
727impl core::fmt::Debug for MLB {
728 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
729 f.debug_struct("MLB").finish()
730 }
731}
732#[doc = "MediaLB"]
733pub mod mlb;
734#[doc = "Parallel Input/Output Controller"]
735pub struct PIOA {
736 _marker: PhantomData<*const ()>,
737}
738unsafe impl Send for PIOA {}
739impl PIOA {
740 #[doc = r"Pointer to the register block"]
741 pub const PTR: *const pioa::RegisterBlock = 0x400e_0e00 as *const _;
742 #[doc = r"Return the pointer to the register block"]
743 #[inline(always)]
744 pub const fn ptr() -> *const pioa::RegisterBlock {
745 Self::PTR
746 }
747}
748impl Deref for PIOA {
749 type Target = pioa::RegisterBlock;
750 #[inline(always)]
751 fn deref(&self) -> &Self::Target {
752 unsafe { &*Self::PTR }
753 }
754}
755impl core::fmt::Debug for PIOA {
756 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
757 f.debug_struct("PIOA").finish()
758 }
759}
760#[doc = "Parallel Input/Output Controller"]
761pub mod pioa;
762#[doc = "Parallel Input/Output Controller"]
763pub struct PIOB {
764 _marker: PhantomData<*const ()>,
765}
766unsafe impl Send for PIOB {}
767impl PIOB {
768 #[doc = r"Pointer to the register block"]
769 pub const PTR: *const pioa::RegisterBlock = 0x400e_1000 as *const _;
770 #[doc = r"Return the pointer to the register block"]
771 #[inline(always)]
772 pub const fn ptr() -> *const pioa::RegisterBlock {
773 Self::PTR
774 }
775}
776impl Deref for PIOB {
777 type Target = pioa::RegisterBlock;
778 #[inline(always)]
779 fn deref(&self) -> &Self::Target {
780 unsafe { &*Self::PTR }
781 }
782}
783impl core::fmt::Debug for PIOB {
784 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
785 f.debug_struct("PIOB").finish()
786 }
787}
788#[doc = "Parallel Input/Output Controller"]
789pub use pioa as piob;
790#[doc = "Parallel Input/Output Controller"]
791pub struct PIOD {
792 _marker: PhantomData<*const ()>,
793}
794unsafe impl Send for PIOD {}
795impl PIOD {
796 #[doc = r"Pointer to the register block"]
797 pub const PTR: *const pioa::RegisterBlock = 0x400e_1400 as *const _;
798 #[doc = r"Return the pointer to the register block"]
799 #[inline(always)]
800 pub const fn ptr() -> *const pioa::RegisterBlock {
801 Self::PTR
802 }
803}
804impl Deref for PIOD {
805 type Target = pioa::RegisterBlock;
806 #[inline(always)]
807 fn deref(&self) -> &Self::Target {
808 unsafe { &*Self::PTR }
809 }
810}
811impl core::fmt::Debug for PIOD {
812 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
813 f.debug_struct("PIOD").finish()
814 }
815}
816#[doc = "Parallel Input/Output Controller"]
817pub use pioa as piod;
818#[doc = "Power Management Controller"]
819pub struct PMC {
820 _marker: PhantomData<*const ()>,
821}
822unsafe impl Send for PMC {}
823impl PMC {
824 #[doc = r"Pointer to the register block"]
825 pub const PTR: *const pmc::RegisterBlock = 0x400e_0600 as *const _;
826 #[doc = r"Return the pointer to the register block"]
827 #[inline(always)]
828 pub const fn ptr() -> *const pmc::RegisterBlock {
829 Self::PTR
830 }
831}
832impl Deref for PMC {
833 type Target = pmc::RegisterBlock;
834 #[inline(always)]
835 fn deref(&self) -> &Self::Target {
836 unsafe { &*Self::PTR }
837 }
838}
839impl core::fmt::Debug for PMC {
840 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
841 f.debug_struct("PMC").finish()
842 }
843}
844#[doc = "Power Management Controller"]
845pub mod pmc;
846#[doc = "Pulse Width Modulation Controller"]
847pub struct PWM0 {
848 _marker: PhantomData<*const ()>,
849}
850unsafe impl Send for PWM0 {}
851impl PWM0 {
852 #[doc = r"Pointer to the register block"]
853 pub const PTR: *const pwm0::RegisterBlock = 0x4002_0000 as *const _;
854 #[doc = r"Return the pointer to the register block"]
855 #[inline(always)]
856 pub const fn ptr() -> *const pwm0::RegisterBlock {
857 Self::PTR
858 }
859}
860impl Deref for PWM0 {
861 type Target = pwm0::RegisterBlock;
862 #[inline(always)]
863 fn deref(&self) -> &Self::Target {
864 unsafe { &*Self::PTR }
865 }
866}
867impl core::fmt::Debug for PWM0 {
868 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
869 f.debug_struct("PWM0").finish()
870 }
871}
872#[doc = "Pulse Width Modulation Controller"]
873pub mod pwm0;
874#[doc = "Pulse Width Modulation Controller"]
875pub struct PWM1 {
876 _marker: PhantomData<*const ()>,
877}
878unsafe impl Send for PWM1 {}
879impl PWM1 {
880 #[doc = r"Pointer to the register block"]
881 pub const PTR: *const pwm0::RegisterBlock = 0x4005_c000 as *const _;
882 #[doc = r"Return the pointer to the register block"]
883 #[inline(always)]
884 pub const fn ptr() -> *const pwm0::RegisterBlock {
885 Self::PTR
886 }
887}
888impl Deref for PWM1 {
889 type Target = pwm0::RegisterBlock;
890 #[inline(always)]
891 fn deref(&self) -> &Self::Target {
892 unsafe { &*Self::PTR }
893 }
894}
895impl core::fmt::Debug for PWM1 {
896 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
897 f.debug_struct("PWM1").finish()
898 }
899}
900#[doc = "Pulse Width Modulation Controller"]
901pub use pwm0 as pwm1;
902#[doc = "Quad Serial Peripheral Interface"]
903pub struct QSPI {
904 _marker: PhantomData<*const ()>,
905}
906unsafe impl Send for QSPI {}
907impl QSPI {
908 #[doc = r"Pointer to the register block"]
909 pub const PTR: *const qspi::RegisterBlock = 0x4007_c000 as *const _;
910 #[doc = r"Return the pointer to the register block"]
911 #[inline(always)]
912 pub const fn ptr() -> *const qspi::RegisterBlock {
913 Self::PTR
914 }
915}
916impl Deref for QSPI {
917 type Target = qspi::RegisterBlock;
918 #[inline(always)]
919 fn deref(&self) -> &Self::Target {
920 unsafe { &*Self::PTR }
921 }
922}
923impl core::fmt::Debug for QSPI {
924 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
925 f.debug_struct("QSPI").finish()
926 }
927}
928#[doc = "Quad Serial Peripheral Interface"]
929pub mod qspi;
930#[doc = "Reset Controller"]
931pub struct RSTC {
932 _marker: PhantomData<*const ()>,
933}
934unsafe impl Send for RSTC {}
935impl RSTC {
936 #[doc = r"Pointer to the register block"]
937 pub const PTR: *const rstc::RegisterBlock = 0x400e_1800 as *const _;
938 #[doc = r"Return the pointer to the register block"]
939 #[inline(always)]
940 pub const fn ptr() -> *const rstc::RegisterBlock {
941 Self::PTR
942 }
943}
944impl Deref for RSTC {
945 type Target = rstc::RegisterBlock;
946 #[inline(always)]
947 fn deref(&self) -> &Self::Target {
948 unsafe { &*Self::PTR }
949 }
950}
951impl core::fmt::Debug for RSTC {
952 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
953 f.debug_struct("RSTC").finish()
954 }
955}
956#[doc = "Reset Controller"]
957pub mod rstc;
958#[doc = "Reinforced Safety Watchdog Timer"]
959pub struct RSWDT {
960 _marker: PhantomData<*const ()>,
961}
962unsafe impl Send for RSWDT {}
963impl RSWDT {
964 #[doc = r"Pointer to the register block"]
965 pub const PTR: *const rswdt::RegisterBlock = 0x400e_1900 as *const _;
966 #[doc = r"Return the pointer to the register block"]
967 #[inline(always)]
968 pub const fn ptr() -> *const rswdt::RegisterBlock {
969 Self::PTR
970 }
971}
972impl Deref for RSWDT {
973 type Target = rswdt::RegisterBlock;
974 #[inline(always)]
975 fn deref(&self) -> &Self::Target {
976 unsafe { &*Self::PTR }
977 }
978}
979impl core::fmt::Debug for RSWDT {
980 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
981 f.debug_struct("RSWDT").finish()
982 }
983}
984#[doc = "Reinforced Safety Watchdog Timer"]
985pub mod rswdt;
986#[doc = "Real-time Clock"]
987pub struct RTC {
988 _marker: PhantomData<*const ()>,
989}
990unsafe impl Send for RTC {}
991impl RTC {
992 #[doc = r"Pointer to the register block"]
993 pub const PTR: *const rtc::RegisterBlock = 0x400e_1860 as *const _;
994 #[doc = r"Return the pointer to the register block"]
995 #[inline(always)]
996 pub const fn ptr() -> *const rtc::RegisterBlock {
997 Self::PTR
998 }
999}
1000impl Deref for RTC {
1001 type Target = rtc::RegisterBlock;
1002 #[inline(always)]
1003 fn deref(&self) -> &Self::Target {
1004 unsafe { &*Self::PTR }
1005 }
1006}
1007impl core::fmt::Debug for RTC {
1008 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1009 f.debug_struct("RTC").finish()
1010 }
1011}
1012#[doc = "Real-time Clock"]
1013pub mod rtc;
1014#[doc = "Real-time Timer"]
1015pub struct RTT {
1016 _marker: PhantomData<*const ()>,
1017}
1018unsafe impl Send for RTT {}
1019impl RTT {
1020 #[doc = r"Pointer to the register block"]
1021 pub const PTR: *const rtt::RegisterBlock = 0x400e_1830 as *const _;
1022 #[doc = r"Return the pointer to the register block"]
1023 #[inline(always)]
1024 pub const fn ptr() -> *const rtt::RegisterBlock {
1025 Self::PTR
1026 }
1027}
1028impl Deref for RTT {
1029 type Target = rtt::RegisterBlock;
1030 #[inline(always)]
1031 fn deref(&self) -> &Self::Target {
1032 unsafe { &*Self::PTR }
1033 }
1034}
1035impl core::fmt::Debug for RTT {
1036 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1037 f.debug_struct("RTT").finish()
1038 }
1039}
1040#[doc = "Real-time Timer"]
1041pub mod rtt;
1042#[doc = "Serial Peripheral Interface"]
1043pub struct SPI0 {
1044 _marker: PhantomData<*const ()>,
1045}
1046unsafe impl Send for SPI0 {}
1047impl SPI0 {
1048 #[doc = r"Pointer to the register block"]
1049 pub const PTR: *const spi0::RegisterBlock = 0x4000_8000 as *const _;
1050 #[doc = r"Return the pointer to the register block"]
1051 #[inline(always)]
1052 pub const fn ptr() -> *const spi0::RegisterBlock {
1053 Self::PTR
1054 }
1055}
1056impl Deref for SPI0 {
1057 type Target = spi0::RegisterBlock;
1058 #[inline(always)]
1059 fn deref(&self) -> &Self::Target {
1060 unsafe { &*Self::PTR }
1061 }
1062}
1063impl core::fmt::Debug for SPI0 {
1064 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1065 f.debug_struct("SPI0").finish()
1066 }
1067}
1068#[doc = "Serial Peripheral Interface"]
1069pub mod spi0;
1070#[doc = "Synchronous Serial Controller"]
1071pub struct SSC {
1072 _marker: PhantomData<*const ()>,
1073}
1074unsafe impl Send for SSC {}
1075impl SSC {
1076 #[doc = r"Pointer to the register block"]
1077 pub const PTR: *const ssc::RegisterBlock = 0x4000_4000 as *const _;
1078 #[doc = r"Return the pointer to the register block"]
1079 #[inline(always)]
1080 pub const fn ptr() -> *const ssc::RegisterBlock {
1081 Self::PTR
1082 }
1083}
1084impl Deref for SSC {
1085 type Target = ssc::RegisterBlock;
1086 #[inline(always)]
1087 fn deref(&self) -> &Self::Target {
1088 unsafe { &*Self::PTR }
1089 }
1090}
1091impl core::fmt::Debug for SSC {
1092 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1093 f.debug_struct("SSC").finish()
1094 }
1095}
1096#[doc = "Synchronous Serial Controller"]
1097pub mod ssc;
1098#[doc = "Supply Controller"]
1099pub struct SUPC {
1100 _marker: PhantomData<*const ()>,
1101}
1102unsafe impl Send for SUPC {}
1103impl SUPC {
1104 #[doc = r"Pointer to the register block"]
1105 pub const PTR: *const supc::RegisterBlock = 0x400e_1810 as *const _;
1106 #[doc = r"Return the pointer to the register block"]
1107 #[inline(always)]
1108 pub const fn ptr() -> *const supc::RegisterBlock {
1109 Self::PTR
1110 }
1111}
1112impl Deref for SUPC {
1113 type Target = supc::RegisterBlock;
1114 #[inline(always)]
1115 fn deref(&self) -> &Self::Target {
1116 unsafe { &*Self::PTR }
1117 }
1118}
1119impl core::fmt::Debug for SUPC {
1120 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1121 f.debug_struct("SUPC").finish()
1122 }
1123}
1124#[doc = "Supply Controller"]
1125pub mod supc;
1126#[doc = "Timer Counter"]
1127pub struct TC0 {
1128 _marker: PhantomData<*const ()>,
1129}
1130unsafe impl Send for TC0 {}
1131impl TC0 {
1132 #[doc = r"Pointer to the register block"]
1133 pub const PTR: *const tc0::RegisterBlock = 0x4000_c000 as *const _;
1134 #[doc = r"Return the pointer to the register block"]
1135 #[inline(always)]
1136 pub const fn ptr() -> *const tc0::RegisterBlock {
1137 Self::PTR
1138 }
1139}
1140impl Deref for TC0 {
1141 type Target = tc0::RegisterBlock;
1142 #[inline(always)]
1143 fn deref(&self) -> &Self::Target {
1144 unsafe { &*Self::PTR }
1145 }
1146}
1147impl core::fmt::Debug for TC0 {
1148 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1149 f.debug_struct("TC0").finish()
1150 }
1151}
1152#[doc = "Timer Counter"]
1153pub mod tc0;
1154#[doc = "Timer Counter"]
1155pub struct TC1 {
1156 _marker: PhantomData<*const ()>,
1157}
1158unsafe impl Send for TC1 {}
1159impl TC1 {
1160 #[doc = r"Pointer to the register block"]
1161 pub const PTR: *const tc0::RegisterBlock = 0x4001_0000 as *const _;
1162 #[doc = r"Return the pointer to the register block"]
1163 #[inline(always)]
1164 pub const fn ptr() -> *const tc0::RegisterBlock {
1165 Self::PTR
1166 }
1167}
1168impl Deref for TC1 {
1169 type Target = tc0::RegisterBlock;
1170 #[inline(always)]
1171 fn deref(&self) -> &Self::Target {
1172 unsafe { &*Self::PTR }
1173 }
1174}
1175impl core::fmt::Debug for TC1 {
1176 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1177 f.debug_struct("TC1").finish()
1178 }
1179}
1180#[doc = "Timer Counter"]
1181pub use tc0 as tc1;
1182#[doc = "Timer Counter"]
1183pub struct TC2 {
1184 _marker: PhantomData<*const ()>,
1185}
1186unsafe impl Send for TC2 {}
1187impl TC2 {
1188 #[doc = r"Pointer to the register block"]
1189 pub const PTR: *const tc0::RegisterBlock = 0x4001_4000 as *const _;
1190 #[doc = r"Return the pointer to the register block"]
1191 #[inline(always)]
1192 pub const fn ptr() -> *const tc0::RegisterBlock {
1193 Self::PTR
1194 }
1195}
1196impl Deref for TC2 {
1197 type Target = tc0::RegisterBlock;
1198 #[inline(always)]
1199 fn deref(&self) -> &Self::Target {
1200 unsafe { &*Self::PTR }
1201 }
1202}
1203impl core::fmt::Debug for TC2 {
1204 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1205 f.debug_struct("TC2").finish()
1206 }
1207}
1208#[doc = "Timer Counter"]
1209pub use tc0 as tc2;
1210#[doc = "Timer Counter"]
1211pub struct TC3 {
1212 _marker: PhantomData<*const ()>,
1213}
1214unsafe impl Send for TC3 {}
1215impl TC3 {
1216 #[doc = r"Pointer to the register block"]
1217 pub const PTR: *const tc0::RegisterBlock = 0x4005_4000 as *const _;
1218 #[doc = r"Return the pointer to the register block"]
1219 #[inline(always)]
1220 pub const fn ptr() -> *const tc0::RegisterBlock {
1221 Self::PTR
1222 }
1223}
1224impl Deref for TC3 {
1225 type Target = tc0::RegisterBlock;
1226 #[inline(always)]
1227 fn deref(&self) -> &Self::Target {
1228 unsafe { &*Self::PTR }
1229 }
1230}
1231impl core::fmt::Debug for TC3 {
1232 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1233 f.debug_struct("TC3").finish()
1234 }
1235}
1236#[doc = "Timer Counter"]
1237pub use tc0 as tc3;
1238#[doc = "True Random Number Generator"]
1239pub struct TRNG {
1240 _marker: PhantomData<*const ()>,
1241}
1242unsafe impl Send for TRNG {}
1243impl TRNG {
1244 #[doc = r"Pointer to the register block"]
1245 pub const PTR: *const trng::RegisterBlock = 0x4007_0000 as *const _;
1246 #[doc = r"Return the pointer to the register block"]
1247 #[inline(always)]
1248 pub const fn ptr() -> *const trng::RegisterBlock {
1249 Self::PTR
1250 }
1251}
1252impl Deref for TRNG {
1253 type Target = trng::RegisterBlock;
1254 #[inline(always)]
1255 fn deref(&self) -> &Self::Target {
1256 unsafe { &*Self::PTR }
1257 }
1258}
1259impl core::fmt::Debug for TRNG {
1260 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1261 f.debug_struct("TRNG").finish()
1262 }
1263}
1264#[doc = "True Random Number Generator"]
1265pub mod trng;
1266#[doc = "Two-wire Interface High Speed"]
1267pub struct TWIHS0 {
1268 _marker: PhantomData<*const ()>,
1269}
1270unsafe impl Send for TWIHS0 {}
1271impl TWIHS0 {
1272 #[doc = r"Pointer to the register block"]
1273 pub const PTR: *const twihs0::RegisterBlock = 0x4001_8000 as *const _;
1274 #[doc = r"Return the pointer to the register block"]
1275 #[inline(always)]
1276 pub const fn ptr() -> *const twihs0::RegisterBlock {
1277 Self::PTR
1278 }
1279}
1280impl Deref for TWIHS0 {
1281 type Target = twihs0::RegisterBlock;
1282 #[inline(always)]
1283 fn deref(&self) -> &Self::Target {
1284 unsafe { &*Self::PTR }
1285 }
1286}
1287impl core::fmt::Debug for TWIHS0 {
1288 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1289 f.debug_struct("TWIHS0").finish()
1290 }
1291}
1292#[doc = "Two-wire Interface High Speed"]
1293pub mod twihs0;
1294#[doc = "Two-wire Interface High Speed"]
1295pub struct TWIHS1 {
1296 _marker: PhantomData<*const ()>,
1297}
1298unsafe impl Send for TWIHS1 {}
1299impl TWIHS1 {
1300 #[doc = r"Pointer to the register block"]
1301 pub const PTR: *const twihs0::RegisterBlock = 0x4001_c000 as *const _;
1302 #[doc = r"Return the pointer to the register block"]
1303 #[inline(always)]
1304 pub const fn ptr() -> *const twihs0::RegisterBlock {
1305 Self::PTR
1306 }
1307}
1308impl Deref for TWIHS1 {
1309 type Target = twihs0::RegisterBlock;
1310 #[inline(always)]
1311 fn deref(&self) -> &Self::Target {
1312 unsafe { &*Self::PTR }
1313 }
1314}
1315impl core::fmt::Debug for TWIHS1 {
1316 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1317 f.debug_struct("TWIHS1").finish()
1318 }
1319}
1320#[doc = "Two-wire Interface High Speed"]
1321pub use twihs0 as twihs1;
1322#[doc = "Two-wire Interface High Speed"]
1323pub struct TWIHS2 {
1324 _marker: PhantomData<*const ()>,
1325}
1326unsafe impl Send for TWIHS2 {}
1327impl TWIHS2 {
1328 #[doc = r"Pointer to the register block"]
1329 pub const PTR: *const twihs0::RegisterBlock = 0x4006_0000 as *const _;
1330 #[doc = r"Return the pointer to the register block"]
1331 #[inline(always)]
1332 pub const fn ptr() -> *const twihs0::RegisterBlock {
1333 Self::PTR
1334 }
1335}
1336impl Deref for TWIHS2 {
1337 type Target = twihs0::RegisterBlock;
1338 #[inline(always)]
1339 fn deref(&self) -> &Self::Target {
1340 unsafe { &*Self::PTR }
1341 }
1342}
1343impl core::fmt::Debug for TWIHS2 {
1344 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1345 f.debug_struct("TWIHS2").finish()
1346 }
1347}
1348#[doc = "Two-wire Interface High Speed"]
1349pub use twihs0 as twihs2;
1350#[doc = "Universal Asynchronous Receiver Transmitter"]
1351pub struct UART0 {
1352 _marker: PhantomData<*const ()>,
1353}
1354unsafe impl Send for UART0 {}
1355impl UART0 {
1356 #[doc = r"Pointer to the register block"]
1357 pub const PTR: *const uart0::RegisterBlock = 0x400e_0800 as *const _;
1358 #[doc = r"Return the pointer to the register block"]
1359 #[inline(always)]
1360 pub const fn ptr() -> *const uart0::RegisterBlock {
1361 Self::PTR
1362 }
1363}
1364impl Deref for UART0 {
1365 type Target = uart0::RegisterBlock;
1366 #[inline(always)]
1367 fn deref(&self) -> &Self::Target {
1368 unsafe { &*Self::PTR }
1369 }
1370}
1371impl core::fmt::Debug for UART0 {
1372 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1373 f.debug_struct("UART0").finish()
1374 }
1375}
1376#[doc = "Universal Asynchronous Receiver Transmitter"]
1377pub mod uart0;
1378#[doc = "Universal Asynchronous Receiver Transmitter"]
1379pub struct UART1 {
1380 _marker: PhantomData<*const ()>,
1381}
1382unsafe impl Send for UART1 {}
1383impl UART1 {
1384 #[doc = r"Pointer to the register block"]
1385 pub const PTR: *const uart0::RegisterBlock = 0x400e_0a00 as *const _;
1386 #[doc = r"Return the pointer to the register block"]
1387 #[inline(always)]
1388 pub const fn ptr() -> *const uart0::RegisterBlock {
1389 Self::PTR
1390 }
1391}
1392impl Deref for UART1 {
1393 type Target = uart0::RegisterBlock;
1394 #[inline(always)]
1395 fn deref(&self) -> &Self::Target {
1396 unsafe { &*Self::PTR }
1397 }
1398}
1399impl core::fmt::Debug for UART1 {
1400 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1401 f.debug_struct("UART1").finish()
1402 }
1403}
1404#[doc = "Universal Asynchronous Receiver Transmitter"]
1405pub use uart0 as uart1;
1406#[doc = "Universal Asynchronous Receiver Transmitter"]
1407pub struct UART2 {
1408 _marker: PhantomData<*const ()>,
1409}
1410unsafe impl Send for UART2 {}
1411impl UART2 {
1412 #[doc = r"Pointer to the register block"]
1413 pub const PTR: *const uart0::RegisterBlock = 0x400e_1a00 as *const _;
1414 #[doc = r"Return the pointer to the register block"]
1415 #[inline(always)]
1416 pub const fn ptr() -> *const uart0::RegisterBlock {
1417 Self::PTR
1418 }
1419}
1420impl Deref for UART2 {
1421 type Target = uart0::RegisterBlock;
1422 #[inline(always)]
1423 fn deref(&self) -> &Self::Target {
1424 unsafe { &*Self::PTR }
1425 }
1426}
1427impl core::fmt::Debug for UART2 {
1428 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1429 f.debug_struct("UART2").finish()
1430 }
1431}
1432#[doc = "Universal Asynchronous Receiver Transmitter"]
1433pub use uart0 as uart2;
1434#[doc = "Universal Asynchronous Receiver Transmitter"]
1435pub struct UART3 {
1436 _marker: PhantomData<*const ()>,
1437}
1438unsafe impl Send for UART3 {}
1439impl UART3 {
1440 #[doc = r"Pointer to the register block"]
1441 pub const PTR: *const uart0::RegisterBlock = 0x400e_1c00 as *const _;
1442 #[doc = r"Return the pointer to the register block"]
1443 #[inline(always)]
1444 pub const fn ptr() -> *const uart0::RegisterBlock {
1445 Self::PTR
1446 }
1447}
1448impl Deref for UART3 {
1449 type Target = uart0::RegisterBlock;
1450 #[inline(always)]
1451 fn deref(&self) -> &Self::Target {
1452 unsafe { &*Self::PTR }
1453 }
1454}
1455impl core::fmt::Debug for UART3 {
1456 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1457 f.debug_struct("UART3").finish()
1458 }
1459}
1460#[doc = "Universal Asynchronous Receiver Transmitter"]
1461pub use uart0 as uart3;
1462#[doc = "Universal Asynchronous Receiver Transmitter"]
1463pub struct UART4 {
1464 _marker: PhantomData<*const ()>,
1465}
1466unsafe impl Send for UART4 {}
1467impl UART4 {
1468 #[doc = r"Pointer to the register block"]
1469 pub const PTR: *const uart0::RegisterBlock = 0x400e_1e00 as *const _;
1470 #[doc = r"Return the pointer to the register block"]
1471 #[inline(always)]
1472 pub const fn ptr() -> *const uart0::RegisterBlock {
1473 Self::PTR
1474 }
1475}
1476impl Deref for UART4 {
1477 type Target = uart0::RegisterBlock;
1478 #[inline(always)]
1479 fn deref(&self) -> &Self::Target {
1480 unsafe { &*Self::PTR }
1481 }
1482}
1483impl core::fmt::Debug for UART4 {
1484 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1485 f.debug_struct("UART4").finish()
1486 }
1487}
1488#[doc = "Universal Asynchronous Receiver Transmitter"]
1489pub use uart0 as uart4;
1490#[doc = "Universal Synchronous Asynchronous Receiver Transmitter"]
1491pub struct USART0 {
1492 _marker: PhantomData<*const ()>,
1493}
1494unsafe impl Send for USART0 {}
1495impl USART0 {
1496 #[doc = r"Pointer to the register block"]
1497 pub const PTR: *const usart0::RegisterBlock = 0x4002_4000 as *const _;
1498 #[doc = r"Return the pointer to the register block"]
1499 #[inline(always)]
1500 pub const fn ptr() -> *const usart0::RegisterBlock {
1501 Self::PTR
1502 }
1503}
1504impl Deref for USART0 {
1505 type Target = usart0::RegisterBlock;
1506 #[inline(always)]
1507 fn deref(&self) -> &Self::Target {
1508 unsafe { &*Self::PTR }
1509 }
1510}
1511impl core::fmt::Debug for USART0 {
1512 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1513 f.debug_struct("USART0").finish()
1514 }
1515}
1516#[doc = "Universal Synchronous Asynchronous Receiver Transmitter"]
1517pub mod usart0;
1518#[doc = "Universal Synchronous Asynchronous Receiver Transmitter"]
1519pub struct USART1 {
1520 _marker: PhantomData<*const ()>,
1521}
1522unsafe impl Send for USART1 {}
1523impl USART1 {
1524 #[doc = r"Pointer to the register block"]
1525 pub const PTR: *const usart0::RegisterBlock = 0x4002_8000 as *const _;
1526 #[doc = r"Return the pointer to the register block"]
1527 #[inline(always)]
1528 pub const fn ptr() -> *const usart0::RegisterBlock {
1529 Self::PTR
1530 }
1531}
1532impl Deref for USART1 {
1533 type Target = usart0::RegisterBlock;
1534 #[inline(always)]
1535 fn deref(&self) -> &Self::Target {
1536 unsafe { &*Self::PTR }
1537 }
1538}
1539impl core::fmt::Debug for USART1 {
1540 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1541 f.debug_struct("USART1").finish()
1542 }
1543}
1544#[doc = "Universal Synchronous Asynchronous Receiver Transmitter"]
1545pub use usart0 as usart1;
1546#[doc = "Universal Synchronous Asynchronous Receiver Transmitter"]
1547pub struct USART2 {
1548 _marker: PhantomData<*const ()>,
1549}
1550unsafe impl Send for USART2 {}
1551impl USART2 {
1552 #[doc = r"Pointer to the register block"]
1553 pub const PTR: *const usart0::RegisterBlock = 0x4002_c000 as *const _;
1554 #[doc = r"Return the pointer to the register block"]
1555 #[inline(always)]
1556 pub const fn ptr() -> *const usart0::RegisterBlock {
1557 Self::PTR
1558 }
1559}
1560impl Deref for USART2 {
1561 type Target = usart0::RegisterBlock;
1562 #[inline(always)]
1563 fn deref(&self) -> &Self::Target {
1564 unsafe { &*Self::PTR }
1565 }
1566}
1567impl core::fmt::Debug for USART2 {
1568 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1569 f.debug_struct("USART2").finish()
1570 }
1571}
1572#[doc = "Universal Synchronous Asynchronous Receiver Transmitter"]
1573pub use usart0 as usart2;
1574#[doc = "USB High-Speed Interface"]
1575pub struct USBHS {
1576 _marker: PhantomData<*const ()>,
1577}
1578unsafe impl Send for USBHS {}
1579impl USBHS {
1580 #[doc = r"Pointer to the register block"]
1581 pub const PTR: *const usbhs::RegisterBlock = 0x4003_8000 as *const _;
1582 #[doc = r"Return the pointer to the register block"]
1583 #[inline(always)]
1584 pub const fn ptr() -> *const usbhs::RegisterBlock {
1585 Self::PTR
1586 }
1587}
1588impl Deref for USBHS {
1589 type Target = usbhs::RegisterBlock;
1590 #[inline(always)]
1591 fn deref(&self) -> &Self::Target {
1592 unsafe { &*Self::PTR }
1593 }
1594}
1595impl core::fmt::Debug for USBHS {
1596 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1597 f.debug_struct("USBHS").finish()
1598 }
1599}
1600#[doc = "USB High-Speed Interface"]
1601pub mod usbhs;
1602#[doc = "USB Transmitter Interface Macrocell"]
1603pub struct UTMI {
1604 _marker: PhantomData<*const ()>,
1605}
1606unsafe impl Send for UTMI {}
1607impl UTMI {
1608 #[doc = r"Pointer to the register block"]
1609 pub const PTR: *const utmi::RegisterBlock = 0x400e_0400 as *const _;
1610 #[doc = r"Return the pointer to the register block"]
1611 #[inline(always)]
1612 pub const fn ptr() -> *const utmi::RegisterBlock {
1613 Self::PTR
1614 }
1615}
1616impl Deref for UTMI {
1617 type Target = utmi::RegisterBlock;
1618 #[inline(always)]
1619 fn deref(&self) -> &Self::Target {
1620 unsafe { &*Self::PTR }
1621 }
1622}
1623impl core::fmt::Debug for UTMI {
1624 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1625 f.debug_struct("UTMI").finish()
1626 }
1627}
1628#[doc = "USB Transmitter Interface Macrocell"]
1629pub mod utmi;
1630#[doc = "Watchdog Timer"]
1631pub struct WDT {
1632 _marker: PhantomData<*const ()>,
1633}
1634unsafe impl Send for WDT {}
1635impl WDT {
1636 #[doc = r"Pointer to the register block"]
1637 pub const PTR: *const wdt::RegisterBlock = 0x400e_1850 as *const _;
1638 #[doc = r"Return the pointer to the register block"]
1639 #[inline(always)]
1640 pub const fn ptr() -> *const wdt::RegisterBlock {
1641 Self::PTR
1642 }
1643}
1644impl Deref for WDT {
1645 type Target = wdt::RegisterBlock;
1646 #[inline(always)]
1647 fn deref(&self) -> &Self::Target {
1648 unsafe { &*Self::PTR }
1649 }
1650}
1651impl core::fmt::Debug for WDT {
1652 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1653 f.debug_struct("WDT").finish()
1654 }
1655}
1656#[doc = "Watchdog Timer"]
1657pub mod wdt;
1658#[doc = "Extensible DMA Controller"]
1659pub struct XDMAC {
1660 _marker: PhantomData<*const ()>,
1661}
1662unsafe impl Send for XDMAC {}
1663impl XDMAC {
1664 #[doc = r"Pointer to the register block"]
1665 pub const PTR: *const xdmac::RegisterBlock = 0x4007_8000 as *const _;
1666 #[doc = r"Return the pointer to the register block"]
1667 #[inline(always)]
1668 pub const fn ptr() -> *const xdmac::RegisterBlock {
1669 Self::PTR
1670 }
1671}
1672impl Deref for XDMAC {
1673 type Target = xdmac::RegisterBlock;
1674 #[inline(always)]
1675 fn deref(&self) -> &Self::Target {
1676 unsafe { &*Self::PTR }
1677 }
1678}
1679impl core::fmt::Debug for XDMAC {
1680 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1681 f.debug_struct("XDMAC").finish()
1682 }
1683}
1684#[doc = "Extensible DMA Controller"]
1685pub mod xdmac;
1686#[doc = "LOCKBIT"]
1687pub struct LOCKBIT {
1688 _marker: PhantomData<*const ()>,
1689}
1690unsafe impl Send for LOCKBIT {}
1691impl LOCKBIT {
1692 #[doc = r"Pointer to the register block"]
1693 pub const PTR: *const lockbit::RegisterBlock = 0 as *const _;
1694 #[doc = r"Return the pointer to the register block"]
1695 #[inline(always)]
1696 pub const fn ptr() -> *const lockbit::RegisterBlock {
1697 Self::PTR
1698 }
1699}
1700impl Deref for LOCKBIT {
1701 type Target = lockbit::RegisterBlock;
1702 #[inline(always)]
1703 fn deref(&self) -> &Self::Target {
1704 unsafe { &*Self::PTR }
1705 }
1706}
1707impl core::fmt::Debug for LOCKBIT {
1708 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1709 f.debug_struct("LOCKBIT").finish()
1710 }
1711}
1712#[doc = "LOCKBIT"]
1713pub mod lockbit;
1714#[doc = "System control not in SCB"]
1715pub struct SCNSCB {
1716 _marker: PhantomData<*const ()>,
1717}
1718unsafe impl Send for SCNSCB {}
1719impl SCNSCB {
1720 #[doc = r"Pointer to the register block"]
1721 pub const PTR: *const scn_scb::RegisterBlock = 0xe000_e000 as *const _;
1722 #[doc = r"Return the pointer to the register block"]
1723 #[inline(always)]
1724 pub const fn ptr() -> *const scn_scb::RegisterBlock {
1725 Self::PTR
1726 }
1727}
1728impl Deref for SCNSCB {
1729 type Target = scn_scb::RegisterBlock;
1730 #[inline(always)]
1731 fn deref(&self) -> &Self::Target {
1732 unsafe { &*Self::PTR }
1733 }
1734}
1735impl core::fmt::Debug for SCNSCB {
1736 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1737 f.debug_struct("SCNSCB").finish()
1738 }
1739}
1740#[doc = "System control not in SCB"]
1741pub mod scn_scb;
1742#[doc = "System timer"]
1743pub struct SYSTICK {
1744 _marker: PhantomData<*const ()>,
1745}
1746unsafe impl Send for SYSTICK {}
1747impl SYSTICK {
1748 #[doc = r"Pointer to the register block"]
1749 pub const PTR: *const sys_tick::RegisterBlock = 0xe000_e010 as *const _;
1750 #[doc = r"Return the pointer to the register block"]
1751 #[inline(always)]
1752 pub const fn ptr() -> *const sys_tick::RegisterBlock {
1753 Self::PTR
1754 }
1755}
1756impl Deref for SYSTICK {
1757 type Target = sys_tick::RegisterBlock;
1758 #[inline(always)]
1759 fn deref(&self) -> &Self::Target {
1760 unsafe { &*Self::PTR }
1761 }
1762}
1763impl core::fmt::Debug for SYSTICK {
1764 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1765 f.debug_struct("SYSTICK").finish()
1766 }
1767}
1768#[doc = "System timer"]
1769pub mod sys_tick;
1770#[no_mangle]
1771static mut DEVICE_PERIPHERALS: bool = false;
1772#[doc = r"All the peripherals"]
1773#[allow(non_snake_case)]
1774pub struct Peripherals {
1775 #[doc = "ACC"]
1776 pub ACC: ACC,
1777 #[doc = "AES"]
1778 pub AES: AES,
1779 #[doc = "AFEC0"]
1780 pub AFEC0: AFEC0,
1781 #[doc = "AFEC1"]
1782 pub AFEC1: AFEC1,
1783 #[doc = "CHIPID"]
1784 pub CHIPID: CHIPID,
1785 #[doc = "EFC"]
1786 pub EFC: EFC,
1787 #[doc = "GMAC"]
1788 pub GMAC: GMAC,
1789 #[doc = "GPBR"]
1790 pub GPBR: GPBR,
1791 #[doc = "HSMCI"]
1792 pub HSMCI: HSMCI,
1793 #[doc = "ICM"]
1794 pub ICM: ICM,
1795 #[doc = "ISI"]
1796 pub ISI: ISI,
1797 #[doc = "MATRIX"]
1798 pub MATRIX: MATRIX,
1799 #[doc = "MCAN0"]
1800 pub MCAN0: MCAN0,
1801 #[doc = "MCAN1"]
1802 pub MCAN1: MCAN1,
1803 #[doc = "MLB"]
1804 pub MLB: MLB,
1805 #[doc = "PIOA"]
1806 pub PIOA: PIOA,
1807 #[doc = "PIOB"]
1808 pub PIOB: PIOB,
1809 #[doc = "PIOD"]
1810 pub PIOD: PIOD,
1811 #[doc = "PMC"]
1812 pub PMC: PMC,
1813 #[doc = "PWM0"]
1814 pub PWM0: PWM0,
1815 #[doc = "PWM1"]
1816 pub PWM1: PWM1,
1817 #[doc = "QSPI"]
1818 pub QSPI: QSPI,
1819 #[doc = "RSTC"]
1820 pub RSTC: RSTC,
1821 #[doc = "RSWDT"]
1822 pub RSWDT: RSWDT,
1823 #[doc = "RTC"]
1824 pub RTC: RTC,
1825 #[doc = "RTT"]
1826 pub RTT: RTT,
1827 #[doc = "SPI0"]
1828 pub SPI0: SPI0,
1829 #[doc = "SSC"]
1830 pub SSC: SSC,
1831 #[doc = "SUPC"]
1832 pub SUPC: SUPC,
1833 #[doc = "TC0"]
1834 pub TC0: TC0,
1835 #[doc = "TC1"]
1836 pub TC1: TC1,
1837 #[doc = "TC2"]
1838 pub TC2: TC2,
1839 #[doc = "TC3"]
1840 pub TC3: TC3,
1841 #[doc = "TRNG"]
1842 pub TRNG: TRNG,
1843 #[doc = "TWIHS0"]
1844 pub TWIHS0: TWIHS0,
1845 #[doc = "TWIHS1"]
1846 pub TWIHS1: TWIHS1,
1847 #[doc = "TWIHS2"]
1848 pub TWIHS2: TWIHS2,
1849 #[doc = "UART0"]
1850 pub UART0: UART0,
1851 #[doc = "UART1"]
1852 pub UART1: UART1,
1853 #[doc = "UART2"]
1854 pub UART2: UART2,
1855 #[doc = "UART3"]
1856 pub UART3: UART3,
1857 #[doc = "UART4"]
1858 pub UART4: UART4,
1859 #[doc = "USART0"]
1860 pub USART0: USART0,
1861 #[doc = "USART1"]
1862 pub USART1: USART1,
1863 #[doc = "USART2"]
1864 pub USART2: USART2,
1865 #[doc = "USBHS"]
1866 pub USBHS: USBHS,
1867 #[doc = "UTMI"]
1868 pub UTMI: UTMI,
1869 #[doc = "WDT"]
1870 pub WDT: WDT,
1871 #[doc = "XDMAC"]
1872 pub XDMAC: XDMAC,
1873 #[doc = "LOCKBIT"]
1874 pub LOCKBIT: LOCKBIT,
1875 #[doc = "SCNSCB"]
1876 pub SCNSCB: SCNSCB,
1877 #[doc = "SYSTICK"]
1878 pub SYSTICK: SYSTICK,
1879}
1880impl Peripherals {
1881 #[doc = r"Returns all the peripherals *once*"]
1882 #[inline]
1883 pub fn take() -> Option<Self> {
1884 cortex_m::interrupt::free(|_| {
1885 if unsafe { DEVICE_PERIPHERALS } {
1886 None
1887 } else {
1888 Some(unsafe { Peripherals::steal() })
1889 }
1890 })
1891 }
1892 #[doc = r"Unchecked version of `Peripherals::take`"]
1893 #[inline]
1894 pub unsafe fn steal() -> Self {
1895 DEVICE_PERIPHERALS = true;
1896 Peripherals {
1897 ACC: ACC {
1898 _marker: PhantomData,
1899 },
1900 AES: AES {
1901 _marker: PhantomData,
1902 },
1903 AFEC0: AFEC0 {
1904 _marker: PhantomData,
1905 },
1906 AFEC1: AFEC1 {
1907 _marker: PhantomData,
1908 },
1909 CHIPID: CHIPID {
1910 _marker: PhantomData,
1911 },
1912 EFC: EFC {
1913 _marker: PhantomData,
1914 },
1915 GMAC: GMAC {
1916 _marker: PhantomData,
1917 },
1918 GPBR: GPBR {
1919 _marker: PhantomData,
1920 },
1921 HSMCI: HSMCI {
1922 _marker: PhantomData,
1923 },
1924 ICM: ICM {
1925 _marker: PhantomData,
1926 },
1927 ISI: ISI {
1928 _marker: PhantomData,
1929 },
1930 MATRIX: MATRIX {
1931 _marker: PhantomData,
1932 },
1933 MCAN0: MCAN0 {
1934 _marker: PhantomData,
1935 },
1936 MCAN1: MCAN1 {
1937 _marker: PhantomData,
1938 },
1939 MLB: MLB {
1940 _marker: PhantomData,
1941 },
1942 PIOA: PIOA {
1943 _marker: PhantomData,
1944 },
1945 PIOB: PIOB {
1946 _marker: PhantomData,
1947 },
1948 PIOD: PIOD {
1949 _marker: PhantomData,
1950 },
1951 PMC: PMC {
1952 _marker: PhantomData,
1953 },
1954 PWM0: PWM0 {
1955 _marker: PhantomData,
1956 },
1957 PWM1: PWM1 {
1958 _marker: PhantomData,
1959 },
1960 QSPI: QSPI {
1961 _marker: PhantomData,
1962 },
1963 RSTC: RSTC {
1964 _marker: PhantomData,
1965 },
1966 RSWDT: RSWDT {
1967 _marker: PhantomData,
1968 },
1969 RTC: RTC {
1970 _marker: PhantomData,
1971 },
1972 RTT: RTT {
1973 _marker: PhantomData,
1974 },
1975 SPI0: SPI0 {
1976 _marker: PhantomData,
1977 },
1978 SSC: SSC {
1979 _marker: PhantomData,
1980 },
1981 SUPC: SUPC {
1982 _marker: PhantomData,
1983 },
1984 TC0: TC0 {
1985 _marker: PhantomData,
1986 },
1987 TC1: TC1 {
1988 _marker: PhantomData,
1989 },
1990 TC2: TC2 {
1991 _marker: PhantomData,
1992 },
1993 TC3: TC3 {
1994 _marker: PhantomData,
1995 },
1996 TRNG: TRNG {
1997 _marker: PhantomData,
1998 },
1999 TWIHS0: TWIHS0 {
2000 _marker: PhantomData,
2001 },
2002 TWIHS1: TWIHS1 {
2003 _marker: PhantomData,
2004 },
2005 TWIHS2: TWIHS2 {
2006 _marker: PhantomData,
2007 },
2008 UART0: UART0 {
2009 _marker: PhantomData,
2010 },
2011 UART1: UART1 {
2012 _marker: PhantomData,
2013 },
2014 UART2: UART2 {
2015 _marker: PhantomData,
2016 },
2017 UART3: UART3 {
2018 _marker: PhantomData,
2019 },
2020 UART4: UART4 {
2021 _marker: PhantomData,
2022 },
2023 USART0: USART0 {
2024 _marker: PhantomData,
2025 },
2026 USART1: USART1 {
2027 _marker: PhantomData,
2028 },
2029 USART2: USART2 {
2030 _marker: PhantomData,
2031 },
2032 USBHS: USBHS {
2033 _marker: PhantomData,
2034 },
2035 UTMI: UTMI {
2036 _marker: PhantomData,
2037 },
2038 WDT: WDT {
2039 _marker: PhantomData,
2040 },
2041 XDMAC: XDMAC {
2042 _marker: PhantomData,
2043 },
2044 LOCKBIT: LOCKBIT {
2045 _marker: PhantomData,
2046 },
2047 SCNSCB: SCNSCB {
2048 _marker: PhantomData,
2049 },
2050 SYSTICK: SYSTICK {
2051 _marker: PhantomData,
2052 },
2053 }
2054 }
2055}