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