1#![doc = "Peripheral access API for SSE300 microcontrollers (generated using svd2rust v0.26.0 ( ))\n\nYou can find an overview of the generated API [here].\n\nAPI features to be included in the [next]
2
3// Copyright 2022 Arm Limited and/or its affiliates <open-source-office@arm.com>
4//
5// SPDX-License-Identifier: MIT
6
7svd2rust 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.26.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"]
8#![deny(const_err)]
9#![deny(dead_code)]
10#![deny(improper_ctypes)]
11#![deny(missing_docs)]
12#![deny(no_mangle_generic_items)]
13#![deny(non_shorthand_field_patterns)]
14#![deny(overflowing_literals)]
15#![deny(path_statements)]
16#![deny(patterns_in_fns_without_body)]
17#![deny(private_in_public)]
18#![deny(unconditional_recursion)]
19#![deny(unused_allocation)]
20#![deny(unused_comparisons)]
21#![deny(unused_parens)]
22#![deny(while_true)]
23#![allow(non_camel_case_types)]
24#![allow(non_snake_case)]
25#![no_std]
26use core::marker::PhantomData;
27use core::ops::Deref;
28#[doc = r"Number available in the NVIC for configuring priority"]
29pub const NVIC_PRIO_BITS: u8 = 3;
30#[cfg(feature = "rt")]
31pub use self::Interrupt as interrupt;
32pub use cortex_m::peripheral::Peripherals as CorePeripherals;
33pub use cortex_m::peripheral::{CBP, CPUID, DCB, DWT, FPB, FPU, ITM, MPU, NVIC, SCB, SYST, TPIU};
34#[cfg(feature = "rt")]
35pub use cortex_m_rt::interrupt;
36#[allow(unused_imports)]
37use generic::*;
38#[doc = r"Common register and bit access and modify traits"]
39pub mod generic;
40#[cfg(feature = "rt")]
41extern "C" {
42 fn NONSEC_WATCHDOG_RST_REQ();
43 fn NONSEC_WATCHDOG_IRQ();
44 fn S32K_TIMER();
45 fn TIMER0();
46 fn TIMER1();
47 fn DUALTIMER();
48 fn MPC();
49 fn PPC();
50 fn MSC();
51 fn BRG();
52 fn MGMT_PPU();
53 fn SYS_PPU();
54 fn CPU0_PPU();
55 fn PPU_DEBUG();
56 fn TIMER3();
57 fn SYSTEM_TIMESTAMP_COUNTER();
58 fn UART0_RX();
59 fn UART0_TX();
60 fn UART1_RX();
61 fn UART1_TX();
62 fn UART2_RX();
63 fn UART2_TX();
64 fn UART3_RX();
65 fn UART3_TX();
66 fn UART4_RX();
67 fn UART4_TX();
68 fn UART0_COMBINED();
69 fn UART1_COMBINED();
70 fn UART2_COMBINED();
71 fn UART3_COMBINED();
72 fn UART4_COMBINED();
73 fn UART_OVERFLOW();
74 fn ETHERNET();
75 fn AUDIO_I2S();
76 fn TOUCH_SCREEN();
77 fn USB();
78 fn SPI2();
79 fn SPI0();
80 fn SPI1();
81 fn GPIO0_COMBINED();
82 fn GPIO1_COMBINED();
83 fn GPIO2_COMBINED();
84 fn GPIO3_COMBINED();
85 fn UART5_RX();
86 fn UART5_TX();
87 fn UART5_COMBINED();
88}
89#[doc(hidden)]
90pub union Vector {
91 _handler: unsafe extern "C" fn(),
92 _reserved: u32,
93}
94#[cfg(feature = "rt")]
95#[doc(hidden)]
96#[link_section = ".vector_table.interrupts"]
97#[no_mangle]
98pub static __INTERRUPTS: [Vector; 128] = [
99 Vector {
100 _handler: NONSEC_WATCHDOG_RST_REQ,
101 },
102 Vector {
103 _handler: NONSEC_WATCHDOG_IRQ,
104 },
105 Vector {
106 _handler: S32K_TIMER,
107 },
108 Vector { _handler: TIMER0 },
109 Vector { _handler: TIMER1 },
110 Vector {
111 _handler: DUALTIMER,
112 },
113 Vector { _reserved: 0 },
114 Vector { _reserved: 0 },
115 Vector { _reserved: 0 },
116 Vector { _handler: MPC },
117 Vector { _handler: PPC },
118 Vector { _handler: MSC },
119 Vector { _handler: BRG },
120 Vector { _reserved: 0 },
121 Vector { _handler: MGMT_PPU },
122 Vector { _handler: SYS_PPU },
123 Vector { _handler: CPU0_PPU },
124 Vector { _reserved: 0 },
125 Vector { _reserved: 0 },
126 Vector { _reserved: 0 },
127 Vector { _reserved: 0 },
128 Vector { _reserved: 0 },
129 Vector { _reserved: 0 },
130 Vector { _reserved: 0 },
131 Vector { _reserved: 0 },
132 Vector { _reserved: 0 },
133 Vector {
134 _handler: PPU_DEBUG,
135 },
136 Vector { _handler: TIMER3 },
137 Vector { _reserved: 0 },
138 Vector { _reserved: 0 },
139 Vector { _reserved: 0 },
140 Vector { _reserved: 0 },
141 Vector {
142 _handler: SYSTEM_TIMESTAMP_COUNTER,
143 },
144 Vector { _handler: UART0_RX },
145 Vector { _handler: UART0_TX },
146 Vector { _handler: UART1_RX },
147 Vector { _handler: UART1_TX },
148 Vector { _handler: UART2_RX },
149 Vector { _handler: UART2_TX },
150 Vector { _handler: UART3_RX },
151 Vector { _handler: UART3_TX },
152 Vector { _handler: UART4_RX },
153 Vector { _handler: UART4_TX },
154 Vector {
155 _handler: UART0_COMBINED,
156 },
157 Vector {
158 _handler: UART1_COMBINED,
159 },
160 Vector {
161 _handler: UART2_COMBINED,
162 },
163 Vector {
164 _handler: UART3_COMBINED,
165 },
166 Vector {
167 _handler: UART4_COMBINED,
168 },
169 Vector {
170 _handler: UART_OVERFLOW,
171 },
172 Vector { _handler: ETHERNET },
173 Vector {
174 _handler: AUDIO_I2S,
175 },
176 Vector {
177 _handler: TOUCH_SCREEN,
178 },
179 Vector { _handler: USB },
180 Vector { _handler: SPI2 },
181 Vector { _handler: SPI0 },
182 Vector { _handler: SPI1 },
183 Vector { _reserved: 0 },
184 Vector { _reserved: 0 },
185 Vector { _reserved: 0 },
186 Vector { _reserved: 0 },
187 Vector { _reserved: 0 },
188 Vector { _reserved: 0 },
189 Vector { _reserved: 0 },
190 Vector { _reserved: 0 },
191 Vector { _reserved: 0 },
192 Vector { _reserved: 0 },
193 Vector { _reserved: 0 },
194 Vector { _reserved: 0 },
195 Vector { _reserved: 0 },
196 Vector {
197 _handler: GPIO0_COMBINED,
198 },
199 Vector {
200 _handler: GPIO1_COMBINED,
201 },
202 Vector {
203 _handler: GPIO2_COMBINED,
204 },
205 Vector {
206 _handler: GPIO3_COMBINED,
207 },
208 Vector { _reserved: 0 },
209 Vector { _reserved: 0 },
210 Vector { _reserved: 0 },
211 Vector { _reserved: 0 },
212 Vector { _reserved: 0 },
213 Vector { _reserved: 0 },
214 Vector { _reserved: 0 },
215 Vector { _reserved: 0 },
216 Vector { _reserved: 0 },
217 Vector { _reserved: 0 },
218 Vector { _reserved: 0 },
219 Vector { _reserved: 0 },
220 Vector { _reserved: 0 },
221 Vector { _reserved: 0 },
222 Vector { _reserved: 0 },
223 Vector { _reserved: 0 },
224 Vector { _reserved: 0 },
225 Vector { _reserved: 0 },
226 Vector { _reserved: 0 },
227 Vector { _reserved: 0 },
228 Vector { _reserved: 0 },
229 Vector { _reserved: 0 },
230 Vector { _reserved: 0 },
231 Vector { _reserved: 0 },
232 Vector { _reserved: 0 },
233 Vector { _reserved: 0 },
234 Vector { _reserved: 0 },
235 Vector { _reserved: 0 },
236 Vector { _reserved: 0 },
237 Vector { _reserved: 0 },
238 Vector { _reserved: 0 },
239 Vector { _reserved: 0 },
240 Vector { _reserved: 0 },
241 Vector { _reserved: 0 },
242 Vector { _reserved: 0 },
243 Vector { _reserved: 0 },
244 Vector { _reserved: 0 },
245 Vector { _reserved: 0 },
246 Vector { _reserved: 0 },
247 Vector { _reserved: 0 },
248 Vector { _reserved: 0 },
249 Vector { _reserved: 0 },
250 Vector { _reserved: 0 },
251 Vector { _reserved: 0 },
252 Vector { _reserved: 0 },
253 Vector { _reserved: 0 },
254 Vector { _reserved: 0 },
255 Vector { _reserved: 0 },
256 Vector { _reserved: 0 },
257 Vector { _reserved: 0 },
258 Vector { _reserved: 0 },
259 Vector { _reserved: 0 },
260 Vector { _handler: UART5_RX },
261 Vector { _handler: UART5_TX },
262 Vector {
263 _handler: UART5_COMBINED,
264 },
265];
266#[doc = r"Enumeration of all the interrupts."]
267#[derive(Copy, Clone, Debug, PartialEq, Eq)]
268#[repr(u16)]
269pub enum Interrupt {
270 #[doc = "0 - Non-Secure Watchdog reset Request"]
271 NONSEC_WATCHDOG_RST_REQ = 0,
272 #[doc = "1 - Non-Secure Watchdog Interrupt"]
273 NONSEC_WATCHDOG_IRQ = 1,
274 #[doc = "2 - S32K Timer"]
275 S32K_TIMER = 2,
276 #[doc = "3 - Timer 0"]
277 TIMER0 = 3,
278 #[doc = "4 - Timer 1"]
279 TIMER1 = 4,
280 #[doc = "5 - Timer 2"]
281 DUALTIMER = 5,
282 #[doc = "9 - MPC Combined"]
283 MPC = 9,
284 #[doc = "10 - PPC Combined"]
285 PPC = 10,
286 #[doc = "11 - MSC Combined"]
287 MSC = 11,
288 #[doc = "12 - Bridge Buffer Error"]
289 BRG = 12,
290 #[doc = "14 - MGMT_PPU"]
291 MGMT_PPU = 14,
292 #[doc = "15 - SYS_PPU"]
293 SYS_PPU = 15,
294 #[doc = "16 - CPU0_PPU"]
295 CPU0_PPU = 16,
296 #[doc = "26 - PPU_DEBUG"]
297 PPU_DEBUG = 26,
298 #[doc = "27 - Timer 3"]
299 TIMER3 = 27,
300 #[doc = "32 - System_Timestamp_Counter"]
301 SYSTEM_TIMESTAMP_COUNTER = 32,
302 #[doc = "33 - UART 0 RX"]
303 UART0_RX = 33,
304 #[doc = "34 - UART 0 TX"]
305 UART0_TX = 34,
306 #[doc = "35 - UART 1 RX"]
307 UART1_RX = 35,
308 #[doc = "36 - UART 1 TX"]
309 UART1_TX = 36,
310 #[doc = "37 - UART 2 RX"]
311 UART2_RX = 37,
312 #[doc = "38 - UART 2 TX"]
313 UART2_TX = 38,
314 #[doc = "39 - UART 3 RX"]
315 UART3_RX = 39,
316 #[doc = "40 - UART 3 TX"]
317 UART3_TX = 40,
318 #[doc = "41 - UART 4 RX"]
319 UART4_RX = 41,
320 #[doc = "42 - UART 4 TX"]
321 UART4_TX = 42,
322 #[doc = "43 - UART 0 Combined interrupt"]
323 UART0_COMBINED = 43,
324 #[doc = "44 - UART 1 Combined interrupt"]
325 UART1_COMBINED = 44,
326 #[doc = "45 - UART 2 Combined interrupt"]
327 UART2_COMBINED = 45,
328 #[doc = "46 - UART 3 Combined interrupt"]
329 UART3_COMBINED = 46,
330 #[doc = "47 - UART 4 Combined interrupt"]
331 UART4_COMBINED = 47,
332 #[doc = "48 - UART 0 to 5 combined overflow/overrun"]
333 UART_OVERFLOW = 48,
334 #[doc = "49 - Ethernet"]
335 ETHERNET = 49,
336 #[doc = "50 - AudioI2S"]
337 AUDIO_I2S = 50,
338 #[doc = "51 - TouchScreen"]
339 TOUCH_SCREEN = 51,
340 #[doc = "52 - USB"]
341 USB = 52,
342 #[doc = "53 - SPI 2"]
343 SPI2 = 53,
344 #[doc = "54 - SPI 0"]
345 SPI0 = 54,
346 #[doc = "55 - SPI 1"]
347 SPI1 = 55,
348 #[doc = "69 - GPIO 0 combined"]
349 GPIO0_COMBINED = 69,
350 #[doc = "70 - GPIO 1 combined"]
351 GPIO1_COMBINED = 70,
352 #[doc = "71 - GPIO 2 combined"]
353 GPIO2_COMBINED = 71,
354 #[doc = "72 - GPIO 3 combined"]
355 GPIO3_COMBINED = 72,
356 #[doc = "125 - UART 5 RX"]
357 UART5_RX = 125,
358 #[doc = "126 - UART 5 TX"]
359 UART5_TX = 126,
360 #[doc = "127 - UART 5 Combined interrupt"]
361 UART5_COMBINED = 127,
362}
363unsafe impl cortex_m::interrupt::InterruptNumber for Interrupt {
364 #[inline(always)]
365 fn number(self) -> u16 {
366 self as u16
367 }
368}
369#[doc = "System counter control"]
370pub struct SYSCOUNTER_CNTRL {
371 _marker: PhantomData<*const ()>,
372}
373unsafe impl Send for SYSCOUNTER_CNTRL {}
374impl SYSCOUNTER_CNTRL {
375 #[doc = r"Pointer to the register block"]
376 pub const PTR: *const syscounter_cntrl::RegisterBlock = 0x5810_0000 as *const _;
377 #[doc = r"Return the pointer to the register block"]
378 #[inline(always)]
379 pub const fn ptr() -> *const syscounter_cntrl::RegisterBlock {
380 Self::PTR
381 }
382}
383impl Deref for SYSCOUNTER_CNTRL {
384 type Target = syscounter_cntrl::RegisterBlock;
385 #[inline(always)]
386 fn deref(&self) -> &Self::Target {
387 unsafe { &*Self::PTR }
388 }
389}
390impl core::fmt::Debug for SYSCOUNTER_CNTRL {
391 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
392 f.debug_struct("SYSCOUNTER_CNTRL").finish()
393 }
394}
395#[doc = "System counter control"]
396pub mod syscounter_cntrl;
397#[doc = "System counter read"]
398pub struct SYSCOUNTER_READ {
399 _marker: PhantomData<*const ()>,
400}
401unsafe impl Send for SYSCOUNTER_READ {}
402impl SYSCOUNTER_READ {
403 #[doc = r"Pointer to the register block"]
404 pub const PTR: *const syscounter_read::RegisterBlock = 0x4810_1000 as *const _;
405 #[doc = r"Return the pointer to the register block"]
406 #[inline(always)]
407 pub const fn ptr() -> *const syscounter_read::RegisterBlock {
408 Self::PTR
409 }
410}
411impl Deref for SYSCOUNTER_READ {
412 type Target = syscounter_read::RegisterBlock;
413 #[inline(always)]
414 fn deref(&self) -> &Self::Target {
415 unsafe { &*Self::PTR }
416 }
417}
418impl core::fmt::Debug for SYSCOUNTER_READ {
419 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
420 f.debug_struct("SYSCOUNTER_READ").finish()
421 }
422}
423#[doc = "System counter read"]
424pub mod syscounter_read;
425#[doc = "System Counter Read (Secure)"]
426pub struct SYSCOUNTER_READ_SECURE {
427 _marker: PhantomData<*const ()>,
428}
429unsafe impl Send for SYSCOUNTER_READ_SECURE {}
430impl SYSCOUNTER_READ_SECURE {
431 #[doc = r"Pointer to the register block"]
432 pub const PTR: *const syscounter_read::RegisterBlock = 0x5810_1000 as *const _;
433 #[doc = r"Return the pointer to the register block"]
434 #[inline(always)]
435 pub const fn ptr() -> *const syscounter_read::RegisterBlock {
436 Self::PTR
437 }
438}
439impl Deref for SYSCOUNTER_READ_SECURE {
440 type Target = syscounter_read::RegisterBlock;
441 #[inline(always)]
442 fn deref(&self) -> &Self::Target {
443 unsafe { &*Self::PTR }
444 }
445}
446impl core::fmt::Debug for SYSCOUNTER_READ_SECURE {
447 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
448 f.debug_struct("SYSCOUNTER_READ_SECURE").finish()
449 }
450}
451#[doc = "System Counter Read (Secure)"]
452pub use self::syscounter_read as syscounter_read_secure;
453#[doc = "System Information"]
454pub struct SYSINFO {
455 _marker: PhantomData<*const ()>,
456}
457unsafe impl Send for SYSINFO {}
458impl SYSINFO {
459 #[doc = r"Pointer to the register block"]
460 pub const PTR: *const sysinfo::RegisterBlock = 0x4802_0000 as *const _;
461 #[doc = r"Return the pointer to the register block"]
462 #[inline(always)]
463 pub const fn ptr() -> *const sysinfo::RegisterBlock {
464 Self::PTR
465 }
466}
467impl Deref for SYSINFO {
468 type Target = sysinfo::RegisterBlock;
469 #[inline(always)]
470 fn deref(&self) -> &Self::Target {
471 unsafe { &*Self::PTR }
472 }
473}
474impl core::fmt::Debug for SYSINFO {
475 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
476 f.debug_struct("SYSINFO").finish()
477 }
478}
479#[doc = "System Information"]
480pub mod sysinfo;
481#[doc = "System Information (Secure)"]
482pub struct SYSINFO_SECURE {
483 _marker: PhantomData<*const ()>,
484}
485unsafe impl Send for SYSINFO_SECURE {}
486impl SYSINFO_SECURE {
487 #[doc = r"Pointer to the register block"]
488 pub const PTR: *const sysinfo::RegisterBlock = 0x5802_0000 as *const _;
489 #[doc = r"Return the pointer to the register block"]
490 #[inline(always)]
491 pub const fn ptr() -> *const sysinfo::RegisterBlock {
492 Self::PTR
493 }
494}
495impl Deref for SYSINFO_SECURE {
496 type Target = sysinfo::RegisterBlock;
497 #[inline(always)]
498 fn deref(&self) -> &Self::Target {
499 unsafe { &*Self::PTR }
500 }
501}
502impl core::fmt::Debug for SYSINFO_SECURE {
503 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
504 f.debug_struct("SYSINFO_SECURE").finish()
505 }
506}
507#[doc = "System Information (Secure)"]
508pub use self::sysinfo as sysinfo_secure;
509#[doc = "System Control"]
510pub struct SYSCONTROL {
511 _marker: PhantomData<*const ()>,
512}
513unsafe impl Send for SYSCONTROL {}
514impl SYSCONTROL {
515 #[doc = r"Pointer to the register block"]
516 pub const PTR: *const syscontrol::RegisterBlock = 0x5802_1000 as *const _;
517 #[doc = r"Return the pointer to the register block"]
518 #[inline(always)]
519 pub const fn ptr() -> *const syscontrol::RegisterBlock {
520 Self::PTR
521 }
522}
523impl Deref for SYSCONTROL {
524 type Target = syscontrol::RegisterBlock;
525 #[inline(always)]
526 fn deref(&self) -> &Self::Target {
527 unsafe { &*Self::PTR }
528 }
529}
530impl core::fmt::Debug for SYSCONTROL {
531 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
532 f.debug_struct("SYSCONTROL").finish()
533 }
534}
535#[doc = "System Control"]
536pub mod syscontrol;
537#[doc = "Security Attribution Unit"]
538pub struct SAU {
539 _marker: PhantomData<*const ()>,
540}
541unsafe impl Send for SAU {}
542impl SAU {
543 #[doc = r"Pointer to the register block"]
544 pub const PTR: *const sau::RegisterBlock = 0xe000_edd0 as *const _;
545 #[doc = r"Return the pointer to the register block"]
546 #[inline(always)]
547 pub const fn ptr() -> *const sau::RegisterBlock {
548 Self::PTR
549 }
550}
551impl Deref for SAU {
552 type Target = sau::RegisterBlock;
553 #[inline(always)]
554 fn deref(&self) -> &Self::Target {
555 unsafe { &*Self::PTR }
556 }
557}
558impl core::fmt::Debug for SAU {
559 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
560 f.debug_struct("SAU").finish()
561 }
562}
563#[doc = "Security Attribution Unit"]
564pub mod sau;
565#[doc = "Timer 0"]
566pub struct TIMER0 {
567 _marker: PhantomData<*const ()>,
568}
569unsafe impl Send for TIMER0 {}
570impl TIMER0 {
571 #[doc = r"Pointer to the register block"]
572 pub const PTR: *const timer0::RegisterBlock = 0x4800_0000 as *const _;
573 #[doc = r"Return the pointer to the register block"]
574 #[inline(always)]
575 pub const fn ptr() -> *const timer0::RegisterBlock {
576 Self::PTR
577 }
578}
579impl Deref for TIMER0 {
580 type Target = timer0::RegisterBlock;
581 #[inline(always)]
582 fn deref(&self) -> &Self::Target {
583 unsafe { &*Self::PTR }
584 }
585}
586impl core::fmt::Debug for TIMER0 {
587 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
588 f.debug_struct("TIMER0").finish()
589 }
590}
591#[doc = "Timer 0"]
592pub mod timer0;
593#[doc = "Timer 1"]
594pub struct TIMER1 {
595 _marker: PhantomData<*const ()>,
596}
597unsafe impl Send for TIMER1 {}
598impl TIMER1 {
599 #[doc = r"Pointer to the register block"]
600 pub const PTR: *const timer0::RegisterBlock = 0x4800_1000 as *const _;
601 #[doc = r"Return the pointer to the register block"]
602 #[inline(always)]
603 pub const fn ptr() -> *const timer0::RegisterBlock {
604 Self::PTR
605 }
606}
607impl Deref for TIMER1 {
608 type Target = timer0::RegisterBlock;
609 #[inline(always)]
610 fn deref(&self) -> &Self::Target {
611 unsafe { &*Self::PTR }
612 }
613}
614impl core::fmt::Debug for TIMER1 {
615 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
616 f.debug_struct("TIMER1").finish()
617 }
618}
619#[doc = "Timer 1"]
620pub use self::timer0 as timer1;
621#[doc = "Timer 2"]
622pub struct TIMER2 {
623 _marker: PhantomData<*const ()>,
624}
625unsafe impl Send for TIMER2 {}
626impl TIMER2 {
627 #[doc = r"Pointer to the register block"]
628 pub const PTR: *const timer0::RegisterBlock = 0x4800_2000 as *const _;
629 #[doc = r"Return the pointer to the register block"]
630 #[inline(always)]
631 pub const fn ptr() -> *const timer0::RegisterBlock {
632 Self::PTR
633 }
634}
635impl Deref for TIMER2 {
636 type Target = timer0::RegisterBlock;
637 #[inline(always)]
638 fn deref(&self) -> &Self::Target {
639 unsafe { &*Self::PTR }
640 }
641}
642impl core::fmt::Debug for TIMER2 {
643 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
644 f.debug_struct("TIMER2").finish()
645 }
646}
647#[doc = "Timer 2"]
648pub use self::timer0 as timer2;
649#[doc = "AON Timer 3"]
650pub struct TIMER3 {
651 _marker: PhantomData<*const ()>,
652}
653unsafe impl Send for TIMER3 {}
654impl TIMER3 {
655 #[doc = r"Pointer to the register block"]
656 pub const PTR: *const timer0::RegisterBlock = 0x4800_3000 as *const _;
657 #[doc = r"Return the pointer to the register block"]
658 #[inline(always)]
659 pub const fn ptr() -> *const timer0::RegisterBlock {
660 Self::PTR
661 }
662}
663impl Deref for TIMER3 {
664 type Target = timer0::RegisterBlock;
665 #[inline(always)]
666 fn deref(&self) -> &Self::Target {
667 unsafe { &*Self::PTR }
668 }
669}
670impl core::fmt::Debug for TIMER3 {
671 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
672 f.debug_struct("TIMER3").finish()
673 }
674}
675#[doc = "AON Timer 3"]
676pub use self::timer0 as timer3;
677#[doc = "SLOWCLK AON Timer"]
678pub struct SLOWCLK {
679 _marker: PhantomData<*const ()>,
680}
681unsafe impl Send for SLOWCLK {}
682impl SLOWCLK {
683 #[doc = r"Pointer to the register block"]
684 pub const PTR: *const slowclk::RegisterBlock = 0x4802_f000 as *const _;
685 #[doc = r"Return the pointer to the register block"]
686 #[inline(always)]
687 pub const fn ptr() -> *const slowclk::RegisterBlock {
688 Self::PTR
689 }
690}
691impl Deref for SLOWCLK {
692 type Target = slowclk::RegisterBlock;
693 #[inline(always)]
694 fn deref(&self) -> &Self::Target {
695 unsafe { &*Self::PTR }
696 }
697}
698impl core::fmt::Debug for SLOWCLK {
699 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
700 f.debug_struct("SLOWCLK").finish()
701 }
702}
703#[doc = "SLOWCLK AON Timer"]
704pub mod slowclk;
705#[doc = "Timer 0 (Secure)"]
706pub struct TIMER0_SECURE {
707 _marker: PhantomData<*const ()>,
708}
709unsafe impl Send for TIMER0_SECURE {}
710impl TIMER0_SECURE {
711 #[doc = r"Pointer to the register block"]
712 pub const PTR: *const timer0::RegisterBlock = 0x5800_0000 as *const _;
713 #[doc = r"Return the pointer to the register block"]
714 #[inline(always)]
715 pub const fn ptr() -> *const timer0::RegisterBlock {
716 Self::PTR
717 }
718}
719impl Deref for TIMER0_SECURE {
720 type Target = timer0::RegisterBlock;
721 #[inline(always)]
722 fn deref(&self) -> &Self::Target {
723 unsafe { &*Self::PTR }
724 }
725}
726impl core::fmt::Debug for TIMER0_SECURE {
727 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
728 f.debug_struct("TIMER0_SECURE").finish()
729 }
730}
731#[doc = "Timer 0 (Secure)"]
732pub use self::timer0 as timer0_secure;
733#[doc = "Timer 1 (Secure)"]
734pub struct TIMER1_SECURE {
735 _marker: PhantomData<*const ()>,
736}
737unsafe impl Send for TIMER1_SECURE {}
738impl TIMER1_SECURE {
739 #[doc = r"Pointer to the register block"]
740 pub const PTR: *const timer0::RegisterBlock = 0x5800_1000 as *const _;
741 #[doc = r"Return the pointer to the register block"]
742 #[inline(always)]
743 pub const fn ptr() -> *const timer0::RegisterBlock {
744 Self::PTR
745 }
746}
747impl Deref for TIMER1_SECURE {
748 type Target = timer0::RegisterBlock;
749 #[inline(always)]
750 fn deref(&self) -> &Self::Target {
751 unsafe { &*Self::PTR }
752 }
753}
754impl core::fmt::Debug for TIMER1_SECURE {
755 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
756 f.debug_struct("TIMER1_SECURE").finish()
757 }
758}
759#[doc = "Timer 1 (Secure)"]
760pub use self::timer0 as timer1_secure;
761#[doc = "Timer 2 (Secure)"]
762pub struct TIMER2_SECURE {
763 _marker: PhantomData<*const ()>,
764}
765unsafe impl Send for TIMER2_SECURE {}
766impl TIMER2_SECURE {
767 #[doc = r"Pointer to the register block"]
768 pub const PTR: *const timer0::RegisterBlock = 0x5800_2000 as *const _;
769 #[doc = r"Return the pointer to the register block"]
770 #[inline(always)]
771 pub const fn ptr() -> *const timer0::RegisterBlock {
772 Self::PTR
773 }
774}
775impl Deref for TIMER2_SECURE {
776 type Target = timer0::RegisterBlock;
777 #[inline(always)]
778 fn deref(&self) -> &Self::Target {
779 unsafe { &*Self::PTR }
780 }
781}
782impl core::fmt::Debug for TIMER2_SECURE {
783 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
784 f.debug_struct("TIMER2_SECURE").finish()
785 }
786}
787#[doc = "Timer 2 (Secure)"]
788pub use self::timer0 as timer2_secure;
789#[doc = "Timer 3 (Secure)"]
790pub struct TIMER3_SECURE {
791 _marker: PhantomData<*const ()>,
792}
793unsafe impl Send for TIMER3_SECURE {}
794impl TIMER3_SECURE {
795 #[doc = r"Pointer to the register block"]
796 pub const PTR: *const timer0::RegisterBlock = 0x5800_3000 as *const _;
797 #[doc = r"Return the pointer to the register block"]
798 #[inline(always)]
799 pub const fn ptr() -> *const timer0::RegisterBlock {
800 Self::PTR
801 }
802}
803impl Deref for TIMER3_SECURE {
804 type Target = timer0::RegisterBlock;
805 #[inline(always)]
806 fn deref(&self) -> &Self::Target {
807 unsafe { &*Self::PTR }
808 }
809}
810impl core::fmt::Debug for TIMER3_SECURE {
811 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
812 f.debug_struct("TIMER3_SECURE").finish()
813 }
814}
815#[doc = "Timer 3 (Secure)"]
816pub use self::timer0 as timer3_secure;
817#[doc = "SLOWCLK AON Timer (Secure)"]
818pub struct SLOWCLK_SECURE {
819 _marker: PhantomData<*const ()>,
820}
821unsafe impl Send for SLOWCLK_SECURE {}
822impl SLOWCLK_SECURE {
823 #[doc = r"Pointer to the register block"]
824 pub const PTR: *const slowclk::RegisterBlock = 0x5802_f000 as *const _;
825 #[doc = r"Return the pointer to the register block"]
826 #[inline(always)]
827 pub const fn ptr() -> *const slowclk::RegisterBlock {
828 Self::PTR
829 }
830}
831impl Deref for SLOWCLK_SECURE {
832 type Target = slowclk::RegisterBlock;
833 #[inline(always)]
834 fn deref(&self) -> &Self::Target {
835 unsafe { &*Self::PTR }
836 }
837}
838impl core::fmt::Debug for SLOWCLK_SECURE {
839 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
840 f.debug_struct("SLOWCLK_SECURE").finish()
841 }
842}
843#[doc = "SLOWCLK AON Timer (Secure)"]
844pub use self::slowclk as slowclk_secure;
845#[doc = "General-purpose I/O 0"]
846pub struct GPIO0 {
847 _marker: PhantomData<*const ()>,
848}
849unsafe impl Send for GPIO0 {}
850impl GPIO0 {
851 #[doc = r"Pointer to the register block"]
852 pub const PTR: *const gpio0::RegisterBlock = 0x4110_0000 as *const _;
853 #[doc = r"Return the pointer to the register block"]
854 #[inline(always)]
855 pub const fn ptr() -> *const gpio0::RegisterBlock {
856 Self::PTR
857 }
858}
859impl Deref for GPIO0 {
860 type Target = gpio0::RegisterBlock;
861 #[inline(always)]
862 fn deref(&self) -> &Self::Target {
863 unsafe { &*Self::PTR }
864 }
865}
866impl core::fmt::Debug for GPIO0 {
867 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
868 f.debug_struct("GPIO0").finish()
869 }
870}
871#[doc = "General-purpose I/O 0"]
872pub mod gpio0;
873#[doc = "General-purpose I/O 1"]
874pub struct GPIO1 {
875 _marker: PhantomData<*const ()>,
876}
877unsafe impl Send for GPIO1 {}
878impl GPIO1 {
879 #[doc = r"Pointer to the register block"]
880 pub const PTR: *const gpio0::RegisterBlock = 0x4110_1000 as *const _;
881 #[doc = r"Return the pointer to the register block"]
882 #[inline(always)]
883 pub const fn ptr() -> *const gpio0::RegisterBlock {
884 Self::PTR
885 }
886}
887impl Deref for GPIO1 {
888 type Target = gpio0::RegisterBlock;
889 #[inline(always)]
890 fn deref(&self) -> &Self::Target {
891 unsafe { &*Self::PTR }
892 }
893}
894impl core::fmt::Debug for GPIO1 {
895 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
896 f.debug_struct("GPIO1").finish()
897 }
898}
899#[doc = "General-purpose I/O 1"]
900pub use self::gpio0 as gpio1;
901#[doc = "General-purpose I/O 2"]
902pub struct GPIO2 {
903 _marker: PhantomData<*const ()>,
904}
905unsafe impl Send for GPIO2 {}
906impl GPIO2 {
907 #[doc = r"Pointer to the register block"]
908 pub const PTR: *const gpio0::RegisterBlock = 0x4110_2000 as *const _;
909 #[doc = r"Return the pointer to the register block"]
910 #[inline(always)]
911 pub const fn ptr() -> *const gpio0::RegisterBlock {
912 Self::PTR
913 }
914}
915impl Deref for GPIO2 {
916 type Target = gpio0::RegisterBlock;
917 #[inline(always)]
918 fn deref(&self) -> &Self::Target {
919 unsafe { &*Self::PTR }
920 }
921}
922impl core::fmt::Debug for GPIO2 {
923 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
924 f.debug_struct("GPIO2").finish()
925 }
926}
927#[doc = "General-purpose I/O 2"]
928pub use self::gpio0 as gpio2;
929#[doc = "General-purpose I/O 3"]
930pub struct GPIO3 {
931 _marker: PhantomData<*const ()>,
932}
933unsafe impl Send for GPIO3 {}
934impl GPIO3 {
935 #[doc = r"Pointer to the register block"]
936 pub const PTR: *const gpio0::RegisterBlock = 0x4110_3000 as *const _;
937 #[doc = r"Return the pointer to the register block"]
938 #[inline(always)]
939 pub const fn ptr() -> *const gpio0::RegisterBlock {
940 Self::PTR
941 }
942}
943impl Deref for GPIO3 {
944 type Target = gpio0::RegisterBlock;
945 #[inline(always)]
946 fn deref(&self) -> &Self::Target {
947 unsafe { &*Self::PTR }
948 }
949}
950impl core::fmt::Debug for GPIO3 {
951 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
952 f.debug_struct("GPIO3").finish()
953 }
954}
955#[doc = "General-purpose I/O 3"]
956pub use self::gpio0 as gpio3;
957#[doc = "General-purpose I/O 0 (Secure)"]
958pub struct GPIO0_SECURE {
959 _marker: PhantomData<*const ()>,
960}
961unsafe impl Send for GPIO0_SECURE {}
962impl GPIO0_SECURE {
963 #[doc = r"Pointer to the register block"]
964 pub const PTR: *const gpio0::RegisterBlock = 0x5010_0000 as *const _;
965 #[doc = r"Return the pointer to the register block"]
966 #[inline(always)]
967 pub const fn ptr() -> *const gpio0::RegisterBlock {
968 Self::PTR
969 }
970}
971impl Deref for GPIO0_SECURE {
972 type Target = gpio0::RegisterBlock;
973 #[inline(always)]
974 fn deref(&self) -> &Self::Target {
975 unsafe { &*Self::PTR }
976 }
977}
978impl core::fmt::Debug for GPIO0_SECURE {
979 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
980 f.debug_struct("GPIO0_SECURE").finish()
981 }
982}
983#[doc = "General-purpose I/O 0 (Secure)"]
984pub use self::gpio0 as gpio0_secure;
985#[doc = "General-purpose I/O 1 (Secure)"]
986pub struct GPIO1_SECURE {
987 _marker: PhantomData<*const ()>,
988}
989unsafe impl Send for GPIO1_SECURE {}
990impl GPIO1_SECURE {
991 #[doc = r"Pointer to the register block"]
992 pub const PTR: *const gpio0::RegisterBlock = 0x5010_1000 as *const _;
993 #[doc = r"Return the pointer to the register block"]
994 #[inline(always)]
995 pub const fn ptr() -> *const gpio0::RegisterBlock {
996 Self::PTR
997 }
998}
999impl Deref for GPIO1_SECURE {
1000 type Target = gpio0::RegisterBlock;
1001 #[inline(always)]
1002 fn deref(&self) -> &Self::Target {
1003 unsafe { &*Self::PTR }
1004 }
1005}
1006impl core::fmt::Debug for GPIO1_SECURE {
1007 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1008 f.debug_struct("GPIO1_SECURE").finish()
1009 }
1010}
1011#[doc = "General-purpose I/O 1 (Secure)"]
1012pub use self::gpio0 as gpio1_secure;
1013#[doc = "General-purpose I/O 2 (Secure)"]
1014pub struct GPIO2_SECURE {
1015 _marker: PhantomData<*const ()>,
1016}
1017unsafe impl Send for GPIO2_SECURE {}
1018impl GPIO2_SECURE {
1019 #[doc = r"Pointer to the register block"]
1020 pub const PTR: *const gpio0::RegisterBlock = 0x5010_2000 as *const _;
1021 #[doc = r"Return the pointer to the register block"]
1022 #[inline(always)]
1023 pub const fn ptr() -> *const gpio0::RegisterBlock {
1024 Self::PTR
1025 }
1026}
1027impl Deref for GPIO2_SECURE {
1028 type Target = gpio0::RegisterBlock;
1029 #[inline(always)]
1030 fn deref(&self) -> &Self::Target {
1031 unsafe { &*Self::PTR }
1032 }
1033}
1034impl core::fmt::Debug for GPIO2_SECURE {
1035 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1036 f.debug_struct("GPIO2_SECURE").finish()
1037 }
1038}
1039#[doc = "General-purpose I/O 2 (Secure)"]
1040pub use self::gpio0 as gpio2_secure;
1041#[doc = "General-purpose I/O 3 (Secure)"]
1042pub struct GPIO3_SECURE {
1043 _marker: PhantomData<*const ()>,
1044}
1045unsafe impl Send for GPIO3_SECURE {}
1046impl GPIO3_SECURE {
1047 #[doc = r"Pointer to the register block"]
1048 pub const PTR: *const gpio0::RegisterBlock = 0x5010_3000 as *const _;
1049 #[doc = r"Return the pointer to the register block"]
1050 #[inline(always)]
1051 pub const fn ptr() -> *const gpio0::RegisterBlock {
1052 Self::PTR
1053 }
1054}
1055impl Deref for GPIO3_SECURE {
1056 type Target = gpio0::RegisterBlock;
1057 #[inline(always)]
1058 fn deref(&self) -> &Self::Target {
1059 unsafe { &*Self::PTR }
1060 }
1061}
1062impl core::fmt::Debug for GPIO3_SECURE {
1063 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1064 f.debug_struct("GPIO3_SECURE").finish()
1065 }
1066}
1067#[doc = "General-purpose I/O 3 (Secure)"]
1068pub use self::gpio0 as gpio3_secure;
1069#[doc = "Direct Memory Access 0 (PL081)"]
1070pub struct DMA0 {
1071 _marker: PhantomData<*const ()>,
1072}
1073unsafe impl Send for DMA0 {}
1074impl DMA0 {
1075 #[doc = r"Pointer to the register block"]
1076 pub const PTR: *const dma0::RegisterBlock = 0x4120_0000 as *const _;
1077 #[doc = r"Return the pointer to the register block"]
1078 #[inline(always)]
1079 pub const fn ptr() -> *const dma0::RegisterBlock {
1080 Self::PTR
1081 }
1082}
1083impl Deref for DMA0 {
1084 type Target = dma0::RegisterBlock;
1085 #[inline(always)]
1086 fn deref(&self) -> &Self::Target {
1087 unsafe { &*Self::PTR }
1088 }
1089}
1090impl core::fmt::Debug for DMA0 {
1091 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1092 f.debug_struct("DMA0").finish()
1093 }
1094}
1095#[doc = "Direct Memory Access 0 (PL081)"]
1096pub mod dma0;
1097#[doc = "Direct Memory Access 1"]
1098pub struct DMA1 {
1099 _marker: PhantomData<*const ()>,
1100}
1101unsafe impl Send for DMA1 {}
1102impl DMA1 {
1103 #[doc = r"Pointer to the register block"]
1104 pub const PTR: *const dma0::RegisterBlock = 0x4110_1000 as *const _;
1105 #[doc = r"Return the pointer to the register block"]
1106 #[inline(always)]
1107 pub const fn ptr() -> *const dma0::RegisterBlock {
1108 Self::PTR
1109 }
1110}
1111impl Deref for DMA1 {
1112 type Target = dma0::RegisterBlock;
1113 #[inline(always)]
1114 fn deref(&self) -> &Self::Target {
1115 unsafe { &*Self::PTR }
1116 }
1117}
1118impl core::fmt::Debug for DMA1 {
1119 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1120 f.debug_struct("DMA1").finish()
1121 }
1122}
1123#[doc = "Direct Memory Access 1"]
1124pub use self::dma0 as dma1;
1125#[doc = "Direct Memory Access 2"]
1126pub struct DMA2 {
1127 _marker: PhantomData<*const ()>,
1128}
1129unsafe impl Send for DMA2 {}
1130impl DMA2 {
1131 #[doc = r"Pointer to the register block"]
1132 pub const PTR: *const dma0::RegisterBlock = 0x4120_2000 as *const _;
1133 #[doc = r"Return the pointer to the register block"]
1134 #[inline(always)]
1135 pub const fn ptr() -> *const dma0::RegisterBlock {
1136 Self::PTR
1137 }
1138}
1139impl Deref for DMA2 {
1140 type Target = dma0::RegisterBlock;
1141 #[inline(always)]
1142 fn deref(&self) -> &Self::Target {
1143 unsafe { &*Self::PTR }
1144 }
1145}
1146impl core::fmt::Debug for DMA2 {
1147 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1148 f.debug_struct("DMA2").finish()
1149 }
1150}
1151#[doc = "Direct Memory Access 2"]
1152pub use self::dma0 as dma2;
1153#[doc = "Direct Memory Access 3"]
1154pub struct DMA3 {
1155 _marker: PhantomData<*const ()>,
1156}
1157unsafe impl Send for DMA3 {}
1158impl DMA3 {
1159 #[doc = r"Pointer to the register block"]
1160 pub const PTR: *const dma0::RegisterBlock = 0x4120_3000 as *const _;
1161 #[doc = r"Return the pointer to the register block"]
1162 #[inline(always)]
1163 pub const fn ptr() -> *const dma0::RegisterBlock {
1164 Self::PTR
1165 }
1166}
1167impl Deref for DMA3 {
1168 type Target = dma0::RegisterBlock;
1169 #[inline(always)]
1170 fn deref(&self) -> &Self::Target {
1171 unsafe { &*Self::PTR }
1172 }
1173}
1174impl core::fmt::Debug for DMA3 {
1175 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1176 f.debug_struct("DMA3").finish()
1177 }
1178}
1179#[doc = "Direct Memory Access 3"]
1180pub use self::dma0 as dma3;
1181#[doc = "Direct Memory Access 0 (Secure)"]
1182pub struct DMA0_SECURE {
1183 _marker: PhantomData<*const ()>,
1184}
1185unsafe impl Send for DMA0_SECURE {}
1186impl DMA0_SECURE {
1187 #[doc = r"Pointer to the register block"]
1188 pub const PTR: *const dma0::RegisterBlock = 0x5120_0000 as *const _;
1189 #[doc = r"Return the pointer to the register block"]
1190 #[inline(always)]
1191 pub const fn ptr() -> *const dma0::RegisterBlock {
1192 Self::PTR
1193 }
1194}
1195impl Deref for DMA0_SECURE {
1196 type Target = dma0::RegisterBlock;
1197 #[inline(always)]
1198 fn deref(&self) -> &Self::Target {
1199 unsafe { &*Self::PTR }
1200 }
1201}
1202impl core::fmt::Debug for DMA0_SECURE {
1203 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1204 f.debug_struct("DMA0_SECURE").finish()
1205 }
1206}
1207#[doc = "Direct Memory Access 0 (Secure)"]
1208pub use self::dma0 as dma0_secure;
1209#[doc = "Direct Memory Access 1 (Secure)"]
1210pub struct DMA1_SECURE {
1211 _marker: PhantomData<*const ()>,
1212}
1213unsafe impl Send for DMA1_SECURE {}
1214impl DMA1_SECURE {
1215 #[doc = r"Pointer to the register block"]
1216 pub const PTR: *const dma0::RegisterBlock = 0x5120_1000 as *const _;
1217 #[doc = r"Return the pointer to the register block"]
1218 #[inline(always)]
1219 pub const fn ptr() -> *const dma0::RegisterBlock {
1220 Self::PTR
1221 }
1222}
1223impl Deref for DMA1_SECURE {
1224 type Target = dma0::RegisterBlock;
1225 #[inline(always)]
1226 fn deref(&self) -> &Self::Target {
1227 unsafe { &*Self::PTR }
1228 }
1229}
1230impl core::fmt::Debug for DMA1_SECURE {
1231 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1232 f.debug_struct("DMA1_SECURE").finish()
1233 }
1234}
1235#[doc = "Direct Memory Access 1 (Secure)"]
1236pub use self::dma0 as dma1_secure;
1237#[doc = "Direct Memory Access 2 (Secure)"]
1238pub struct DMA2_SECURE {
1239 _marker: PhantomData<*const ()>,
1240}
1241unsafe impl Send for DMA2_SECURE {}
1242impl DMA2_SECURE {
1243 #[doc = r"Pointer to the register block"]
1244 pub const PTR: *const dma0::RegisterBlock = 0x5120_2000 as *const _;
1245 #[doc = r"Return the pointer to the register block"]
1246 #[inline(always)]
1247 pub const fn ptr() -> *const dma0::RegisterBlock {
1248 Self::PTR
1249 }
1250}
1251impl Deref for DMA2_SECURE {
1252 type Target = dma0::RegisterBlock;
1253 #[inline(always)]
1254 fn deref(&self) -> &Self::Target {
1255 unsafe { &*Self::PTR }
1256 }
1257}
1258impl core::fmt::Debug for DMA2_SECURE {
1259 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1260 f.debug_struct("DMA2_SECURE").finish()
1261 }
1262}
1263#[doc = "Direct Memory Access 2 (Secure)"]
1264pub use self::dma0 as dma2_secure;
1265#[doc = "Direct Memory Access 3 (Secure)"]
1266pub struct DMA3_SECURE {
1267 _marker: PhantomData<*const ()>,
1268}
1269unsafe impl Send for DMA3_SECURE {}
1270impl DMA3_SECURE {
1271 #[doc = r"Pointer to the register block"]
1272 pub const PTR: *const dma0::RegisterBlock = 0x5120_3000 as *const _;
1273 #[doc = r"Return the pointer to the register block"]
1274 #[inline(always)]
1275 pub const fn ptr() -> *const dma0::RegisterBlock {
1276 Self::PTR
1277 }
1278}
1279impl Deref for DMA3_SECURE {
1280 type Target = dma0::RegisterBlock;
1281 #[inline(always)]
1282 fn deref(&self) -> &Self::Target {
1283 unsafe { &*Self::PTR }
1284 }
1285}
1286impl core::fmt::Debug for DMA3_SECURE {
1287 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1288 f.debug_struct("DMA3_SECURE").finish()
1289 }
1290}
1291#[doc = "Direct Memory Access 3 (Secure)"]
1292pub use self::dma0 as dma3_secure;
1293#[doc = "UART 0"]
1294pub struct UART0 {
1295 _marker: PhantomData<*const ()>,
1296}
1297unsafe impl Send for UART0 {}
1298impl UART0 {
1299 #[doc = r"Pointer to the register block"]
1300 pub const PTR: *const uart0::RegisterBlock = 0x4930_3000 as *const _;
1301 #[doc = r"Return the pointer to the register block"]
1302 #[inline(always)]
1303 pub const fn ptr() -> *const uart0::RegisterBlock {
1304 Self::PTR
1305 }
1306}
1307impl Deref for UART0 {
1308 type Target = uart0::RegisterBlock;
1309 #[inline(always)]
1310 fn deref(&self) -> &Self::Target {
1311 unsafe { &*Self::PTR }
1312 }
1313}
1314impl core::fmt::Debug for UART0 {
1315 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1316 f.debug_struct("UART0").finish()
1317 }
1318}
1319#[doc = "UART 0"]
1320pub mod uart0;
1321#[doc = "UART 1"]
1322pub struct UART1 {
1323 _marker: PhantomData<*const ()>,
1324}
1325unsafe impl Send for UART1 {}
1326impl UART1 {
1327 #[doc = r"Pointer to the register block"]
1328 pub const PTR: *const uart0::RegisterBlock = 0x4930_4000 as *const _;
1329 #[doc = r"Return the pointer to the register block"]
1330 #[inline(always)]
1331 pub const fn ptr() -> *const uart0::RegisterBlock {
1332 Self::PTR
1333 }
1334}
1335impl Deref for UART1 {
1336 type Target = uart0::RegisterBlock;
1337 #[inline(always)]
1338 fn deref(&self) -> &Self::Target {
1339 unsafe { &*Self::PTR }
1340 }
1341}
1342impl core::fmt::Debug for UART1 {
1343 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1344 f.debug_struct("UART1").finish()
1345 }
1346}
1347#[doc = "UART 1"]
1348pub use self::uart0 as uart1;
1349#[doc = "UART 2"]
1350pub struct UART2 {
1351 _marker: PhantomData<*const ()>,
1352}
1353unsafe impl Send for UART2 {}
1354impl UART2 {
1355 #[doc = r"Pointer to the register block"]
1356 pub const PTR: *const uart0::RegisterBlock = 0x4930_5000 as *const _;
1357 #[doc = r"Return the pointer to the register block"]
1358 #[inline(always)]
1359 pub const fn ptr() -> *const uart0::RegisterBlock {
1360 Self::PTR
1361 }
1362}
1363impl Deref for UART2 {
1364 type Target = uart0::RegisterBlock;
1365 #[inline(always)]
1366 fn deref(&self) -> &Self::Target {
1367 unsafe { &*Self::PTR }
1368 }
1369}
1370impl core::fmt::Debug for UART2 {
1371 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1372 f.debug_struct("UART2").finish()
1373 }
1374}
1375#[doc = "UART 2"]
1376pub use self::uart0 as uart2;
1377#[doc = "UART 3"]
1378pub struct UART3 {
1379 _marker: PhantomData<*const ()>,
1380}
1381unsafe impl Send for UART3 {}
1382impl UART3 {
1383 #[doc = r"Pointer to the register block"]
1384 pub const PTR: *const uart0::RegisterBlock = 0x4930_6000 as *const _;
1385 #[doc = r"Return the pointer to the register block"]
1386 #[inline(always)]
1387 pub const fn ptr() -> *const uart0::RegisterBlock {
1388 Self::PTR
1389 }
1390}
1391impl Deref for UART3 {
1392 type Target = uart0::RegisterBlock;
1393 #[inline(always)]
1394 fn deref(&self) -> &Self::Target {
1395 unsafe { &*Self::PTR }
1396 }
1397}
1398impl core::fmt::Debug for UART3 {
1399 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1400 f.debug_struct("UART3").finish()
1401 }
1402}
1403#[doc = "UART 3"]
1404pub use self::uart0 as uart3;
1405#[doc = "UART 4"]
1406pub struct UART4 {
1407 _marker: PhantomData<*const ()>,
1408}
1409unsafe impl Send for UART4 {}
1410impl UART4 {
1411 #[doc = r"Pointer to the register block"]
1412 pub const PTR: *const uart0::RegisterBlock = 0x4930_7000 as *const _;
1413 #[doc = r"Return the pointer to the register block"]
1414 #[inline(always)]
1415 pub const fn ptr() -> *const uart0::RegisterBlock {
1416 Self::PTR
1417 }
1418}
1419impl Deref for UART4 {
1420 type Target = uart0::RegisterBlock;
1421 #[inline(always)]
1422 fn deref(&self) -> &Self::Target {
1423 unsafe { &*Self::PTR }
1424 }
1425}
1426impl core::fmt::Debug for UART4 {
1427 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1428 f.debug_struct("UART4").finish()
1429 }
1430}
1431#[doc = "UART 4"]
1432pub use self::uart0 as uart4;
1433#[doc = "UART 5"]
1434pub struct UART5 {
1435 _marker: PhantomData<*const ()>,
1436}
1437unsafe impl Send for UART5 {}
1438impl UART5 {
1439 #[doc = r"Pointer to the register block"]
1440 pub const PTR: *const uart0::RegisterBlock = 0x4930_8000 as *const _;
1441 #[doc = r"Return the pointer to the register block"]
1442 #[inline(always)]
1443 pub const fn ptr() -> *const uart0::RegisterBlock {
1444 Self::PTR
1445 }
1446}
1447impl Deref for UART5 {
1448 type Target = uart0::RegisterBlock;
1449 #[inline(always)]
1450 fn deref(&self) -> &Self::Target {
1451 unsafe { &*Self::PTR }
1452 }
1453}
1454impl core::fmt::Debug for UART5 {
1455 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1456 f.debug_struct("UART5").finish()
1457 }
1458}
1459#[doc = "UART 5"]
1460pub use self::uart0 as uart5;
1461#[doc = "UART 0 (Secure)"]
1462pub struct UART0_SECURE {
1463 _marker: PhantomData<*const ()>,
1464}
1465unsafe impl Send for UART0_SECURE {}
1466impl UART0_SECURE {
1467 #[doc = r"Pointer to the register block"]
1468 pub const PTR: *const uart0::RegisterBlock = 0x5930_3000 as *const _;
1469 #[doc = r"Return the pointer to the register block"]
1470 #[inline(always)]
1471 pub const fn ptr() -> *const uart0::RegisterBlock {
1472 Self::PTR
1473 }
1474}
1475impl Deref for UART0_SECURE {
1476 type Target = uart0::RegisterBlock;
1477 #[inline(always)]
1478 fn deref(&self) -> &Self::Target {
1479 unsafe { &*Self::PTR }
1480 }
1481}
1482impl core::fmt::Debug for UART0_SECURE {
1483 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1484 f.debug_struct("UART0_SECURE").finish()
1485 }
1486}
1487#[doc = "UART 0 (Secure)"]
1488pub use self::uart0 as uart0_secure;
1489#[doc = "UART 1 (Secure)"]
1490pub struct UART1_SECURE {
1491 _marker: PhantomData<*const ()>,
1492}
1493unsafe impl Send for UART1_SECURE {}
1494impl UART1_SECURE {
1495 #[doc = r"Pointer to the register block"]
1496 pub const PTR: *const uart0::RegisterBlock = 0x5930_4000 as *const _;
1497 #[doc = r"Return the pointer to the register block"]
1498 #[inline(always)]
1499 pub const fn ptr() -> *const uart0::RegisterBlock {
1500 Self::PTR
1501 }
1502}
1503impl Deref for UART1_SECURE {
1504 type Target = uart0::RegisterBlock;
1505 #[inline(always)]
1506 fn deref(&self) -> &Self::Target {
1507 unsafe { &*Self::PTR }
1508 }
1509}
1510impl core::fmt::Debug for UART1_SECURE {
1511 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1512 f.debug_struct("UART1_SECURE").finish()
1513 }
1514}
1515#[doc = "UART 1 (Secure)"]
1516pub use self::uart0 as uart1_secure;
1517#[doc = "UART 2 (Secure)"]
1518pub struct UART2_SECURE {
1519 _marker: PhantomData<*const ()>,
1520}
1521unsafe impl Send for UART2_SECURE {}
1522impl UART2_SECURE {
1523 #[doc = r"Pointer to the register block"]
1524 pub const PTR: *const uart0::RegisterBlock = 0x5930_5000 as *const _;
1525 #[doc = r"Return the pointer to the register block"]
1526 #[inline(always)]
1527 pub const fn ptr() -> *const uart0::RegisterBlock {
1528 Self::PTR
1529 }
1530}
1531impl Deref for UART2_SECURE {
1532 type Target = uart0::RegisterBlock;
1533 #[inline(always)]
1534 fn deref(&self) -> &Self::Target {
1535 unsafe { &*Self::PTR }
1536 }
1537}
1538impl core::fmt::Debug for UART2_SECURE {
1539 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1540 f.debug_struct("UART2_SECURE").finish()
1541 }
1542}
1543#[doc = "UART 2 (Secure)"]
1544pub use self::uart0 as uart2_secure;
1545#[doc = "UART 3 (Secure)"]
1546pub struct UART3_SECURE {
1547 _marker: PhantomData<*const ()>,
1548}
1549unsafe impl Send for UART3_SECURE {}
1550impl UART3_SECURE {
1551 #[doc = r"Pointer to the register block"]
1552 pub const PTR: *const uart0::RegisterBlock = 0x5930_6000 as *const _;
1553 #[doc = r"Return the pointer to the register block"]
1554 #[inline(always)]
1555 pub const fn ptr() -> *const uart0::RegisterBlock {
1556 Self::PTR
1557 }
1558}
1559impl Deref for UART3_SECURE {
1560 type Target = uart0::RegisterBlock;
1561 #[inline(always)]
1562 fn deref(&self) -> &Self::Target {
1563 unsafe { &*Self::PTR }
1564 }
1565}
1566impl core::fmt::Debug for UART3_SECURE {
1567 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1568 f.debug_struct("UART3_SECURE").finish()
1569 }
1570}
1571#[doc = "UART 3 (Secure)"]
1572pub use self::uart0 as uart3_secure;
1573#[doc = "UART 4 (Secure)"]
1574pub struct UART4_SECURE {
1575 _marker: PhantomData<*const ()>,
1576}
1577unsafe impl Send for UART4_SECURE {}
1578impl UART4_SECURE {
1579 #[doc = r"Pointer to the register block"]
1580 pub const PTR: *const uart0::RegisterBlock = 0x5930_7000 as *const _;
1581 #[doc = r"Return the pointer to the register block"]
1582 #[inline(always)]
1583 pub const fn ptr() -> *const uart0::RegisterBlock {
1584 Self::PTR
1585 }
1586}
1587impl Deref for UART4_SECURE {
1588 type Target = uart0::RegisterBlock;
1589 #[inline(always)]
1590 fn deref(&self) -> &Self::Target {
1591 unsafe { &*Self::PTR }
1592 }
1593}
1594impl core::fmt::Debug for UART4_SECURE {
1595 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1596 f.debug_struct("UART4_SECURE").finish()
1597 }
1598}
1599#[doc = "UART 4 (Secure)"]
1600pub use self::uart0 as uart4_secure;
1601#[doc = "UART 5 (Secure)"]
1602pub struct UART5_SECURE {
1603 _marker: PhantomData<*const ()>,
1604}
1605unsafe impl Send for UART5_SECURE {}
1606impl UART5_SECURE {
1607 #[doc = r"Pointer to the register block"]
1608 pub const PTR: *const uart0::RegisterBlock = 0x5930_8000 as *const _;
1609 #[doc = r"Return the pointer to the register block"]
1610 #[inline(always)]
1611 pub const fn ptr() -> *const uart0::RegisterBlock {
1612 Self::PTR
1613 }
1614}
1615impl Deref for UART5_SECURE {
1616 type Target = uart0::RegisterBlock;
1617 #[inline(always)]
1618 fn deref(&self) -> &Self::Target {
1619 unsafe { &*Self::PTR }
1620 }
1621}
1622impl core::fmt::Debug for UART5_SECURE {
1623 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1624 f.debug_struct("UART5_SECURE").finish()
1625 }
1626}
1627#[doc = "UART 5 (Secure)"]
1628pub use self::uart0 as uart5_secure;
1629#[doc = "I2C Touch"]
1630pub struct I2C0 {
1631 _marker: PhantomData<*const ()>,
1632}
1633unsafe impl Send for I2C0 {}
1634impl I2C0 {
1635 #[doc = r"Pointer to the register block"]
1636 pub const PTR: *const i2c0::RegisterBlock = 0x4920_0000 as *const _;
1637 #[doc = r"Return the pointer to the register block"]
1638 #[inline(always)]
1639 pub const fn ptr() -> *const i2c0::RegisterBlock {
1640 Self::PTR
1641 }
1642}
1643impl Deref for I2C0 {
1644 type Target = i2c0::RegisterBlock;
1645 #[inline(always)]
1646 fn deref(&self) -> &Self::Target {
1647 unsafe { &*Self::PTR }
1648 }
1649}
1650impl core::fmt::Debug for I2C0 {
1651 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1652 f.debug_struct("I2C0").finish()
1653 }
1654}
1655#[doc = "I2C Touch"]
1656pub mod i2c0;
1657#[doc = "I2C Audio"]
1658pub struct I2C1 {
1659 _marker: PhantomData<*const ()>,
1660}
1661unsafe impl Send for I2C1 {}
1662impl I2C1 {
1663 #[doc = r"Pointer to the register block"]
1664 pub const PTR: *const i2c0::RegisterBlock = 0x4920_1000 as *const _;
1665 #[doc = r"Return the pointer to the register block"]
1666 #[inline(always)]
1667 pub const fn ptr() -> *const i2c0::RegisterBlock {
1668 Self::PTR
1669 }
1670}
1671impl Deref for I2C1 {
1672 type Target = i2c0::RegisterBlock;
1673 #[inline(always)]
1674 fn deref(&self) -> &Self::Target {
1675 unsafe { &*Self::PTR }
1676 }
1677}
1678impl core::fmt::Debug for I2C1 {
1679 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1680 f.debug_struct("I2C1").finish()
1681 }
1682}
1683#[doc = "I2C Audio"]
1684pub use self::i2c0 as i2c1;
1685#[doc = "I2C Touch (Secure)"]
1686pub struct I2C0_SECURE {
1687 _marker: PhantomData<*const ()>,
1688}
1689unsafe impl Send for I2C0_SECURE {}
1690impl I2C0_SECURE {
1691 #[doc = r"Pointer to the register block"]
1692 pub const PTR: *const i2c0::RegisterBlock = 0x5920_0000 as *const _;
1693 #[doc = r"Return the pointer to the register block"]
1694 #[inline(always)]
1695 pub const fn ptr() -> *const i2c0::RegisterBlock {
1696 Self::PTR
1697 }
1698}
1699impl Deref for I2C0_SECURE {
1700 type Target = i2c0::RegisterBlock;
1701 #[inline(always)]
1702 fn deref(&self) -> &Self::Target {
1703 unsafe { &*Self::PTR }
1704 }
1705}
1706impl core::fmt::Debug for I2C0_SECURE {
1707 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1708 f.debug_struct("I2C0_SECURE").finish()
1709 }
1710}
1711#[doc = "I2C Touch (Secure)"]
1712pub use self::i2c0 as i2c0_secure;
1713#[doc = "I2C Audio (Secure)"]
1714pub struct I2C1_SECURE {
1715 _marker: PhantomData<*const ()>,
1716}
1717unsafe impl Send for I2C1_SECURE {}
1718impl I2C1_SECURE {
1719 #[doc = r"Pointer to the register block"]
1720 pub const PTR: *const i2c0::RegisterBlock = 0x5920_1000 as *const _;
1721 #[doc = r"Return the pointer to the register block"]
1722 #[inline(always)]
1723 pub const fn ptr() -> *const i2c0::RegisterBlock {
1724 Self::PTR
1725 }
1726}
1727impl Deref for I2C1_SECURE {
1728 type Target = i2c0::RegisterBlock;
1729 #[inline(always)]
1730 fn deref(&self) -> &Self::Target {
1731 unsafe { &*Self::PTR }
1732 }
1733}
1734impl core::fmt::Debug for I2C1_SECURE {
1735 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1736 f.debug_struct("I2C1_SECURE").finish()
1737 }
1738}
1739#[doc = "I2C Audio (Secure)"]
1740pub use self::i2c0 as i2c1_secure;
1741#[doc = "SPI 0"]
1742pub struct SSP0 {
1743 _marker: PhantomData<*const ()>,
1744}
1745unsafe impl Send for SSP0 {}
1746impl SSP0 {
1747 #[doc = r"Pointer to the register block"]
1748 pub const PTR: *const ssp0::RegisterBlock = 0x4920_3000 as *const _;
1749 #[doc = r"Return the pointer to the register block"]
1750 #[inline(always)]
1751 pub const fn ptr() -> *const ssp0::RegisterBlock {
1752 Self::PTR
1753 }
1754}
1755impl Deref for SSP0 {
1756 type Target = ssp0::RegisterBlock;
1757 #[inline(always)]
1758 fn deref(&self) -> &Self::Target {
1759 unsafe { &*Self::PTR }
1760 }
1761}
1762impl core::fmt::Debug for SSP0 {
1763 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1764 f.debug_struct("SSP0").finish()
1765 }
1766}
1767#[doc = "SPI 0"]
1768pub mod ssp0;
1769#[doc = "SPI 1"]
1770pub struct SSP1 {
1771 _marker: PhantomData<*const ()>,
1772}
1773unsafe impl Send for SSP1 {}
1774impl SSP1 {
1775 #[doc = r"Pointer to the register block"]
1776 pub const PTR: *const ssp0::RegisterBlock = 0x4920_4000 as *const _;
1777 #[doc = r"Return the pointer to the register block"]
1778 #[inline(always)]
1779 pub const fn ptr() -> *const ssp0::RegisterBlock {
1780 Self::PTR
1781 }
1782}
1783impl Deref for SSP1 {
1784 type Target = ssp0::RegisterBlock;
1785 #[inline(always)]
1786 fn deref(&self) -> &Self::Target {
1787 unsafe { &*Self::PTR }
1788 }
1789}
1790impl core::fmt::Debug for SSP1 {
1791 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1792 f.debug_struct("SSP1").finish()
1793 }
1794}
1795#[doc = "SPI 1"]
1796pub use self::ssp0 as ssp1;
1797#[doc = "SPI 2"]
1798pub struct SSP2 {
1799 _marker: PhantomData<*const ()>,
1800}
1801unsafe impl Send for SSP2 {}
1802impl SSP2 {
1803 #[doc = r"Pointer to the register block"]
1804 pub const PTR: *const ssp0::RegisterBlock = 0x4920_2000 as *const _;
1805 #[doc = r"Return the pointer to the register block"]
1806 #[inline(always)]
1807 pub const fn ptr() -> *const ssp0::RegisterBlock {
1808 Self::PTR
1809 }
1810}
1811impl Deref for SSP2 {
1812 type Target = ssp0::RegisterBlock;
1813 #[inline(always)]
1814 fn deref(&self) -> &Self::Target {
1815 unsafe { &*Self::PTR }
1816 }
1817}
1818impl core::fmt::Debug for SSP2 {
1819 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1820 f.debug_struct("SSP2").finish()
1821 }
1822}
1823#[doc = "SPI 2"]
1824pub use self::ssp0 as ssp2;
1825#[doc = "SPI 0 (Secure)"]
1826pub struct SSP0_SECURE {
1827 _marker: PhantomData<*const ()>,
1828}
1829unsafe impl Send for SSP0_SECURE {}
1830impl SSP0_SECURE {
1831 #[doc = r"Pointer to the register block"]
1832 pub const PTR: *const ssp0::RegisterBlock = 0x5920_3000 as *const _;
1833 #[doc = r"Return the pointer to the register block"]
1834 #[inline(always)]
1835 pub const fn ptr() -> *const ssp0::RegisterBlock {
1836 Self::PTR
1837 }
1838}
1839impl Deref for SSP0_SECURE {
1840 type Target = ssp0::RegisterBlock;
1841 #[inline(always)]
1842 fn deref(&self) -> &Self::Target {
1843 unsafe { &*Self::PTR }
1844 }
1845}
1846impl core::fmt::Debug for SSP0_SECURE {
1847 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1848 f.debug_struct("SSP0_SECURE").finish()
1849 }
1850}
1851#[doc = "SPI 0 (Secure)"]
1852pub use self::ssp0 as ssp0_secure;
1853#[doc = "SPI 1 (Secure)"]
1854pub struct SSP1_SECURE {
1855 _marker: PhantomData<*const ()>,
1856}
1857unsafe impl Send for SSP1_SECURE {}
1858impl SSP1_SECURE {
1859 #[doc = r"Pointer to the register block"]
1860 pub const PTR: *const ssp0::RegisterBlock = 0x5920_4000 as *const _;
1861 #[doc = r"Return the pointer to the register block"]
1862 #[inline(always)]
1863 pub const fn ptr() -> *const ssp0::RegisterBlock {
1864 Self::PTR
1865 }
1866}
1867impl Deref for SSP1_SECURE {
1868 type Target = ssp0::RegisterBlock;
1869 #[inline(always)]
1870 fn deref(&self) -> &Self::Target {
1871 unsafe { &*Self::PTR }
1872 }
1873}
1874impl core::fmt::Debug for SSP1_SECURE {
1875 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1876 f.debug_struct("SSP1_SECURE").finish()
1877 }
1878}
1879#[doc = "SPI 1 (Secure)"]
1880pub use self::ssp0 as ssp1_secure;
1881#[doc = "SPI 2 (Secure)"]
1882pub struct SSP2_SECURE {
1883 _marker: PhantomData<*const ()>,
1884}
1885unsafe impl Send for SSP2_SECURE {}
1886impl SSP2_SECURE {
1887 #[doc = r"Pointer to the register block"]
1888 pub const PTR: *const ssp0::RegisterBlock = 0x5920_2000 as *const _;
1889 #[doc = r"Return the pointer to the register block"]
1890 #[inline(always)]
1891 pub const fn ptr() -> *const ssp0::RegisterBlock {
1892 Self::PTR
1893 }
1894}
1895impl Deref for SSP2_SECURE {
1896 type Target = ssp0::RegisterBlock;
1897 #[inline(always)]
1898 fn deref(&self) -> &Self::Target {
1899 unsafe { &*Self::PTR }
1900 }
1901}
1902impl core::fmt::Debug for SSP2_SECURE {
1903 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1904 f.debug_struct("SSP2_SECURE").finish()
1905 }
1906}
1907#[doc = "SPI 2 (Secure)"]
1908pub use self::ssp0 as ssp2_secure;
1909#[doc = "Non-secure Watchdog Timer"]
1910pub struct WATCHDOG {
1911 _marker: PhantomData<*const ()>,
1912}
1913unsafe impl Send for WATCHDOG {}
1914impl WATCHDOG {
1915 #[doc = r"Pointer to the register block"]
1916 pub const PTR: *const watchdog::RegisterBlock = 0x4804_0000 as *const _;
1917 #[doc = r"Return the pointer to the register block"]
1918 #[inline(always)]
1919 pub const fn ptr() -> *const watchdog::RegisterBlock {
1920 Self::PTR
1921 }
1922}
1923impl Deref for WATCHDOG {
1924 type Target = watchdog::RegisterBlock;
1925 #[inline(always)]
1926 fn deref(&self) -> &Self::Target {
1927 unsafe { &*Self::PTR }
1928 }
1929}
1930impl core::fmt::Debug for WATCHDOG {
1931 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1932 f.debug_struct("WATCHDOG").finish()
1933 }
1934}
1935#[doc = "Non-secure Watchdog Timer"]
1936pub mod watchdog;
1937#[doc = "Watchdog (Secure)"]
1938pub struct WATCHDOG_SECURE {
1939 _marker: PhantomData<*const ()>,
1940}
1941unsafe impl Send for WATCHDOG_SECURE {}
1942impl WATCHDOG_SECURE {
1943 #[doc = r"Pointer to the register block"]
1944 pub const PTR: *const watchdog::RegisterBlock = 0x5804_0000 as *const _;
1945 #[doc = r"Return the pointer to the register block"]
1946 #[inline(always)]
1947 pub const fn ptr() -> *const watchdog::RegisterBlock {
1948 Self::PTR
1949 }
1950}
1951impl Deref for WATCHDOG_SECURE {
1952 type Target = watchdog::RegisterBlock;
1953 #[inline(always)]
1954 fn deref(&self) -> &Self::Target {
1955 unsafe { &*Self::PTR }
1956 }
1957}
1958impl core::fmt::Debug for WATCHDOG_SECURE {
1959 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1960 f.debug_struct("WATCHDOG_SECURE").finish()
1961 }
1962}
1963#[doc = "Watchdog (Secure)"]
1964pub use self::watchdog as watchdog_secure;
1965#[doc = "SLOWCLK Watchdog (Secure)"]
1966pub struct SLOWCLKWATCHDOG {
1967 _marker: PhantomData<*const ()>,
1968}
1969unsafe impl Send for SLOWCLKWATCHDOG {}
1970impl SLOWCLKWATCHDOG {
1971 #[doc = r"Pointer to the register block"]
1972 pub const PTR: *const slowclk::RegisterBlock = 0x5802_e000 as *const _;
1973 #[doc = r"Return the pointer to the register block"]
1974 #[inline(always)]
1975 pub const fn ptr() -> *const slowclk::RegisterBlock {
1976 Self::PTR
1977 }
1978}
1979impl Deref for SLOWCLKWATCHDOG {
1980 type Target = slowclk::RegisterBlock;
1981 #[inline(always)]
1982 fn deref(&self) -> &Self::Target {
1983 unsafe { &*Self::PTR }
1984 }
1985}
1986impl core::fmt::Debug for SLOWCLKWATCHDOG {
1987 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1988 f.debug_struct("SLOWCLKWATCHDOG").finish()
1989 }
1990}
1991#[doc = "SLOWCLK Watchdog (Secure)"]
1992pub use self::slowclk as slowclkwatchdog;
1993#[doc = "FPGA System Control I/O"]
1994pub struct FPGAIO {
1995 _marker: PhantomData<*const ()>,
1996}
1997unsafe impl Send for FPGAIO {}
1998impl FPGAIO {
1999 #[doc = r"Pointer to the register block"]
2000 pub const PTR: *const fpgaio::RegisterBlock = 0x4930_2000 as *const _;
2001 #[doc = r"Return the pointer to the register block"]
2002 #[inline(always)]
2003 pub const fn ptr() -> *const fpgaio::RegisterBlock {
2004 Self::PTR
2005 }
2006}
2007impl Deref for FPGAIO {
2008 type Target = fpgaio::RegisterBlock;
2009 #[inline(always)]
2010 fn deref(&self) -> &Self::Target {
2011 unsafe { &*Self::PTR }
2012 }
2013}
2014impl core::fmt::Debug for FPGAIO {
2015 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2016 f.debug_struct("FPGAIO").finish()
2017 }
2018}
2019#[doc = "FPGA System Control I/O"]
2020pub mod fpgaio;
2021#[doc = "FPGA System Control I/O (Secure)"]
2022pub struct FPGAIO_SECURE {
2023 _marker: PhantomData<*const ()>,
2024}
2025unsafe impl Send for FPGAIO_SECURE {}
2026impl FPGAIO_SECURE {
2027 #[doc = r"Pointer to the register block"]
2028 pub const PTR: *const fpgaio::RegisterBlock = 0x5930_2000 as *const _;
2029 #[doc = r"Return the pointer to the register block"]
2030 #[inline(always)]
2031 pub const fn ptr() -> *const fpgaio::RegisterBlock {
2032 Self::PTR
2033 }
2034}
2035impl Deref for FPGAIO_SECURE {
2036 type Target = fpgaio::RegisterBlock;
2037 #[inline(always)]
2038 fn deref(&self) -> &Self::Target {
2039 unsafe { &*Self::PTR }
2040 }
2041}
2042impl core::fmt::Debug for FPGAIO_SECURE {
2043 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2044 f.debug_struct("FPGAIO_SECURE").finish()
2045 }
2046}
2047#[doc = "FPGA System Control I/O (Secure)"]
2048pub use self::fpgaio as fpgaio_secure;
2049#[doc = "Serial Communication Controller"]
2050pub struct SCC {
2051 _marker: PhantomData<*const ()>,
2052}
2053unsafe impl Send for SCC {}
2054impl SCC {
2055 #[doc = r"Pointer to the register block"]
2056 pub const PTR: *const scc::RegisterBlock = 0x4930_0000 as *const _;
2057 #[doc = r"Return the pointer to the register block"]
2058 #[inline(always)]
2059 pub const fn ptr() -> *const scc::RegisterBlock {
2060 Self::PTR
2061 }
2062}
2063impl Deref for SCC {
2064 type Target = scc::RegisterBlock;
2065 #[inline(always)]
2066 fn deref(&self) -> &Self::Target {
2067 unsafe { &*Self::PTR }
2068 }
2069}
2070impl core::fmt::Debug for SCC {
2071 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2072 f.debug_struct("SCC").finish()
2073 }
2074}
2075#[doc = "Serial Communication Controller"]
2076pub mod scc;
2077#[doc = "Serial Communication Controller"]
2078pub struct SCC_SECURE {
2079 _marker: PhantomData<*const ()>,
2080}
2081unsafe impl Send for SCC_SECURE {}
2082impl SCC_SECURE {
2083 #[doc = r"Pointer to the register block"]
2084 pub const PTR: *const scc::RegisterBlock = 0x5930_0000 as *const _;
2085 #[doc = r"Return the pointer to the register block"]
2086 #[inline(always)]
2087 pub const fn ptr() -> *const scc::RegisterBlock {
2088 Self::PTR
2089 }
2090}
2091impl Deref for SCC_SECURE {
2092 type Target = scc::RegisterBlock;
2093 #[inline(always)]
2094 fn deref(&self) -> &Self::Target {
2095 unsafe { &*Self::PTR }
2096 }
2097}
2098impl core::fmt::Debug for SCC_SECURE {
2099 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2100 f.debug_struct("SCC_SECURE").finish()
2101 }
2102}
2103#[doc = "Serial Communication Controller"]
2104pub use self::scc as scc_secure;
2105#[doc = "Secure Access Configuration Register Block"]
2106pub struct SACRB {
2107 _marker: PhantomData<*const ()>,
2108}
2109unsafe impl Send for SACRB {}
2110impl SACRB {
2111 #[doc = r"Pointer to the register block"]
2112 pub const PTR: *const sacrb::RegisterBlock = 0x5008_0000 as *const _;
2113 #[doc = r"Return the pointer to the register block"]
2114 #[inline(always)]
2115 pub const fn ptr() -> *const sacrb::RegisterBlock {
2116 Self::PTR
2117 }
2118}
2119impl Deref for SACRB {
2120 type Target = sacrb::RegisterBlock;
2121 #[inline(always)]
2122 fn deref(&self) -> &Self::Target {
2123 unsafe { &*Self::PTR }
2124 }
2125}
2126impl core::fmt::Debug for SACRB {
2127 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2128 f.debug_struct("SACRB").finish()
2129 }
2130}
2131#[doc = "Secure Access Configuration Register Block"]
2132pub mod sacrb;
2133#[doc = "Non-secure Access Configuration Register Block"]
2134pub struct NSACRB {
2135 _marker: PhantomData<*const ()>,
2136}
2137unsafe impl Send for NSACRB {}
2138impl NSACRB {
2139 #[doc = r"Pointer to the register block"]
2140 pub const PTR: *const nsacrb::RegisterBlock = 0x4008_0000 as *const _;
2141 #[doc = r"Return the pointer to the register block"]
2142 #[inline(always)]
2143 pub const fn ptr() -> *const nsacrb::RegisterBlock {
2144 Self::PTR
2145 }
2146}
2147impl Deref for NSACRB {
2148 type Target = nsacrb::RegisterBlock;
2149 #[inline(always)]
2150 fn deref(&self) -> &Self::Target {
2151 unsafe { &*Self::PTR }
2152 }
2153}
2154impl core::fmt::Debug for NSACRB {
2155 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2156 f.debug_struct("NSACRB").finish()
2157 }
2158}
2159#[doc = "Non-secure Access Configuration Register Block"]
2160pub mod nsacrb;
2161#[doc = "ISRAM 0 Memory Protection Controller"]
2162pub struct ISRAM0MPC {
2163 _marker: PhantomData<*const ()>,
2164}
2165unsafe impl Send for ISRAM0MPC {}
2166impl ISRAM0MPC {
2167 #[doc = r"Pointer to the register block"]
2168 pub const PTR: *const isram0mpc::RegisterBlock = 0x5008_3000 as *const _;
2169 #[doc = r"Return the pointer to the register block"]
2170 #[inline(always)]
2171 pub const fn ptr() -> *const isram0mpc::RegisterBlock {
2172 Self::PTR
2173 }
2174}
2175impl Deref for ISRAM0MPC {
2176 type Target = isram0mpc::RegisterBlock;
2177 #[inline(always)]
2178 fn deref(&self) -> &Self::Target {
2179 unsafe { &*Self::PTR }
2180 }
2181}
2182impl core::fmt::Debug for ISRAM0MPC {
2183 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2184 f.debug_struct("ISRAM0MPC").finish()
2185 }
2186}
2187#[doc = "ISRAM 0 Memory Protection Controller"]
2188pub mod isram0mpc;
2189#[doc = "ISRAM 1 Memory Protection Controller"]
2190pub struct ISRAM1MPC {
2191 _marker: PhantomData<*const ()>,
2192}
2193unsafe impl Send for ISRAM1MPC {}
2194impl ISRAM1MPC {
2195 #[doc = r"Pointer to the register block"]
2196 pub const PTR: *const isram0mpc::RegisterBlock = 0x5008_4000 as *const _;
2197 #[doc = r"Return the pointer to the register block"]
2198 #[inline(always)]
2199 pub const fn ptr() -> *const isram0mpc::RegisterBlock {
2200 Self::PTR
2201 }
2202}
2203impl Deref for ISRAM1MPC {
2204 type Target = isram0mpc::RegisterBlock;
2205 #[inline(always)]
2206 fn deref(&self) -> &Self::Target {
2207 unsafe { &*Self::PTR }
2208 }
2209}
2210impl core::fmt::Debug for ISRAM1MPC {
2211 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2212 f.debug_struct("ISRAM1MPC").finish()
2213 }
2214}
2215#[doc = "ISRAM 1 Memory Protection Controller"]
2216pub use self::isram0mpc as isram1mpc;
2217#[doc = "SMSC LAN9220"]
2218pub struct ETHERNET {
2219 _marker: PhantomData<*const ()>,
2220}
2221unsafe impl Send for ETHERNET {}
2222impl ETHERNET {
2223 #[doc = r"Pointer to the register block"]
2224 pub const PTR: *const ethernet::RegisterBlock = 0x4140_0000 as *const _;
2225 #[doc = r"Return the pointer to the register block"]
2226 #[inline(always)]
2227 pub const fn ptr() -> *const ethernet::RegisterBlock {
2228 Self::PTR
2229 }
2230}
2231impl Deref for ETHERNET {
2232 type Target = ethernet::RegisterBlock;
2233 #[inline(always)]
2234 fn deref(&self) -> &Self::Target {
2235 unsafe { &*Self::PTR }
2236 }
2237}
2238impl core::fmt::Debug for ETHERNET {
2239 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2240 f.debug_struct("ETHERNET").finish()
2241 }
2242}
2243#[doc = "SMSC LAN9220"]
2244pub mod ethernet;
2245#[doc = "AudioI2S"]
2246pub struct AUDIO_I2S {
2247 _marker: PhantomData<*const ()>,
2248}
2249unsafe impl Send for AUDIO_I2S {}
2250impl AUDIO_I2S {
2251 #[doc = r"Pointer to the register block"]
2252 pub const PTR: *const audio_i2s::RegisterBlock = 0x4930_1000 as *const _;
2253 #[doc = r"Return the pointer to the register block"]
2254 #[inline(always)]
2255 pub const fn ptr() -> *const audio_i2s::RegisterBlock {
2256 Self::PTR
2257 }
2258}
2259impl Deref for AUDIO_I2S {
2260 type Target = audio_i2s::RegisterBlock;
2261 #[inline(always)]
2262 fn deref(&self) -> &Self::Target {
2263 unsafe { &*Self::PTR }
2264 }
2265}
2266impl core::fmt::Debug for AUDIO_I2S {
2267 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2268 f.debug_struct("AUDIO_I2S").finish()
2269 }
2270}
2271#[doc = "AudioI2S"]
2272pub mod audio_i2s;
2273#[no_mangle]
2274static mut DEVICE_PERIPHERALS: bool = false;
2275#[doc = r" All the peripherals."]
2276#[allow(non_snake_case)]
2277pub struct Peripherals {
2278 #[doc = "SYSCOUNTER_CNTRL"]
2279 pub SYSCOUNTER_CNTRL: SYSCOUNTER_CNTRL,
2280 #[doc = "SYSCOUNTER_READ"]
2281 pub SYSCOUNTER_READ: SYSCOUNTER_READ,
2282 #[doc = "SYSCOUNTER_READ_SECURE"]
2283 pub SYSCOUNTER_READ_SECURE: SYSCOUNTER_READ_SECURE,
2284 #[doc = "SYSINFO"]
2285 pub SYSINFO: SYSINFO,
2286 #[doc = "SYSINFO_SECURE"]
2287 pub SYSINFO_SECURE: SYSINFO_SECURE,
2288 #[doc = "SYSCONTROL"]
2289 pub SYSCONTROL: SYSCONTROL,
2290 #[doc = "SAU"]
2291 pub SAU: SAU,
2292 #[doc = "TIMER0"]
2293 pub TIMER0: TIMER0,
2294 #[doc = "TIMER1"]
2295 pub TIMER1: TIMER1,
2296 #[doc = "TIMER2"]
2297 pub TIMER2: TIMER2,
2298 #[doc = "TIMER3"]
2299 pub TIMER3: TIMER3,
2300 #[doc = "SLOWCLK"]
2301 pub SLOWCLK: SLOWCLK,
2302 #[doc = "TIMER0_SECURE"]
2303 pub TIMER0_SECURE: TIMER0_SECURE,
2304 #[doc = "TIMER1_SECURE"]
2305 pub TIMER1_SECURE: TIMER1_SECURE,
2306 #[doc = "TIMER2_SECURE"]
2307 pub TIMER2_SECURE: TIMER2_SECURE,
2308 #[doc = "TIMER3_SECURE"]
2309 pub TIMER3_SECURE: TIMER3_SECURE,
2310 #[doc = "SLOWCLK_SECURE"]
2311 pub SLOWCLK_SECURE: SLOWCLK_SECURE,
2312 #[doc = "GPIO0"]
2313 pub GPIO0: GPIO0,
2314 #[doc = "GPIO1"]
2315 pub GPIO1: GPIO1,
2316 #[doc = "GPIO2"]
2317 pub GPIO2: GPIO2,
2318 #[doc = "GPIO3"]
2319 pub GPIO3: GPIO3,
2320 #[doc = "GPIO0_SECURE"]
2321 pub GPIO0_SECURE: GPIO0_SECURE,
2322 #[doc = "GPIO1_SECURE"]
2323 pub GPIO1_SECURE: GPIO1_SECURE,
2324 #[doc = "GPIO2_SECURE"]
2325 pub GPIO2_SECURE: GPIO2_SECURE,
2326 #[doc = "GPIO3_SECURE"]
2327 pub GPIO3_SECURE: GPIO3_SECURE,
2328 #[doc = "DMA0"]
2329 pub DMA0: DMA0,
2330 #[doc = "DMA1"]
2331 pub DMA1: DMA1,
2332 #[doc = "DMA2"]
2333 pub DMA2: DMA2,
2334 #[doc = "DMA3"]
2335 pub DMA3: DMA3,
2336 #[doc = "DMA0_SECURE"]
2337 pub DMA0_SECURE: DMA0_SECURE,
2338 #[doc = "DMA1_SECURE"]
2339 pub DMA1_SECURE: DMA1_SECURE,
2340 #[doc = "DMA2_SECURE"]
2341 pub DMA2_SECURE: DMA2_SECURE,
2342 #[doc = "DMA3_SECURE"]
2343 pub DMA3_SECURE: DMA3_SECURE,
2344 #[doc = "UART0"]
2345 pub UART0: UART0,
2346 #[doc = "UART1"]
2347 pub UART1: UART1,
2348 #[doc = "UART2"]
2349 pub UART2: UART2,
2350 #[doc = "UART3"]
2351 pub UART3: UART3,
2352 #[doc = "UART4"]
2353 pub UART4: UART4,
2354 #[doc = "UART5"]
2355 pub UART5: UART5,
2356 #[doc = "UART0_SECURE"]
2357 pub UART0_SECURE: UART0_SECURE,
2358 #[doc = "UART1_SECURE"]
2359 pub UART1_SECURE: UART1_SECURE,
2360 #[doc = "UART2_SECURE"]
2361 pub UART2_SECURE: UART2_SECURE,
2362 #[doc = "UART3_SECURE"]
2363 pub UART3_SECURE: UART3_SECURE,
2364 #[doc = "UART4_SECURE"]
2365 pub UART4_SECURE: UART4_SECURE,
2366 #[doc = "UART5_SECURE"]
2367 pub UART5_SECURE: UART5_SECURE,
2368 #[doc = "I2C0"]
2369 pub I2C0: I2C0,
2370 #[doc = "I2C1"]
2371 pub I2C1: I2C1,
2372 #[doc = "I2C0_SECURE"]
2373 pub I2C0_SECURE: I2C0_SECURE,
2374 #[doc = "I2C1_SECURE"]
2375 pub I2C1_SECURE: I2C1_SECURE,
2376 #[doc = "SSP0"]
2377 pub SSP0: SSP0,
2378 #[doc = "SSP1"]
2379 pub SSP1: SSP1,
2380 #[doc = "SSP2"]
2381 pub SSP2: SSP2,
2382 #[doc = "SSP0_SECURE"]
2383 pub SSP0_SECURE: SSP0_SECURE,
2384 #[doc = "SSP1_SECURE"]
2385 pub SSP1_SECURE: SSP1_SECURE,
2386 #[doc = "SSP2_SECURE"]
2387 pub SSP2_SECURE: SSP2_SECURE,
2388 #[doc = "WATCHDOG"]
2389 pub WATCHDOG: WATCHDOG,
2390 #[doc = "WATCHDOG_SECURE"]
2391 pub WATCHDOG_SECURE: WATCHDOG_SECURE,
2392 #[doc = "SLOWCLKWATCHDOG"]
2393 pub SLOWCLKWATCHDOG: SLOWCLKWATCHDOG,
2394 #[doc = "FPGAIO"]
2395 pub FPGAIO: FPGAIO,
2396 #[doc = "FPGAIO_SECURE"]
2397 pub FPGAIO_SECURE: FPGAIO_SECURE,
2398 #[doc = "SCC"]
2399 pub SCC: SCC,
2400 #[doc = "SCC_SECURE"]
2401 pub SCC_SECURE: SCC_SECURE,
2402 #[doc = "SACRB"]
2403 pub SACRB: SACRB,
2404 #[doc = "NSACRB"]
2405 pub NSACRB: NSACRB,
2406 #[doc = "ISRAM0MPC"]
2407 pub ISRAM0MPC: ISRAM0MPC,
2408 #[doc = "ISRAM1MPC"]
2409 pub ISRAM1MPC: ISRAM1MPC,
2410 #[doc = "ETHERNET"]
2411 pub ETHERNET: ETHERNET,
2412 #[doc = "AUDIO_I2S"]
2413 pub AUDIO_I2S: AUDIO_I2S,
2414}
2415impl Peripherals {
2416 #[doc = r" Returns all the peripherals *once*."]
2417 #[cfg(feature = "critical-section")]
2418 #[inline]
2419 pub fn take() -> Option<Self> {
2420 critical_section::with(|_| {
2421 if unsafe { DEVICE_PERIPHERALS } {
2422 return None;
2423 }
2424 Some(unsafe { Peripherals::steal() })
2425 })
2426 }
2427 #[doc = r" Unchecked version of `Peripherals::take`."]
2428 #[doc = r""]
2429 #[doc = r" # Safety"]
2430 #[doc = r""]
2431 #[doc = r" Each of the returned peripherals must be used at most once."]
2432 #[inline]
2433 pub unsafe fn steal() -> Self {
2434 DEVICE_PERIPHERALS = true;
2435 Peripherals {
2436 SYSCOUNTER_CNTRL: SYSCOUNTER_CNTRL {
2437 _marker: PhantomData,
2438 },
2439 SYSCOUNTER_READ: SYSCOUNTER_READ {
2440 _marker: PhantomData,
2441 },
2442 SYSCOUNTER_READ_SECURE: SYSCOUNTER_READ_SECURE {
2443 _marker: PhantomData,
2444 },
2445 SYSINFO: SYSINFO {
2446 _marker: PhantomData,
2447 },
2448 SYSINFO_SECURE: SYSINFO_SECURE {
2449 _marker: PhantomData,
2450 },
2451 SYSCONTROL: SYSCONTROL {
2452 _marker: PhantomData,
2453 },
2454 SAU: SAU {
2455 _marker: PhantomData,
2456 },
2457 TIMER0: TIMER0 {
2458 _marker: PhantomData,
2459 },
2460 TIMER1: TIMER1 {
2461 _marker: PhantomData,
2462 },
2463 TIMER2: TIMER2 {
2464 _marker: PhantomData,
2465 },
2466 TIMER3: TIMER3 {
2467 _marker: PhantomData,
2468 },
2469 SLOWCLK: SLOWCLK {
2470 _marker: PhantomData,
2471 },
2472 TIMER0_SECURE: TIMER0_SECURE {
2473 _marker: PhantomData,
2474 },
2475 TIMER1_SECURE: TIMER1_SECURE {
2476 _marker: PhantomData,
2477 },
2478 TIMER2_SECURE: TIMER2_SECURE {
2479 _marker: PhantomData,
2480 },
2481 TIMER3_SECURE: TIMER3_SECURE {
2482 _marker: PhantomData,
2483 },
2484 SLOWCLK_SECURE: SLOWCLK_SECURE {
2485 _marker: PhantomData,
2486 },
2487 GPIO0: GPIO0 {
2488 _marker: PhantomData,
2489 },
2490 GPIO1: GPIO1 {
2491 _marker: PhantomData,
2492 },
2493 GPIO2: GPIO2 {
2494 _marker: PhantomData,
2495 },
2496 GPIO3: GPIO3 {
2497 _marker: PhantomData,
2498 },
2499 GPIO0_SECURE: GPIO0_SECURE {
2500 _marker: PhantomData,
2501 },
2502 GPIO1_SECURE: GPIO1_SECURE {
2503 _marker: PhantomData,
2504 },
2505 GPIO2_SECURE: GPIO2_SECURE {
2506 _marker: PhantomData,
2507 },
2508 GPIO3_SECURE: GPIO3_SECURE {
2509 _marker: PhantomData,
2510 },
2511 DMA0: DMA0 {
2512 _marker: PhantomData,
2513 },
2514 DMA1: DMA1 {
2515 _marker: PhantomData,
2516 },
2517 DMA2: DMA2 {
2518 _marker: PhantomData,
2519 },
2520 DMA3: DMA3 {
2521 _marker: PhantomData,
2522 },
2523 DMA0_SECURE: DMA0_SECURE {
2524 _marker: PhantomData,
2525 },
2526 DMA1_SECURE: DMA1_SECURE {
2527 _marker: PhantomData,
2528 },
2529 DMA2_SECURE: DMA2_SECURE {
2530 _marker: PhantomData,
2531 },
2532 DMA3_SECURE: DMA3_SECURE {
2533 _marker: PhantomData,
2534 },
2535 UART0: UART0 {
2536 _marker: PhantomData,
2537 },
2538 UART1: UART1 {
2539 _marker: PhantomData,
2540 },
2541 UART2: UART2 {
2542 _marker: PhantomData,
2543 },
2544 UART3: UART3 {
2545 _marker: PhantomData,
2546 },
2547 UART4: UART4 {
2548 _marker: PhantomData,
2549 },
2550 UART5: UART5 {
2551 _marker: PhantomData,
2552 },
2553 UART0_SECURE: UART0_SECURE {
2554 _marker: PhantomData,
2555 },
2556 UART1_SECURE: UART1_SECURE {
2557 _marker: PhantomData,
2558 },
2559 UART2_SECURE: UART2_SECURE {
2560 _marker: PhantomData,
2561 },
2562 UART3_SECURE: UART3_SECURE {
2563 _marker: PhantomData,
2564 },
2565 UART4_SECURE: UART4_SECURE {
2566 _marker: PhantomData,
2567 },
2568 UART5_SECURE: UART5_SECURE {
2569 _marker: PhantomData,
2570 },
2571 I2C0: I2C0 {
2572 _marker: PhantomData,
2573 },
2574 I2C1: I2C1 {
2575 _marker: PhantomData,
2576 },
2577 I2C0_SECURE: I2C0_SECURE {
2578 _marker: PhantomData,
2579 },
2580 I2C1_SECURE: I2C1_SECURE {
2581 _marker: PhantomData,
2582 },
2583 SSP0: SSP0 {
2584 _marker: PhantomData,
2585 },
2586 SSP1: SSP1 {
2587 _marker: PhantomData,
2588 },
2589 SSP2: SSP2 {
2590 _marker: PhantomData,
2591 },
2592 SSP0_SECURE: SSP0_SECURE {
2593 _marker: PhantomData,
2594 },
2595 SSP1_SECURE: SSP1_SECURE {
2596 _marker: PhantomData,
2597 },
2598 SSP2_SECURE: SSP2_SECURE {
2599 _marker: PhantomData,
2600 },
2601 WATCHDOG: WATCHDOG {
2602 _marker: PhantomData,
2603 },
2604 WATCHDOG_SECURE: WATCHDOG_SECURE {
2605 _marker: PhantomData,
2606 },
2607 SLOWCLKWATCHDOG: SLOWCLKWATCHDOG {
2608 _marker: PhantomData,
2609 },
2610 FPGAIO: FPGAIO {
2611 _marker: PhantomData,
2612 },
2613 FPGAIO_SECURE: FPGAIO_SECURE {
2614 _marker: PhantomData,
2615 },
2616 SCC: SCC {
2617 _marker: PhantomData,
2618 },
2619 SCC_SECURE: SCC_SECURE {
2620 _marker: PhantomData,
2621 },
2622 SACRB: SACRB {
2623 _marker: PhantomData,
2624 },
2625 NSACRB: NSACRB {
2626 _marker: PhantomData,
2627 },
2628 ISRAM0MPC: ISRAM0MPC {
2629 _marker: PhantomData,
2630 },
2631 ISRAM1MPC: ISRAM1MPC {
2632 _marker: PhantomData,
2633 },
2634 ETHERNET: ETHERNET {
2635 _marker: PhantomData,
2636 },
2637 AUDIO_I2S: AUDIO_I2S {
2638 _marker: PhantomData,
2639 },
2640 }
2641 }
2642}