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