1#![doc = "Peripheral access API for NRF5340_APPLICATION microcontrollers (generated using svd2rust v0.25.1 ( ))\n\nYou can find an overview of the generated API [here].\n\nAPI features to be included in the [next]
2svd2rust release can be generated by cloning the svd2rust [repository], checking out the above commit, and running `cargo doc --open`.\n\n[here]: https://docs.rs/svd2rust/0.25.1/svd2rust/#peripheral-api\n[next]: https://github.com/rust-embedded/svd2rust/blob/master/CHANGELOG.md#unreleased\n[repository]: https://github.com/rust-embedded/svd2rust"]
3#![deny(const_err)]
4#![deny(dead_code)]
5#![deny(improper_ctypes)]
6#![deny(missing_docs)]
7#![deny(no_mangle_generic_items)]
8#![deny(non_shorthand_field_patterns)]
9#![deny(overflowing_literals)]
10#![deny(path_statements)]
11#![deny(patterns_in_fns_without_body)]
12#![deny(private_in_public)]
13#![deny(unconditional_recursion)]
14#![deny(unused_allocation)]
15#![deny(unused_comparisons)]
16#![deny(unused_parens)]
17#![deny(while_true)]
18#![allow(non_camel_case_types)]
19#![allow(non_snake_case)]
20#![no_std]
21use core::marker::PhantomData;
22use core::ops::Deref;
23#[doc = r"Number available in the NVIC for configuring priority"]
24pub const NVIC_PRIO_BITS: u8 = 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 FPU();
38 fn CACHE();
39 fn SPU();
40 fn CLOCK_POWER();
41 fn SERIAL0();
42 fn SERIAL1();
43 fn SPIM4();
44 fn SERIAL2();
45 fn SERIAL3();
46 fn GPIOTE0();
47 fn SAADC();
48 fn TIMER0();
49 fn TIMER1();
50 fn TIMER2();
51 fn RTC0();
52 fn RTC1();
53 fn WDT0();
54 fn WDT1();
55 fn COMP_LPCOMP();
56 fn EGU0();
57 fn EGU1();
58 fn EGU2();
59 fn EGU3();
60 fn EGU4();
61 fn EGU5();
62 fn PWM0();
63 fn PWM1();
64 fn PWM2();
65 fn PWM3();
66 fn PDM0();
67 fn I2S0();
68 fn IPC();
69 fn QSPI();
70 fn NFCT();
71 fn GPIOTE1();
72 fn QDEC0();
73 fn QDEC1();
74 fn USBD();
75 fn USBREGULATOR();
76 fn KMU();
77 fn CRYPTOCELL();
78}
79#[doc(hidden)]
80pub union Vector {
81 _handler: unsafe extern "C" fn(),
82 _reserved: u32,
83}
84#[cfg(feature = "rt")]
85#[doc(hidden)]
86#[link_section = ".vector_table.interrupts"]
87#[no_mangle]
88pub static __INTERRUPTS: [Vector; 69] = [
89 Vector { _handler: FPU },
90 Vector { _handler: CACHE },
91 Vector { _reserved: 0 },
92 Vector { _handler: SPU },
93 Vector { _reserved: 0 },
94 Vector {
95 _handler: CLOCK_POWER,
96 },
97 Vector { _reserved: 0 },
98 Vector { _reserved: 0 },
99 Vector { _handler: SERIAL0 },
100 Vector { _handler: SERIAL1 },
101 Vector { _handler: SPIM4 },
102 Vector { _handler: SERIAL2 },
103 Vector { _handler: SERIAL3 },
104 Vector { _handler: GPIOTE0 },
105 Vector { _handler: SAADC },
106 Vector { _handler: TIMER0 },
107 Vector { _handler: TIMER1 },
108 Vector { _handler: TIMER2 },
109 Vector { _reserved: 0 },
110 Vector { _reserved: 0 },
111 Vector { _handler: RTC0 },
112 Vector { _handler: RTC1 },
113 Vector { _reserved: 0 },
114 Vector { _reserved: 0 },
115 Vector { _handler: WDT0 },
116 Vector { _handler: WDT1 },
117 Vector {
118 _handler: COMP_LPCOMP,
119 },
120 Vector { _handler: EGU0 },
121 Vector { _handler: EGU1 },
122 Vector { _handler: EGU2 },
123 Vector { _handler: EGU3 },
124 Vector { _handler: EGU4 },
125 Vector { _handler: EGU5 },
126 Vector { _handler: PWM0 },
127 Vector { _handler: PWM1 },
128 Vector { _handler: PWM2 },
129 Vector { _handler: PWM3 },
130 Vector { _reserved: 0 },
131 Vector { _handler: PDM0 },
132 Vector { _reserved: 0 },
133 Vector { _handler: I2S0 },
134 Vector { _reserved: 0 },
135 Vector { _handler: IPC },
136 Vector { _handler: QSPI },
137 Vector { _reserved: 0 },
138 Vector { _handler: NFCT },
139 Vector { _reserved: 0 },
140 Vector { _handler: GPIOTE1 },
141 Vector { _reserved: 0 },
142 Vector { _reserved: 0 },
143 Vector { _reserved: 0 },
144 Vector { _handler: QDEC0 },
145 Vector { _handler: QDEC1 },
146 Vector { _reserved: 0 },
147 Vector { _handler: USBD },
148 Vector {
149 _handler: USBREGULATOR,
150 },
151 Vector { _reserved: 0 },
152 Vector { _handler: KMU },
153 Vector { _reserved: 0 },
154 Vector { _reserved: 0 },
155 Vector { _reserved: 0 },
156 Vector { _reserved: 0 },
157 Vector { _reserved: 0 },
158 Vector { _reserved: 0 },
159 Vector { _reserved: 0 },
160 Vector { _reserved: 0 },
161 Vector { _reserved: 0 },
162 Vector { _reserved: 0 },
163 Vector {
164 _handler: CRYPTOCELL,
165 },
166];
167#[doc = r"Enumeration of all the interrupts."]
168#[derive(Copy, Clone, Debug, PartialEq, Eq)]
169#[repr(u16)]
170pub enum Interrupt {
171 #[doc = "0 - FPU"]
172 FPU = 0,
173 #[doc = "1 - CACHE"]
174 CACHE = 1,
175 #[doc = "3 - SPU"]
176 SPU = 3,
177 #[doc = "5 - CLOCK_POWER"]
178 CLOCK_POWER = 5,
179 #[doc = "8 - SERIAL0"]
180 SERIAL0 = 8,
181 #[doc = "9 - SERIAL1"]
182 SERIAL1 = 9,
183 #[doc = "10 - SPIM4"]
184 SPIM4 = 10,
185 #[doc = "11 - SERIAL2"]
186 SERIAL2 = 11,
187 #[doc = "12 - SERIAL3"]
188 SERIAL3 = 12,
189 #[doc = "13 - GPIOTE0"]
190 GPIOTE0 = 13,
191 #[doc = "14 - SAADC"]
192 SAADC = 14,
193 #[doc = "15 - TIMER0"]
194 TIMER0 = 15,
195 #[doc = "16 - TIMER1"]
196 TIMER1 = 16,
197 #[doc = "17 - TIMER2"]
198 TIMER2 = 17,
199 #[doc = "20 - RTC0"]
200 RTC0 = 20,
201 #[doc = "21 - RTC1"]
202 RTC1 = 21,
203 #[doc = "24 - WDT0"]
204 WDT0 = 24,
205 #[doc = "25 - WDT1"]
206 WDT1 = 25,
207 #[doc = "26 - COMP_LPCOMP"]
208 COMP_LPCOMP = 26,
209 #[doc = "27 - EGU0"]
210 EGU0 = 27,
211 #[doc = "28 - EGU1"]
212 EGU1 = 28,
213 #[doc = "29 - EGU2"]
214 EGU2 = 29,
215 #[doc = "30 - EGU3"]
216 EGU3 = 30,
217 #[doc = "31 - EGU4"]
218 EGU4 = 31,
219 #[doc = "32 - EGU5"]
220 EGU5 = 32,
221 #[doc = "33 - PWM0"]
222 PWM0 = 33,
223 #[doc = "34 - PWM1"]
224 PWM1 = 34,
225 #[doc = "35 - PWM2"]
226 PWM2 = 35,
227 #[doc = "36 - PWM3"]
228 PWM3 = 36,
229 #[doc = "38 - PDM0"]
230 PDM0 = 38,
231 #[doc = "40 - I2S0"]
232 I2S0 = 40,
233 #[doc = "42 - IPC"]
234 IPC = 42,
235 #[doc = "43 - QSPI"]
236 QSPI = 43,
237 #[doc = "45 - NFCT"]
238 NFCT = 45,
239 #[doc = "47 - GPIOTE1"]
240 GPIOTE1 = 47,
241 #[doc = "51 - QDEC0"]
242 QDEC0 = 51,
243 #[doc = "52 - QDEC1"]
244 QDEC1 = 52,
245 #[doc = "54 - USBD"]
246 USBD = 54,
247 #[doc = "55 - USBREGULATOR"]
248 USBREGULATOR = 55,
249 #[doc = "57 - KMU"]
250 KMU = 57,
251 #[doc = "68 - CRYPTOCELL"]
252 CRYPTOCELL = 68,
253}
254unsafe impl cortex_m::interrupt::InterruptNumber for Interrupt {
255 #[inline(always)]
256 fn number(self) -> u16 {
257 self as u16
258 }
259}
260#[doc = "CACHEDATA"]
261pub struct CACHEDATA_S {
262 _marker: PhantomData<*const ()>,
263}
264unsafe impl Send for CACHEDATA_S {}
265impl CACHEDATA_S {
266 #[doc = r"Pointer to the register block"]
267 pub const PTR: *const cachedata_s::RegisterBlock = 0x00f0_0000 as *const _;
268 #[doc = r"Return the pointer to the register block"]
269 #[inline(always)]
270 pub const fn ptr() -> *const cachedata_s::RegisterBlock {
271 Self::PTR
272 }
273}
274impl Deref for CACHEDATA_S {
275 type Target = cachedata_s::RegisterBlock;
276 #[inline(always)]
277 fn deref(&self) -> &Self::Target {
278 unsafe { &*Self::PTR }
279 }
280}
281impl core::fmt::Debug for CACHEDATA_S {
282 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
283 f.debug_struct("CACHEDATA_S").finish()
284 }
285}
286#[doc = "CACHEDATA"]
287pub mod cachedata_s;
288#[doc = "CACHEINFO"]
289pub struct CACHEINFO_S {
290 _marker: PhantomData<*const ()>,
291}
292unsafe impl Send for CACHEINFO_S {}
293impl CACHEINFO_S {
294 #[doc = r"Pointer to the register block"]
295 pub const PTR: *const cacheinfo_s::RegisterBlock = 0x00f0_8000 as *const _;
296 #[doc = r"Return the pointer to the register block"]
297 #[inline(always)]
298 pub const fn ptr() -> *const cacheinfo_s::RegisterBlock {
299 Self::PTR
300 }
301}
302impl Deref for CACHEINFO_S {
303 type Target = cacheinfo_s::RegisterBlock;
304 #[inline(always)]
305 fn deref(&self) -> &Self::Target {
306 unsafe { &*Self::PTR }
307 }
308}
309impl core::fmt::Debug for CACHEINFO_S {
310 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
311 f.debug_struct("CACHEINFO_S").finish()
312 }
313}
314#[doc = "CACHEINFO"]
315pub mod cacheinfo_s;
316#[doc = "Factory Information Configuration Registers"]
317pub struct FICR_S {
318 _marker: PhantomData<*const ()>,
319}
320unsafe impl Send for FICR_S {}
321impl FICR_S {
322 #[doc = r"Pointer to the register block"]
323 pub const PTR: *const ficr_s::RegisterBlock = 0x00ff_0000 as *const _;
324 #[doc = r"Return the pointer to the register block"]
325 #[inline(always)]
326 pub const fn ptr() -> *const ficr_s::RegisterBlock {
327 Self::PTR
328 }
329}
330impl Deref for FICR_S {
331 type Target = ficr_s::RegisterBlock;
332 #[inline(always)]
333 fn deref(&self) -> &Self::Target {
334 unsafe { &*Self::PTR }
335 }
336}
337impl core::fmt::Debug for FICR_S {
338 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
339 f.debug_struct("FICR_S").finish()
340 }
341}
342#[doc = "Factory Information Configuration Registers"]
343pub mod ficr_s;
344#[doc = "User Information Configuration Registers User information configuration registers"]
345pub struct UICR_S {
346 _marker: PhantomData<*const ()>,
347}
348unsafe impl Send for UICR_S {}
349impl UICR_S {
350 #[doc = r"Pointer to the register block"]
351 pub const PTR: *const uicr_s::RegisterBlock = 0x00ff_8000 as *const _;
352 #[doc = r"Return the pointer to the register block"]
353 #[inline(always)]
354 pub const fn ptr() -> *const uicr_s::RegisterBlock {
355 Self::PTR
356 }
357}
358impl Deref for UICR_S {
359 type Target = uicr_s::RegisterBlock;
360 #[inline(always)]
361 fn deref(&self) -> &Self::Target {
362 unsafe { &*Self::PTR }
363 }
364}
365impl core::fmt::Debug for UICR_S {
366 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
367 f.debug_struct("UICR_S").finish()
368 }
369}
370#[doc = "User Information Configuration Registers User information configuration registers"]
371pub mod uicr_s;
372#[doc = "Cross-Trigger Interface control. NOTE: this is not a separate peripheral, but describes CM33 functionality."]
373pub struct CTI_S {
374 _marker: PhantomData<*const ()>,
375}
376unsafe impl Send for CTI_S {}
377impl CTI_S {
378 #[doc = r"Pointer to the register block"]
379 pub const PTR: *const cti_s::RegisterBlock = 0xe004_2000 as *const _;
380 #[doc = r"Return the pointer to the register block"]
381 #[inline(always)]
382 pub const fn ptr() -> *const cti_s::RegisterBlock {
383 Self::PTR
384 }
385}
386impl Deref for CTI_S {
387 type Target = cti_s::RegisterBlock;
388 #[inline(always)]
389 fn deref(&self) -> &Self::Target {
390 unsafe { &*Self::PTR }
391 }
392}
393impl core::fmt::Debug for CTI_S {
394 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
395 f.debug_struct("CTI_S").finish()
396 }
397}
398#[doc = "Cross-Trigger Interface control. NOTE: this is not a separate peripheral, but describes CM33 functionality."]
399pub mod cti_s;
400#[doc = "Trace and debug control"]
401pub struct TAD_S {
402 _marker: PhantomData<*const ()>,
403}
404unsafe impl Send for TAD_S {}
405impl TAD_S {
406 #[doc = r"Pointer to the register block"]
407 pub const PTR: *const tad_s::RegisterBlock = 0xe008_0000 as *const _;
408 #[doc = r"Return the pointer to the register block"]
409 #[inline(always)]
410 pub const fn ptr() -> *const tad_s::RegisterBlock {
411 Self::PTR
412 }
413}
414impl Deref for TAD_S {
415 type Target = tad_s::RegisterBlock;
416 #[inline(always)]
417 fn deref(&self) -> &Self::Target {
418 unsafe { &*Self::PTR }
419 }
420}
421impl core::fmt::Debug for TAD_S {
422 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
423 f.debug_struct("TAD_S").finish()
424 }
425}
426#[doc = "Trace and debug control"]
427pub mod tad_s;
428#[doc = "Domain configuration management 0"]
429pub struct DCNF_NS {
430 _marker: PhantomData<*const ()>,
431}
432unsafe impl Send for DCNF_NS {}
433impl DCNF_NS {
434 #[doc = r"Pointer to the register block"]
435 pub const PTR: *const dcnf_ns::RegisterBlock = 0x4000_0000 as *const _;
436 #[doc = r"Return the pointer to the register block"]
437 #[inline(always)]
438 pub const fn ptr() -> *const dcnf_ns::RegisterBlock {
439 Self::PTR
440 }
441}
442impl Deref for DCNF_NS {
443 type Target = dcnf_ns::RegisterBlock;
444 #[inline(always)]
445 fn deref(&self) -> &Self::Target {
446 unsafe { &*Self::PTR }
447 }
448}
449impl core::fmt::Debug for DCNF_NS {
450 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
451 f.debug_struct("DCNF_NS").finish()
452 }
453}
454#[doc = "Domain configuration management 0"]
455pub mod dcnf_ns;
456#[doc = "FPU control peripheral 0"]
457pub struct FPU_NS {
458 _marker: PhantomData<*const ()>,
459}
460unsafe impl Send for FPU_NS {}
461impl FPU_NS {
462 #[doc = r"Pointer to the register block"]
463 pub const PTR: *const fpu_ns::RegisterBlock = 0x4000_0000 as *const _;
464 #[doc = r"Return the pointer to the register block"]
465 #[inline(always)]
466 pub const fn ptr() -> *const fpu_ns::RegisterBlock {
467 Self::PTR
468 }
469}
470impl Deref for FPU_NS {
471 type Target = fpu_ns::RegisterBlock;
472 #[inline(always)]
473 fn deref(&self) -> &Self::Target {
474 unsafe { &*Self::PTR }
475 }
476}
477impl core::fmt::Debug for FPU_NS {
478 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
479 f.debug_struct("FPU_NS").finish()
480 }
481}
482#[doc = "FPU control peripheral 0"]
483pub mod fpu_ns;
484#[doc = "Domain configuration management 1"]
485pub struct DCNF_S {
486 _marker: PhantomData<*const ()>,
487}
488unsafe impl Send for DCNF_S {}
489impl DCNF_S {
490 #[doc = r"Pointer to the register block"]
491 pub const PTR: *const dcnf_ns::RegisterBlock = 0x5000_0000 as *const _;
492 #[doc = r"Return the pointer to the register block"]
493 #[inline(always)]
494 pub const fn ptr() -> *const dcnf_ns::RegisterBlock {
495 Self::PTR
496 }
497}
498impl Deref for DCNF_S {
499 type Target = dcnf_ns::RegisterBlock;
500 #[inline(always)]
501 fn deref(&self) -> &Self::Target {
502 unsafe { &*Self::PTR }
503 }
504}
505impl core::fmt::Debug for DCNF_S {
506 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
507 f.debug_struct("DCNF_S").finish()
508 }
509}
510#[doc = "Domain configuration management 1"]
511pub use dcnf_ns as dcnf_s;
512#[doc = "FPU control peripheral 1"]
513pub struct FPU_S {
514 _marker: PhantomData<*const ()>,
515}
516unsafe impl Send for FPU_S {}
517impl FPU_S {
518 #[doc = r"Pointer to the register block"]
519 pub const PTR: *const fpu_ns::RegisterBlock = 0x5000_0000 as *const _;
520 #[doc = r"Return the pointer to the register block"]
521 #[inline(always)]
522 pub const fn ptr() -> *const fpu_ns::RegisterBlock {
523 Self::PTR
524 }
525}
526impl Deref for FPU_S {
527 type Target = fpu_ns::RegisterBlock;
528 #[inline(always)]
529 fn deref(&self) -> &Self::Target {
530 unsafe { &*Self::PTR }
531 }
532}
533impl core::fmt::Debug for FPU_S {
534 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
535 f.debug_struct("FPU_S").finish()
536 }
537}
538#[doc = "FPU control peripheral 1"]
539pub use fpu_ns as fpu_s;
540#[doc = "Cache"]
541pub struct CACHE_S {
542 _marker: PhantomData<*const ()>,
543}
544unsafe impl Send for CACHE_S {}
545impl CACHE_S {
546 #[doc = r"Pointer to the register block"]
547 pub const PTR: *const cache_s::RegisterBlock = 0x5000_1000 as *const _;
548 #[doc = r"Return the pointer to the register block"]
549 #[inline(always)]
550 pub const fn ptr() -> *const cache_s::RegisterBlock {
551 Self::PTR
552 }
553}
554impl Deref for CACHE_S {
555 type Target = cache_s::RegisterBlock;
556 #[inline(always)]
557 fn deref(&self) -> &Self::Target {
558 unsafe { &*Self::PTR }
559 }
560}
561impl core::fmt::Debug for CACHE_S {
562 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
563 f.debug_struct("CACHE_S").finish()
564 }
565}
566#[doc = "Cache"]
567pub mod cache_s;
568#[doc = "System protection unit"]
569pub struct SPU_S {
570 _marker: PhantomData<*const ()>,
571}
572unsafe impl Send for SPU_S {}
573impl SPU_S {
574 #[doc = r"Pointer to the register block"]
575 pub const PTR: *const spu_s::RegisterBlock = 0x5000_3000 as *const _;
576 #[doc = r"Return the pointer to the register block"]
577 #[inline(always)]
578 pub const fn ptr() -> *const spu_s::RegisterBlock {
579 Self::PTR
580 }
581}
582impl Deref for SPU_S {
583 type Target = spu_s::RegisterBlock;
584 #[inline(always)]
585 fn deref(&self) -> &Self::Target {
586 unsafe { &*Self::PTR }
587 }
588}
589impl core::fmt::Debug for SPU_S {
590 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
591 f.debug_struct("SPU_S").finish()
592 }
593}
594#[doc = "System protection unit"]
595pub mod spu_s;
596#[doc = "Oscillator control 0"]
597pub struct OSCILLATORS_NS {
598 _marker: PhantomData<*const ()>,
599}
600unsafe impl Send for OSCILLATORS_NS {}
601impl OSCILLATORS_NS {
602 #[doc = r"Pointer to the register block"]
603 pub const PTR: *const oscillators_ns::RegisterBlock = 0x4000_4000 as *const _;
604 #[doc = r"Return the pointer to the register block"]
605 #[inline(always)]
606 pub const fn ptr() -> *const oscillators_ns::RegisterBlock {
607 Self::PTR
608 }
609}
610impl Deref for OSCILLATORS_NS {
611 type Target = oscillators_ns::RegisterBlock;
612 #[inline(always)]
613 fn deref(&self) -> &Self::Target {
614 unsafe { &*Self::PTR }
615 }
616}
617impl core::fmt::Debug for OSCILLATORS_NS {
618 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
619 f.debug_struct("OSCILLATORS_NS").finish()
620 }
621}
622#[doc = "Oscillator control 0"]
623pub mod oscillators_ns;
624#[doc = "Voltage regulators 0"]
625pub struct REGULATORS_NS {
626 _marker: PhantomData<*const ()>,
627}
628unsafe impl Send for REGULATORS_NS {}
629impl REGULATORS_NS {
630 #[doc = r"Pointer to the register block"]
631 pub const PTR: *const regulators_ns::RegisterBlock = 0x4000_4000 as *const _;
632 #[doc = r"Return the pointer to the register block"]
633 #[inline(always)]
634 pub const fn ptr() -> *const regulators_ns::RegisterBlock {
635 Self::PTR
636 }
637}
638impl Deref for REGULATORS_NS {
639 type Target = regulators_ns::RegisterBlock;
640 #[inline(always)]
641 fn deref(&self) -> &Self::Target {
642 unsafe { &*Self::PTR }
643 }
644}
645impl core::fmt::Debug for REGULATORS_NS {
646 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
647 f.debug_struct("REGULATORS_NS").finish()
648 }
649}
650#[doc = "Voltage regulators 0"]
651pub mod regulators_ns;
652#[doc = "Oscillator control 1"]
653pub struct OSCILLATORS_S {
654 _marker: PhantomData<*const ()>,
655}
656unsafe impl Send for OSCILLATORS_S {}
657impl OSCILLATORS_S {
658 #[doc = r"Pointer to the register block"]
659 pub const PTR: *const oscillators_ns::RegisterBlock = 0x5000_4000 as *const _;
660 #[doc = r"Return the pointer to the register block"]
661 #[inline(always)]
662 pub const fn ptr() -> *const oscillators_ns::RegisterBlock {
663 Self::PTR
664 }
665}
666impl Deref for OSCILLATORS_S {
667 type Target = oscillators_ns::RegisterBlock;
668 #[inline(always)]
669 fn deref(&self) -> &Self::Target {
670 unsafe { &*Self::PTR }
671 }
672}
673impl core::fmt::Debug for OSCILLATORS_S {
674 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
675 f.debug_struct("OSCILLATORS_S").finish()
676 }
677}
678#[doc = "Oscillator control 1"]
679pub use oscillators_ns as oscillators_s;
680#[doc = "Voltage regulators 1"]
681pub struct REGULATORS_S {
682 _marker: PhantomData<*const ()>,
683}
684unsafe impl Send for REGULATORS_S {}
685impl REGULATORS_S {
686 #[doc = r"Pointer to the register block"]
687 pub const PTR: *const regulators_ns::RegisterBlock = 0x5000_4000 as *const _;
688 #[doc = r"Return the pointer to the register block"]
689 #[inline(always)]
690 pub const fn ptr() -> *const regulators_ns::RegisterBlock {
691 Self::PTR
692 }
693}
694impl Deref for REGULATORS_S {
695 type Target = regulators_ns::RegisterBlock;
696 #[inline(always)]
697 fn deref(&self) -> &Self::Target {
698 unsafe { &*Self::PTR }
699 }
700}
701impl core::fmt::Debug for REGULATORS_S {
702 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
703 f.debug_struct("REGULATORS_S").finish()
704 }
705}
706#[doc = "Voltage regulators 1"]
707pub use regulators_ns as regulators_s;
708#[doc = "Clock management 0"]
709pub struct CLOCK_NS {
710 _marker: PhantomData<*const ()>,
711}
712unsafe impl Send for CLOCK_NS {}
713impl CLOCK_NS {
714 #[doc = r"Pointer to the register block"]
715 pub const PTR: *const clock_ns::RegisterBlock = 0x4000_5000 as *const _;
716 #[doc = r"Return the pointer to the register block"]
717 #[inline(always)]
718 pub const fn ptr() -> *const clock_ns::RegisterBlock {
719 Self::PTR
720 }
721}
722impl Deref for CLOCK_NS {
723 type Target = clock_ns::RegisterBlock;
724 #[inline(always)]
725 fn deref(&self) -> &Self::Target {
726 unsafe { &*Self::PTR }
727 }
728}
729impl core::fmt::Debug for CLOCK_NS {
730 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
731 f.debug_struct("CLOCK_NS").finish()
732 }
733}
734#[doc = "Clock management 0"]
735pub mod clock_ns;
736#[doc = "Power control 0"]
737pub struct POWER_NS {
738 _marker: PhantomData<*const ()>,
739}
740unsafe impl Send for POWER_NS {}
741impl POWER_NS {
742 #[doc = r"Pointer to the register block"]
743 pub const PTR: *const power_ns::RegisterBlock = 0x4000_5000 as *const _;
744 #[doc = r"Return the pointer to the register block"]
745 #[inline(always)]
746 pub const fn ptr() -> *const power_ns::RegisterBlock {
747 Self::PTR
748 }
749}
750impl Deref for POWER_NS {
751 type Target = power_ns::RegisterBlock;
752 #[inline(always)]
753 fn deref(&self) -> &Self::Target {
754 unsafe { &*Self::PTR }
755 }
756}
757impl core::fmt::Debug for POWER_NS {
758 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
759 f.debug_struct("POWER_NS").finish()
760 }
761}
762#[doc = "Power control 0"]
763pub mod power_ns;
764#[doc = "Reset control 0"]
765pub struct RESET_NS {
766 _marker: PhantomData<*const ()>,
767}
768unsafe impl Send for RESET_NS {}
769impl RESET_NS {
770 #[doc = r"Pointer to the register block"]
771 pub const PTR: *const reset_ns::RegisterBlock = 0x4000_5000 as *const _;
772 #[doc = r"Return the pointer to the register block"]
773 #[inline(always)]
774 pub const fn ptr() -> *const reset_ns::RegisterBlock {
775 Self::PTR
776 }
777}
778impl Deref for RESET_NS {
779 type Target = reset_ns::RegisterBlock;
780 #[inline(always)]
781 fn deref(&self) -> &Self::Target {
782 unsafe { &*Self::PTR }
783 }
784}
785impl core::fmt::Debug for RESET_NS {
786 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
787 f.debug_struct("RESET_NS").finish()
788 }
789}
790#[doc = "Reset control 0"]
791pub mod reset_ns;
792#[doc = "Clock management 1"]
793pub struct CLOCK_S {
794 _marker: PhantomData<*const ()>,
795}
796unsafe impl Send for CLOCK_S {}
797impl CLOCK_S {
798 #[doc = r"Pointer to the register block"]
799 pub const PTR: *const clock_ns::RegisterBlock = 0x5000_5000 as *const _;
800 #[doc = r"Return the pointer to the register block"]
801 #[inline(always)]
802 pub const fn ptr() -> *const clock_ns::RegisterBlock {
803 Self::PTR
804 }
805}
806impl Deref for CLOCK_S {
807 type Target = clock_ns::RegisterBlock;
808 #[inline(always)]
809 fn deref(&self) -> &Self::Target {
810 unsafe { &*Self::PTR }
811 }
812}
813impl core::fmt::Debug for CLOCK_S {
814 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
815 f.debug_struct("CLOCK_S").finish()
816 }
817}
818#[doc = "Clock management 1"]
819pub use clock_ns as clock_s;
820#[doc = "Power control 1"]
821pub struct POWER_S {
822 _marker: PhantomData<*const ()>,
823}
824unsafe impl Send for POWER_S {}
825impl POWER_S {
826 #[doc = r"Pointer to the register block"]
827 pub const PTR: *const power_ns::RegisterBlock = 0x5000_5000 as *const _;
828 #[doc = r"Return the pointer to the register block"]
829 #[inline(always)]
830 pub const fn ptr() -> *const power_ns::RegisterBlock {
831 Self::PTR
832 }
833}
834impl Deref for POWER_S {
835 type Target = power_ns::RegisterBlock;
836 #[inline(always)]
837 fn deref(&self) -> &Self::Target {
838 unsafe { &*Self::PTR }
839 }
840}
841impl core::fmt::Debug for POWER_S {
842 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
843 f.debug_struct("POWER_S").finish()
844 }
845}
846#[doc = "Power control 1"]
847pub use power_ns as power_s;
848#[doc = "Reset control 1"]
849pub struct RESET_S {
850 _marker: PhantomData<*const ()>,
851}
852unsafe impl Send for RESET_S {}
853impl RESET_S {
854 #[doc = r"Pointer to the register block"]
855 pub const PTR: *const reset_ns::RegisterBlock = 0x5000_5000 as *const _;
856 #[doc = r"Return the pointer to the register block"]
857 #[inline(always)]
858 pub const fn ptr() -> *const reset_ns::RegisterBlock {
859 Self::PTR
860 }
861}
862impl Deref for RESET_S {
863 type Target = reset_ns::RegisterBlock;
864 #[inline(always)]
865 fn deref(&self) -> &Self::Target {
866 unsafe { &*Self::PTR }
867 }
868}
869impl core::fmt::Debug for RESET_S {
870 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
871 f.debug_struct("RESET_S").finish()
872 }
873}
874#[doc = "Reset control 1"]
875pub use reset_ns as reset_s;
876#[doc = "Control access port 0"]
877pub struct CTRLAP_NS {
878 _marker: PhantomData<*const ()>,
879}
880unsafe impl Send for CTRLAP_NS {}
881impl CTRLAP_NS {
882 #[doc = r"Pointer to the register block"]
883 pub const PTR: *const ctrlap_ns::RegisterBlock = 0x4000_6000 as *const _;
884 #[doc = r"Return the pointer to the register block"]
885 #[inline(always)]
886 pub const fn ptr() -> *const ctrlap_ns::RegisterBlock {
887 Self::PTR
888 }
889}
890impl Deref for CTRLAP_NS {
891 type Target = ctrlap_ns::RegisterBlock;
892 #[inline(always)]
893 fn deref(&self) -> &Self::Target {
894 unsafe { &*Self::PTR }
895 }
896}
897impl core::fmt::Debug for CTRLAP_NS {
898 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
899 f.debug_struct("CTRLAP_NS").finish()
900 }
901}
902#[doc = "Control access port 0"]
903pub mod ctrlap_ns;
904#[doc = "Control access port 1"]
905pub struct CTRLAP_S {
906 _marker: PhantomData<*const ()>,
907}
908unsafe impl Send for CTRLAP_S {}
909impl CTRLAP_S {
910 #[doc = r"Pointer to the register block"]
911 pub const PTR: *const ctrlap_ns::RegisterBlock = 0x5000_6000 as *const _;
912 #[doc = r"Return the pointer to the register block"]
913 #[inline(always)]
914 pub const fn ptr() -> *const ctrlap_ns::RegisterBlock {
915 Self::PTR
916 }
917}
918impl Deref for CTRLAP_S {
919 type Target = ctrlap_ns::RegisterBlock;
920 #[inline(always)]
921 fn deref(&self) -> &Self::Target {
922 unsafe { &*Self::PTR }
923 }
924}
925impl core::fmt::Debug for CTRLAP_S {
926 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
927 f.debug_struct("CTRLAP_S").finish()
928 }
929}
930#[doc = "Control access port 1"]
931pub use ctrlap_ns as ctrlap_s;
932#[doc = "Serial Peripheral Interface Master with EasyDMA 0"]
933pub struct SPIM0_NS {
934 _marker: PhantomData<*const ()>,
935}
936unsafe impl Send for SPIM0_NS {}
937impl SPIM0_NS {
938 #[doc = r"Pointer to the register block"]
939 pub const PTR: *const spim0_ns::RegisterBlock = 0x4000_8000 as *const _;
940 #[doc = r"Return the pointer to the register block"]
941 #[inline(always)]
942 pub const fn ptr() -> *const spim0_ns::RegisterBlock {
943 Self::PTR
944 }
945}
946impl Deref for SPIM0_NS {
947 type Target = spim0_ns::RegisterBlock;
948 #[inline(always)]
949 fn deref(&self) -> &Self::Target {
950 unsafe { &*Self::PTR }
951 }
952}
953impl core::fmt::Debug for SPIM0_NS {
954 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
955 f.debug_struct("SPIM0_NS").finish()
956 }
957}
958#[doc = "Serial Peripheral Interface Master with EasyDMA 0"]
959pub mod spim0_ns;
960#[doc = "SPI Slave 0"]
961pub struct SPIS0_NS {
962 _marker: PhantomData<*const ()>,
963}
964unsafe impl Send for SPIS0_NS {}
965impl SPIS0_NS {
966 #[doc = r"Pointer to the register block"]
967 pub const PTR: *const spis0_ns::RegisterBlock = 0x4000_8000 as *const _;
968 #[doc = r"Return the pointer to the register block"]
969 #[inline(always)]
970 pub const fn ptr() -> *const spis0_ns::RegisterBlock {
971 Self::PTR
972 }
973}
974impl Deref for SPIS0_NS {
975 type Target = spis0_ns::RegisterBlock;
976 #[inline(always)]
977 fn deref(&self) -> &Self::Target {
978 unsafe { &*Self::PTR }
979 }
980}
981impl core::fmt::Debug for SPIS0_NS {
982 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
983 f.debug_struct("SPIS0_NS").finish()
984 }
985}
986#[doc = "SPI Slave 0"]
987pub mod spis0_ns;
988#[doc = "I2C compatible Two-Wire Master Interface with EasyDMA 0"]
989pub struct TWIM0_NS {
990 _marker: PhantomData<*const ()>,
991}
992unsafe impl Send for TWIM0_NS {}
993impl TWIM0_NS {
994 #[doc = r"Pointer to the register block"]
995 pub const PTR: *const twim0_ns::RegisterBlock = 0x4000_8000 as *const _;
996 #[doc = r"Return the pointer to the register block"]
997 #[inline(always)]
998 pub const fn ptr() -> *const twim0_ns::RegisterBlock {
999 Self::PTR
1000 }
1001}
1002impl Deref for TWIM0_NS {
1003 type Target = twim0_ns::RegisterBlock;
1004 #[inline(always)]
1005 fn deref(&self) -> &Self::Target {
1006 unsafe { &*Self::PTR }
1007 }
1008}
1009impl core::fmt::Debug for TWIM0_NS {
1010 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1011 f.debug_struct("TWIM0_NS").finish()
1012 }
1013}
1014#[doc = "I2C compatible Two-Wire Master Interface with EasyDMA 0"]
1015pub mod twim0_ns;
1016#[doc = "I2C compatible Two-Wire Slave Interface with EasyDMA 0"]
1017pub struct TWIS0_NS {
1018 _marker: PhantomData<*const ()>,
1019}
1020unsafe impl Send for TWIS0_NS {}
1021impl TWIS0_NS {
1022 #[doc = r"Pointer to the register block"]
1023 pub const PTR: *const twis0_ns::RegisterBlock = 0x4000_8000 as *const _;
1024 #[doc = r"Return the pointer to the register block"]
1025 #[inline(always)]
1026 pub const fn ptr() -> *const twis0_ns::RegisterBlock {
1027 Self::PTR
1028 }
1029}
1030impl Deref for TWIS0_NS {
1031 type Target = twis0_ns::RegisterBlock;
1032 #[inline(always)]
1033 fn deref(&self) -> &Self::Target {
1034 unsafe { &*Self::PTR }
1035 }
1036}
1037impl core::fmt::Debug for TWIS0_NS {
1038 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1039 f.debug_struct("TWIS0_NS").finish()
1040 }
1041}
1042#[doc = "I2C compatible Two-Wire Slave Interface with EasyDMA 0"]
1043pub mod twis0_ns;
1044#[doc = "UART with EasyDMA 0"]
1045pub struct UARTE0_NS {
1046 _marker: PhantomData<*const ()>,
1047}
1048unsafe impl Send for UARTE0_NS {}
1049impl UARTE0_NS {
1050 #[doc = r"Pointer to the register block"]
1051 pub const PTR: *const uarte0_ns::RegisterBlock = 0x4000_8000 as *const _;
1052 #[doc = r"Return the pointer to the register block"]
1053 #[inline(always)]
1054 pub const fn ptr() -> *const uarte0_ns::RegisterBlock {
1055 Self::PTR
1056 }
1057}
1058impl Deref for UARTE0_NS {
1059 type Target = uarte0_ns::RegisterBlock;
1060 #[inline(always)]
1061 fn deref(&self) -> &Self::Target {
1062 unsafe { &*Self::PTR }
1063 }
1064}
1065impl core::fmt::Debug for UARTE0_NS {
1066 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1067 f.debug_struct("UARTE0_NS").finish()
1068 }
1069}
1070#[doc = "UART with EasyDMA 0"]
1071pub mod uarte0_ns;
1072#[doc = "Serial Peripheral Interface Master with EasyDMA 1"]
1073pub struct SPIM0_S {
1074 _marker: PhantomData<*const ()>,
1075}
1076unsafe impl Send for SPIM0_S {}
1077impl SPIM0_S {
1078 #[doc = r"Pointer to the register block"]
1079 pub const PTR: *const spim0_ns::RegisterBlock = 0x5000_8000 as *const _;
1080 #[doc = r"Return the pointer to the register block"]
1081 #[inline(always)]
1082 pub const fn ptr() -> *const spim0_ns::RegisterBlock {
1083 Self::PTR
1084 }
1085}
1086impl Deref for SPIM0_S {
1087 type Target = spim0_ns::RegisterBlock;
1088 #[inline(always)]
1089 fn deref(&self) -> &Self::Target {
1090 unsafe { &*Self::PTR }
1091 }
1092}
1093impl core::fmt::Debug for SPIM0_S {
1094 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1095 f.debug_struct("SPIM0_S").finish()
1096 }
1097}
1098#[doc = "Serial Peripheral Interface Master with EasyDMA 1"]
1099pub use spim0_ns as spim0_s;
1100#[doc = "SPI Slave 1"]
1101pub struct SPIS0_S {
1102 _marker: PhantomData<*const ()>,
1103}
1104unsafe impl Send for SPIS0_S {}
1105impl SPIS0_S {
1106 #[doc = r"Pointer to the register block"]
1107 pub const PTR: *const spis0_ns::RegisterBlock = 0x5000_8000 as *const _;
1108 #[doc = r"Return the pointer to the register block"]
1109 #[inline(always)]
1110 pub const fn ptr() -> *const spis0_ns::RegisterBlock {
1111 Self::PTR
1112 }
1113}
1114impl Deref for SPIS0_S {
1115 type Target = spis0_ns::RegisterBlock;
1116 #[inline(always)]
1117 fn deref(&self) -> &Self::Target {
1118 unsafe { &*Self::PTR }
1119 }
1120}
1121impl core::fmt::Debug for SPIS0_S {
1122 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1123 f.debug_struct("SPIS0_S").finish()
1124 }
1125}
1126#[doc = "SPI Slave 1"]
1127pub use spis0_ns as spis0_s;
1128#[doc = "I2C compatible Two-Wire Master Interface with EasyDMA 1"]
1129pub struct TWIM0_S {
1130 _marker: PhantomData<*const ()>,
1131}
1132unsafe impl Send for TWIM0_S {}
1133impl TWIM0_S {
1134 #[doc = r"Pointer to the register block"]
1135 pub const PTR: *const twim0_ns::RegisterBlock = 0x5000_8000 as *const _;
1136 #[doc = r"Return the pointer to the register block"]
1137 #[inline(always)]
1138 pub const fn ptr() -> *const twim0_ns::RegisterBlock {
1139 Self::PTR
1140 }
1141}
1142impl Deref for TWIM0_S {
1143 type Target = twim0_ns::RegisterBlock;
1144 #[inline(always)]
1145 fn deref(&self) -> &Self::Target {
1146 unsafe { &*Self::PTR }
1147 }
1148}
1149impl core::fmt::Debug for TWIM0_S {
1150 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1151 f.debug_struct("TWIM0_S").finish()
1152 }
1153}
1154#[doc = "I2C compatible Two-Wire Master Interface with EasyDMA 1"]
1155pub use twim0_ns as twim0_s;
1156#[doc = "I2C compatible Two-Wire Slave Interface with EasyDMA 1"]
1157pub struct TWIS0_S {
1158 _marker: PhantomData<*const ()>,
1159}
1160unsafe impl Send for TWIS0_S {}
1161impl TWIS0_S {
1162 #[doc = r"Pointer to the register block"]
1163 pub const PTR: *const twis0_ns::RegisterBlock = 0x5000_8000 as *const _;
1164 #[doc = r"Return the pointer to the register block"]
1165 #[inline(always)]
1166 pub const fn ptr() -> *const twis0_ns::RegisterBlock {
1167 Self::PTR
1168 }
1169}
1170impl Deref for TWIS0_S {
1171 type Target = twis0_ns::RegisterBlock;
1172 #[inline(always)]
1173 fn deref(&self) -> &Self::Target {
1174 unsafe { &*Self::PTR }
1175 }
1176}
1177impl core::fmt::Debug for TWIS0_S {
1178 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1179 f.debug_struct("TWIS0_S").finish()
1180 }
1181}
1182#[doc = "I2C compatible Two-Wire Slave Interface with EasyDMA 1"]
1183pub use twis0_ns as twis0_s;
1184#[doc = "UART with EasyDMA 1"]
1185pub struct UARTE0_S {
1186 _marker: PhantomData<*const ()>,
1187}
1188unsafe impl Send for UARTE0_S {}
1189impl UARTE0_S {
1190 #[doc = r"Pointer to the register block"]
1191 pub const PTR: *const uarte0_ns::RegisterBlock = 0x5000_8000 as *const _;
1192 #[doc = r"Return the pointer to the register block"]
1193 #[inline(always)]
1194 pub const fn ptr() -> *const uarte0_ns::RegisterBlock {
1195 Self::PTR
1196 }
1197}
1198impl Deref for UARTE0_S {
1199 type Target = uarte0_ns::RegisterBlock;
1200 #[inline(always)]
1201 fn deref(&self) -> &Self::Target {
1202 unsafe { &*Self::PTR }
1203 }
1204}
1205impl core::fmt::Debug for UARTE0_S {
1206 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1207 f.debug_struct("UARTE0_S").finish()
1208 }
1209}
1210#[doc = "UART with EasyDMA 1"]
1211pub use uarte0_ns as uarte0_s;
1212#[doc = "Serial Peripheral Interface Master with EasyDMA 2"]
1213pub struct SPIM1_NS {
1214 _marker: PhantomData<*const ()>,
1215}
1216unsafe impl Send for SPIM1_NS {}
1217impl SPIM1_NS {
1218 #[doc = r"Pointer to the register block"]
1219 pub const PTR: *const spim0_ns::RegisterBlock = 0x4000_9000 as *const _;
1220 #[doc = r"Return the pointer to the register block"]
1221 #[inline(always)]
1222 pub const fn ptr() -> *const spim0_ns::RegisterBlock {
1223 Self::PTR
1224 }
1225}
1226impl Deref for SPIM1_NS {
1227 type Target = spim0_ns::RegisterBlock;
1228 #[inline(always)]
1229 fn deref(&self) -> &Self::Target {
1230 unsafe { &*Self::PTR }
1231 }
1232}
1233impl core::fmt::Debug for SPIM1_NS {
1234 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1235 f.debug_struct("SPIM1_NS").finish()
1236 }
1237}
1238#[doc = "Serial Peripheral Interface Master with EasyDMA 2"]
1239pub use spim0_ns as spim1_ns;
1240#[doc = "SPI Slave 2"]
1241pub struct SPIS1_NS {
1242 _marker: PhantomData<*const ()>,
1243}
1244unsafe impl Send for SPIS1_NS {}
1245impl SPIS1_NS {
1246 #[doc = r"Pointer to the register block"]
1247 pub const PTR: *const spis0_ns::RegisterBlock = 0x4000_9000 as *const _;
1248 #[doc = r"Return the pointer to the register block"]
1249 #[inline(always)]
1250 pub const fn ptr() -> *const spis0_ns::RegisterBlock {
1251 Self::PTR
1252 }
1253}
1254impl Deref for SPIS1_NS {
1255 type Target = spis0_ns::RegisterBlock;
1256 #[inline(always)]
1257 fn deref(&self) -> &Self::Target {
1258 unsafe { &*Self::PTR }
1259 }
1260}
1261impl core::fmt::Debug for SPIS1_NS {
1262 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1263 f.debug_struct("SPIS1_NS").finish()
1264 }
1265}
1266#[doc = "SPI Slave 2"]
1267pub use spis0_ns as spis1_ns;
1268#[doc = "I2C compatible Two-Wire Master Interface with EasyDMA 2"]
1269pub struct TWIM1_NS {
1270 _marker: PhantomData<*const ()>,
1271}
1272unsafe impl Send for TWIM1_NS {}
1273impl TWIM1_NS {
1274 #[doc = r"Pointer to the register block"]
1275 pub const PTR: *const twim0_ns::RegisterBlock = 0x4000_9000 as *const _;
1276 #[doc = r"Return the pointer to the register block"]
1277 #[inline(always)]
1278 pub const fn ptr() -> *const twim0_ns::RegisterBlock {
1279 Self::PTR
1280 }
1281}
1282impl Deref for TWIM1_NS {
1283 type Target = twim0_ns::RegisterBlock;
1284 #[inline(always)]
1285 fn deref(&self) -> &Self::Target {
1286 unsafe { &*Self::PTR }
1287 }
1288}
1289impl core::fmt::Debug for TWIM1_NS {
1290 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1291 f.debug_struct("TWIM1_NS").finish()
1292 }
1293}
1294#[doc = "I2C compatible Two-Wire Master Interface with EasyDMA 2"]
1295pub use twim0_ns as twim1_ns;
1296#[doc = "I2C compatible Two-Wire Slave Interface with EasyDMA 2"]
1297pub struct TWIS1_NS {
1298 _marker: PhantomData<*const ()>,
1299}
1300unsafe impl Send for TWIS1_NS {}
1301impl TWIS1_NS {
1302 #[doc = r"Pointer to the register block"]
1303 pub const PTR: *const twis0_ns::RegisterBlock = 0x4000_9000 as *const _;
1304 #[doc = r"Return the pointer to the register block"]
1305 #[inline(always)]
1306 pub const fn ptr() -> *const twis0_ns::RegisterBlock {
1307 Self::PTR
1308 }
1309}
1310impl Deref for TWIS1_NS {
1311 type Target = twis0_ns::RegisterBlock;
1312 #[inline(always)]
1313 fn deref(&self) -> &Self::Target {
1314 unsafe { &*Self::PTR }
1315 }
1316}
1317impl core::fmt::Debug for TWIS1_NS {
1318 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1319 f.debug_struct("TWIS1_NS").finish()
1320 }
1321}
1322#[doc = "I2C compatible Two-Wire Slave Interface with EasyDMA 2"]
1323pub use twis0_ns as twis1_ns;
1324#[doc = "UART with EasyDMA 2"]
1325pub struct UARTE1_NS {
1326 _marker: PhantomData<*const ()>,
1327}
1328unsafe impl Send for UARTE1_NS {}
1329impl UARTE1_NS {
1330 #[doc = r"Pointer to the register block"]
1331 pub const PTR: *const uarte0_ns::RegisterBlock = 0x4000_9000 as *const _;
1332 #[doc = r"Return the pointer to the register block"]
1333 #[inline(always)]
1334 pub const fn ptr() -> *const uarte0_ns::RegisterBlock {
1335 Self::PTR
1336 }
1337}
1338impl Deref for UARTE1_NS {
1339 type Target = uarte0_ns::RegisterBlock;
1340 #[inline(always)]
1341 fn deref(&self) -> &Self::Target {
1342 unsafe { &*Self::PTR }
1343 }
1344}
1345impl core::fmt::Debug for UARTE1_NS {
1346 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1347 f.debug_struct("UARTE1_NS").finish()
1348 }
1349}
1350#[doc = "UART with EasyDMA 2"]
1351pub use uarte0_ns as uarte1_ns;
1352#[doc = "Serial Peripheral Interface Master with EasyDMA 3"]
1353pub struct SPIM1_S {
1354 _marker: PhantomData<*const ()>,
1355}
1356unsafe impl Send for SPIM1_S {}
1357impl SPIM1_S {
1358 #[doc = r"Pointer to the register block"]
1359 pub const PTR: *const spim0_ns::RegisterBlock = 0x5000_9000 as *const _;
1360 #[doc = r"Return the pointer to the register block"]
1361 #[inline(always)]
1362 pub const fn ptr() -> *const spim0_ns::RegisterBlock {
1363 Self::PTR
1364 }
1365}
1366impl Deref for SPIM1_S {
1367 type Target = spim0_ns::RegisterBlock;
1368 #[inline(always)]
1369 fn deref(&self) -> &Self::Target {
1370 unsafe { &*Self::PTR }
1371 }
1372}
1373impl core::fmt::Debug for SPIM1_S {
1374 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1375 f.debug_struct("SPIM1_S").finish()
1376 }
1377}
1378#[doc = "Serial Peripheral Interface Master with EasyDMA 3"]
1379pub use spim0_ns as spim1_s;
1380#[doc = "SPI Slave 3"]
1381pub struct SPIS1_S {
1382 _marker: PhantomData<*const ()>,
1383}
1384unsafe impl Send for SPIS1_S {}
1385impl SPIS1_S {
1386 #[doc = r"Pointer to the register block"]
1387 pub const PTR: *const spis0_ns::RegisterBlock = 0x5000_9000 as *const _;
1388 #[doc = r"Return the pointer to the register block"]
1389 #[inline(always)]
1390 pub const fn ptr() -> *const spis0_ns::RegisterBlock {
1391 Self::PTR
1392 }
1393}
1394impl Deref for SPIS1_S {
1395 type Target = spis0_ns::RegisterBlock;
1396 #[inline(always)]
1397 fn deref(&self) -> &Self::Target {
1398 unsafe { &*Self::PTR }
1399 }
1400}
1401impl core::fmt::Debug for SPIS1_S {
1402 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1403 f.debug_struct("SPIS1_S").finish()
1404 }
1405}
1406#[doc = "SPI Slave 3"]
1407pub use spis0_ns as spis1_s;
1408#[doc = "I2C compatible Two-Wire Master Interface with EasyDMA 3"]
1409pub struct TWIM1_S {
1410 _marker: PhantomData<*const ()>,
1411}
1412unsafe impl Send for TWIM1_S {}
1413impl TWIM1_S {
1414 #[doc = r"Pointer to the register block"]
1415 pub const PTR: *const twim0_ns::RegisterBlock = 0x5000_9000 as *const _;
1416 #[doc = r"Return the pointer to the register block"]
1417 #[inline(always)]
1418 pub const fn ptr() -> *const twim0_ns::RegisterBlock {
1419 Self::PTR
1420 }
1421}
1422impl Deref for TWIM1_S {
1423 type Target = twim0_ns::RegisterBlock;
1424 #[inline(always)]
1425 fn deref(&self) -> &Self::Target {
1426 unsafe { &*Self::PTR }
1427 }
1428}
1429impl core::fmt::Debug for TWIM1_S {
1430 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1431 f.debug_struct("TWIM1_S").finish()
1432 }
1433}
1434#[doc = "I2C compatible Two-Wire Master Interface with EasyDMA 3"]
1435pub use twim0_ns as twim1_s;
1436#[doc = "I2C compatible Two-Wire Slave Interface with EasyDMA 3"]
1437pub struct TWIS1_S {
1438 _marker: PhantomData<*const ()>,
1439}
1440unsafe impl Send for TWIS1_S {}
1441impl TWIS1_S {
1442 #[doc = r"Pointer to the register block"]
1443 pub const PTR: *const twis0_ns::RegisterBlock = 0x5000_9000 as *const _;
1444 #[doc = r"Return the pointer to the register block"]
1445 #[inline(always)]
1446 pub const fn ptr() -> *const twis0_ns::RegisterBlock {
1447 Self::PTR
1448 }
1449}
1450impl Deref for TWIS1_S {
1451 type Target = twis0_ns::RegisterBlock;
1452 #[inline(always)]
1453 fn deref(&self) -> &Self::Target {
1454 unsafe { &*Self::PTR }
1455 }
1456}
1457impl core::fmt::Debug for TWIS1_S {
1458 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1459 f.debug_struct("TWIS1_S").finish()
1460 }
1461}
1462#[doc = "I2C compatible Two-Wire Slave Interface with EasyDMA 3"]
1463pub use twis0_ns as twis1_s;
1464#[doc = "UART with EasyDMA 3"]
1465pub struct UARTE1_S {
1466 _marker: PhantomData<*const ()>,
1467}
1468unsafe impl Send for UARTE1_S {}
1469impl UARTE1_S {
1470 #[doc = r"Pointer to the register block"]
1471 pub const PTR: *const uarte0_ns::RegisterBlock = 0x5000_9000 as *const _;
1472 #[doc = r"Return the pointer to the register block"]
1473 #[inline(always)]
1474 pub const fn ptr() -> *const uarte0_ns::RegisterBlock {
1475 Self::PTR
1476 }
1477}
1478impl Deref for UARTE1_S {
1479 type Target = uarte0_ns::RegisterBlock;
1480 #[inline(always)]
1481 fn deref(&self) -> &Self::Target {
1482 unsafe { &*Self::PTR }
1483 }
1484}
1485impl core::fmt::Debug for UARTE1_S {
1486 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1487 f.debug_struct("UARTE1_S").finish()
1488 }
1489}
1490#[doc = "UART with EasyDMA 3"]
1491pub use uarte0_ns as uarte1_s;
1492#[doc = "Serial Peripheral Interface Master with EasyDMA 4"]
1493pub struct SPIM4_NS {
1494 _marker: PhantomData<*const ()>,
1495}
1496unsafe impl Send for SPIM4_NS {}
1497impl SPIM4_NS {
1498 #[doc = r"Pointer to the register block"]
1499 pub const PTR: *const spim0_ns::RegisterBlock = 0x4000_a000 as *const _;
1500 #[doc = r"Return the pointer to the register block"]
1501 #[inline(always)]
1502 pub const fn ptr() -> *const spim0_ns::RegisterBlock {
1503 Self::PTR
1504 }
1505}
1506impl Deref for SPIM4_NS {
1507 type Target = spim0_ns::RegisterBlock;
1508 #[inline(always)]
1509 fn deref(&self) -> &Self::Target {
1510 unsafe { &*Self::PTR }
1511 }
1512}
1513impl core::fmt::Debug for SPIM4_NS {
1514 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1515 f.debug_struct("SPIM4_NS").finish()
1516 }
1517}
1518#[doc = "Serial Peripheral Interface Master with EasyDMA 4"]
1519pub use spim0_ns as spim4_ns;
1520#[doc = "Serial Peripheral Interface Master with EasyDMA 5"]
1521pub struct SPIM4_S {
1522 _marker: PhantomData<*const ()>,
1523}
1524unsafe impl Send for SPIM4_S {}
1525impl SPIM4_S {
1526 #[doc = r"Pointer to the register block"]
1527 pub const PTR: *const spim0_ns::RegisterBlock = 0x5000_a000 as *const _;
1528 #[doc = r"Return the pointer to the register block"]
1529 #[inline(always)]
1530 pub const fn ptr() -> *const spim0_ns::RegisterBlock {
1531 Self::PTR
1532 }
1533}
1534impl Deref for SPIM4_S {
1535 type Target = spim0_ns::RegisterBlock;
1536 #[inline(always)]
1537 fn deref(&self) -> &Self::Target {
1538 unsafe { &*Self::PTR }
1539 }
1540}
1541impl core::fmt::Debug for SPIM4_S {
1542 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1543 f.debug_struct("SPIM4_S").finish()
1544 }
1545}
1546#[doc = "Serial Peripheral Interface Master with EasyDMA 5"]
1547pub use spim0_ns as spim4_s;
1548#[doc = "Serial Peripheral Interface Master with EasyDMA 6"]
1549pub struct SPIM2_NS {
1550 _marker: PhantomData<*const ()>,
1551}
1552unsafe impl Send for SPIM2_NS {}
1553impl SPIM2_NS {
1554 #[doc = r"Pointer to the register block"]
1555 pub const PTR: *const spim0_ns::RegisterBlock = 0x4000_b000 as *const _;
1556 #[doc = r"Return the pointer to the register block"]
1557 #[inline(always)]
1558 pub const fn ptr() -> *const spim0_ns::RegisterBlock {
1559 Self::PTR
1560 }
1561}
1562impl Deref for SPIM2_NS {
1563 type Target = spim0_ns::RegisterBlock;
1564 #[inline(always)]
1565 fn deref(&self) -> &Self::Target {
1566 unsafe { &*Self::PTR }
1567 }
1568}
1569impl core::fmt::Debug for SPIM2_NS {
1570 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1571 f.debug_struct("SPIM2_NS").finish()
1572 }
1573}
1574#[doc = "Serial Peripheral Interface Master with EasyDMA 6"]
1575pub use spim0_ns as spim2_ns;
1576#[doc = "SPI Slave 4"]
1577pub struct SPIS2_NS {
1578 _marker: PhantomData<*const ()>,
1579}
1580unsafe impl Send for SPIS2_NS {}
1581impl SPIS2_NS {
1582 #[doc = r"Pointer to the register block"]
1583 pub const PTR: *const spis0_ns::RegisterBlock = 0x4000_b000 as *const _;
1584 #[doc = r"Return the pointer to the register block"]
1585 #[inline(always)]
1586 pub const fn ptr() -> *const spis0_ns::RegisterBlock {
1587 Self::PTR
1588 }
1589}
1590impl Deref for SPIS2_NS {
1591 type Target = spis0_ns::RegisterBlock;
1592 #[inline(always)]
1593 fn deref(&self) -> &Self::Target {
1594 unsafe { &*Self::PTR }
1595 }
1596}
1597impl core::fmt::Debug for SPIS2_NS {
1598 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1599 f.debug_struct("SPIS2_NS").finish()
1600 }
1601}
1602#[doc = "SPI Slave 4"]
1603pub use spis0_ns as spis2_ns;
1604#[doc = "I2C compatible Two-Wire Master Interface with EasyDMA 4"]
1605pub struct TWIM2_NS {
1606 _marker: PhantomData<*const ()>,
1607}
1608unsafe impl Send for TWIM2_NS {}
1609impl TWIM2_NS {
1610 #[doc = r"Pointer to the register block"]
1611 pub const PTR: *const twim0_ns::RegisterBlock = 0x4000_b000 as *const _;
1612 #[doc = r"Return the pointer to the register block"]
1613 #[inline(always)]
1614 pub const fn ptr() -> *const twim0_ns::RegisterBlock {
1615 Self::PTR
1616 }
1617}
1618impl Deref for TWIM2_NS {
1619 type Target = twim0_ns::RegisterBlock;
1620 #[inline(always)]
1621 fn deref(&self) -> &Self::Target {
1622 unsafe { &*Self::PTR }
1623 }
1624}
1625impl core::fmt::Debug for TWIM2_NS {
1626 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1627 f.debug_struct("TWIM2_NS").finish()
1628 }
1629}
1630#[doc = "I2C compatible Two-Wire Master Interface with EasyDMA 4"]
1631pub use twim0_ns as twim2_ns;
1632#[doc = "I2C compatible Two-Wire Slave Interface with EasyDMA 4"]
1633pub struct TWIS2_NS {
1634 _marker: PhantomData<*const ()>,
1635}
1636unsafe impl Send for TWIS2_NS {}
1637impl TWIS2_NS {
1638 #[doc = r"Pointer to the register block"]
1639 pub const PTR: *const twis0_ns::RegisterBlock = 0x4000_b000 as *const _;
1640 #[doc = r"Return the pointer to the register block"]
1641 #[inline(always)]
1642 pub const fn ptr() -> *const twis0_ns::RegisterBlock {
1643 Self::PTR
1644 }
1645}
1646impl Deref for TWIS2_NS {
1647 type Target = twis0_ns::RegisterBlock;
1648 #[inline(always)]
1649 fn deref(&self) -> &Self::Target {
1650 unsafe { &*Self::PTR }
1651 }
1652}
1653impl core::fmt::Debug for TWIS2_NS {
1654 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1655 f.debug_struct("TWIS2_NS").finish()
1656 }
1657}
1658#[doc = "I2C compatible Two-Wire Slave Interface with EasyDMA 4"]
1659pub use twis0_ns as twis2_ns;
1660#[doc = "UART with EasyDMA 4"]
1661pub struct UARTE2_NS {
1662 _marker: PhantomData<*const ()>,
1663}
1664unsafe impl Send for UARTE2_NS {}
1665impl UARTE2_NS {
1666 #[doc = r"Pointer to the register block"]
1667 pub const PTR: *const uarte0_ns::RegisterBlock = 0x4000_b000 as *const _;
1668 #[doc = r"Return the pointer to the register block"]
1669 #[inline(always)]
1670 pub const fn ptr() -> *const uarte0_ns::RegisterBlock {
1671 Self::PTR
1672 }
1673}
1674impl Deref for UARTE2_NS {
1675 type Target = uarte0_ns::RegisterBlock;
1676 #[inline(always)]
1677 fn deref(&self) -> &Self::Target {
1678 unsafe { &*Self::PTR }
1679 }
1680}
1681impl core::fmt::Debug for UARTE2_NS {
1682 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1683 f.debug_struct("UARTE2_NS").finish()
1684 }
1685}
1686#[doc = "UART with EasyDMA 4"]
1687pub use uarte0_ns as uarte2_ns;
1688#[doc = "Serial Peripheral Interface Master with EasyDMA 7"]
1689pub struct SPIM2_S {
1690 _marker: PhantomData<*const ()>,
1691}
1692unsafe impl Send for SPIM2_S {}
1693impl SPIM2_S {
1694 #[doc = r"Pointer to the register block"]
1695 pub const PTR: *const spim0_ns::RegisterBlock = 0x5000_b000 as *const _;
1696 #[doc = r"Return the pointer to the register block"]
1697 #[inline(always)]
1698 pub const fn ptr() -> *const spim0_ns::RegisterBlock {
1699 Self::PTR
1700 }
1701}
1702impl Deref for SPIM2_S {
1703 type Target = spim0_ns::RegisterBlock;
1704 #[inline(always)]
1705 fn deref(&self) -> &Self::Target {
1706 unsafe { &*Self::PTR }
1707 }
1708}
1709impl core::fmt::Debug for SPIM2_S {
1710 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1711 f.debug_struct("SPIM2_S").finish()
1712 }
1713}
1714#[doc = "Serial Peripheral Interface Master with EasyDMA 7"]
1715pub use spim0_ns as spim2_s;
1716#[doc = "SPI Slave 5"]
1717pub struct SPIS2_S {
1718 _marker: PhantomData<*const ()>,
1719}
1720unsafe impl Send for SPIS2_S {}
1721impl SPIS2_S {
1722 #[doc = r"Pointer to the register block"]
1723 pub const PTR: *const spis0_ns::RegisterBlock = 0x5000_b000 as *const _;
1724 #[doc = r"Return the pointer to the register block"]
1725 #[inline(always)]
1726 pub const fn ptr() -> *const spis0_ns::RegisterBlock {
1727 Self::PTR
1728 }
1729}
1730impl Deref for SPIS2_S {
1731 type Target = spis0_ns::RegisterBlock;
1732 #[inline(always)]
1733 fn deref(&self) -> &Self::Target {
1734 unsafe { &*Self::PTR }
1735 }
1736}
1737impl core::fmt::Debug for SPIS2_S {
1738 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1739 f.debug_struct("SPIS2_S").finish()
1740 }
1741}
1742#[doc = "SPI Slave 5"]
1743pub use spis0_ns as spis2_s;
1744#[doc = "I2C compatible Two-Wire Master Interface with EasyDMA 5"]
1745pub struct TWIM2_S {
1746 _marker: PhantomData<*const ()>,
1747}
1748unsafe impl Send for TWIM2_S {}
1749impl TWIM2_S {
1750 #[doc = r"Pointer to the register block"]
1751 pub const PTR: *const twim0_ns::RegisterBlock = 0x5000_b000 as *const _;
1752 #[doc = r"Return the pointer to the register block"]
1753 #[inline(always)]
1754 pub const fn ptr() -> *const twim0_ns::RegisterBlock {
1755 Self::PTR
1756 }
1757}
1758impl Deref for TWIM2_S {
1759 type Target = twim0_ns::RegisterBlock;
1760 #[inline(always)]
1761 fn deref(&self) -> &Self::Target {
1762 unsafe { &*Self::PTR }
1763 }
1764}
1765impl core::fmt::Debug for TWIM2_S {
1766 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1767 f.debug_struct("TWIM2_S").finish()
1768 }
1769}
1770#[doc = "I2C compatible Two-Wire Master Interface with EasyDMA 5"]
1771pub use twim0_ns as twim2_s;
1772#[doc = "I2C compatible Two-Wire Slave Interface with EasyDMA 5"]
1773pub struct TWIS2_S {
1774 _marker: PhantomData<*const ()>,
1775}
1776unsafe impl Send for TWIS2_S {}
1777impl TWIS2_S {
1778 #[doc = r"Pointer to the register block"]
1779 pub const PTR: *const twis0_ns::RegisterBlock = 0x5000_b000 as *const _;
1780 #[doc = r"Return the pointer to the register block"]
1781 #[inline(always)]
1782 pub const fn ptr() -> *const twis0_ns::RegisterBlock {
1783 Self::PTR
1784 }
1785}
1786impl Deref for TWIS2_S {
1787 type Target = twis0_ns::RegisterBlock;
1788 #[inline(always)]
1789 fn deref(&self) -> &Self::Target {
1790 unsafe { &*Self::PTR }
1791 }
1792}
1793impl core::fmt::Debug for TWIS2_S {
1794 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1795 f.debug_struct("TWIS2_S").finish()
1796 }
1797}
1798#[doc = "I2C compatible Two-Wire Slave Interface with EasyDMA 5"]
1799pub use twis0_ns as twis2_s;
1800#[doc = "UART with EasyDMA 5"]
1801pub struct UARTE2_S {
1802 _marker: PhantomData<*const ()>,
1803}
1804unsafe impl Send for UARTE2_S {}
1805impl UARTE2_S {
1806 #[doc = r"Pointer to the register block"]
1807 pub const PTR: *const uarte0_ns::RegisterBlock = 0x5000_b000 as *const _;
1808 #[doc = r"Return the pointer to the register block"]
1809 #[inline(always)]
1810 pub const fn ptr() -> *const uarte0_ns::RegisterBlock {
1811 Self::PTR
1812 }
1813}
1814impl Deref for UARTE2_S {
1815 type Target = uarte0_ns::RegisterBlock;
1816 #[inline(always)]
1817 fn deref(&self) -> &Self::Target {
1818 unsafe { &*Self::PTR }
1819 }
1820}
1821impl core::fmt::Debug for UARTE2_S {
1822 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1823 f.debug_struct("UARTE2_S").finish()
1824 }
1825}
1826#[doc = "UART with EasyDMA 5"]
1827pub use uarte0_ns as uarte2_s;
1828#[doc = "Serial Peripheral Interface Master with EasyDMA 8"]
1829pub struct SPIM3_NS {
1830 _marker: PhantomData<*const ()>,
1831}
1832unsafe impl Send for SPIM3_NS {}
1833impl SPIM3_NS {
1834 #[doc = r"Pointer to the register block"]
1835 pub const PTR: *const spim0_ns::RegisterBlock = 0x4000_c000 as *const _;
1836 #[doc = r"Return the pointer to the register block"]
1837 #[inline(always)]
1838 pub const fn ptr() -> *const spim0_ns::RegisterBlock {
1839 Self::PTR
1840 }
1841}
1842impl Deref for SPIM3_NS {
1843 type Target = spim0_ns::RegisterBlock;
1844 #[inline(always)]
1845 fn deref(&self) -> &Self::Target {
1846 unsafe { &*Self::PTR }
1847 }
1848}
1849impl core::fmt::Debug for SPIM3_NS {
1850 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1851 f.debug_struct("SPIM3_NS").finish()
1852 }
1853}
1854#[doc = "Serial Peripheral Interface Master with EasyDMA 8"]
1855pub use spim0_ns as spim3_ns;
1856#[doc = "SPI Slave 6"]
1857pub struct SPIS3_NS {
1858 _marker: PhantomData<*const ()>,
1859}
1860unsafe impl Send for SPIS3_NS {}
1861impl SPIS3_NS {
1862 #[doc = r"Pointer to the register block"]
1863 pub const PTR: *const spis0_ns::RegisterBlock = 0x4000_c000 as *const _;
1864 #[doc = r"Return the pointer to the register block"]
1865 #[inline(always)]
1866 pub const fn ptr() -> *const spis0_ns::RegisterBlock {
1867 Self::PTR
1868 }
1869}
1870impl Deref for SPIS3_NS {
1871 type Target = spis0_ns::RegisterBlock;
1872 #[inline(always)]
1873 fn deref(&self) -> &Self::Target {
1874 unsafe { &*Self::PTR }
1875 }
1876}
1877impl core::fmt::Debug for SPIS3_NS {
1878 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1879 f.debug_struct("SPIS3_NS").finish()
1880 }
1881}
1882#[doc = "SPI Slave 6"]
1883pub use spis0_ns as spis3_ns;
1884#[doc = "I2C compatible Two-Wire Master Interface with EasyDMA 6"]
1885pub struct TWIM3_NS {
1886 _marker: PhantomData<*const ()>,
1887}
1888unsafe impl Send for TWIM3_NS {}
1889impl TWIM3_NS {
1890 #[doc = r"Pointer to the register block"]
1891 pub const PTR: *const twim0_ns::RegisterBlock = 0x4000_c000 as *const _;
1892 #[doc = r"Return the pointer to the register block"]
1893 #[inline(always)]
1894 pub const fn ptr() -> *const twim0_ns::RegisterBlock {
1895 Self::PTR
1896 }
1897}
1898impl Deref for TWIM3_NS {
1899 type Target = twim0_ns::RegisterBlock;
1900 #[inline(always)]
1901 fn deref(&self) -> &Self::Target {
1902 unsafe { &*Self::PTR }
1903 }
1904}
1905impl core::fmt::Debug for TWIM3_NS {
1906 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1907 f.debug_struct("TWIM3_NS").finish()
1908 }
1909}
1910#[doc = "I2C compatible Two-Wire Master Interface with EasyDMA 6"]
1911pub use twim0_ns as twim3_ns;
1912#[doc = "I2C compatible Two-Wire Slave Interface with EasyDMA 6"]
1913pub struct TWIS3_NS {
1914 _marker: PhantomData<*const ()>,
1915}
1916unsafe impl Send for TWIS3_NS {}
1917impl TWIS3_NS {
1918 #[doc = r"Pointer to the register block"]
1919 pub const PTR: *const twis0_ns::RegisterBlock = 0x4000_c000 as *const _;
1920 #[doc = r"Return the pointer to the register block"]
1921 #[inline(always)]
1922 pub const fn ptr() -> *const twis0_ns::RegisterBlock {
1923 Self::PTR
1924 }
1925}
1926impl Deref for TWIS3_NS {
1927 type Target = twis0_ns::RegisterBlock;
1928 #[inline(always)]
1929 fn deref(&self) -> &Self::Target {
1930 unsafe { &*Self::PTR }
1931 }
1932}
1933impl core::fmt::Debug for TWIS3_NS {
1934 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1935 f.debug_struct("TWIS3_NS").finish()
1936 }
1937}
1938#[doc = "I2C compatible Two-Wire Slave Interface with EasyDMA 6"]
1939pub use twis0_ns as twis3_ns;
1940#[doc = "UART with EasyDMA 6"]
1941pub struct UARTE3_NS {
1942 _marker: PhantomData<*const ()>,
1943}
1944unsafe impl Send for UARTE3_NS {}
1945impl UARTE3_NS {
1946 #[doc = r"Pointer to the register block"]
1947 pub const PTR: *const uarte0_ns::RegisterBlock = 0x4000_c000 as *const _;
1948 #[doc = r"Return the pointer to the register block"]
1949 #[inline(always)]
1950 pub const fn ptr() -> *const uarte0_ns::RegisterBlock {
1951 Self::PTR
1952 }
1953}
1954impl Deref for UARTE3_NS {
1955 type Target = uarte0_ns::RegisterBlock;
1956 #[inline(always)]
1957 fn deref(&self) -> &Self::Target {
1958 unsafe { &*Self::PTR }
1959 }
1960}
1961impl core::fmt::Debug for UARTE3_NS {
1962 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1963 f.debug_struct("UARTE3_NS").finish()
1964 }
1965}
1966#[doc = "UART with EasyDMA 6"]
1967pub use uarte0_ns as uarte3_ns;
1968#[doc = "Serial Peripheral Interface Master with EasyDMA 9"]
1969pub struct SPIM3_S {
1970 _marker: PhantomData<*const ()>,
1971}
1972unsafe impl Send for SPIM3_S {}
1973impl SPIM3_S {
1974 #[doc = r"Pointer to the register block"]
1975 pub const PTR: *const spim0_ns::RegisterBlock = 0x5000_c000 as *const _;
1976 #[doc = r"Return the pointer to the register block"]
1977 #[inline(always)]
1978 pub const fn ptr() -> *const spim0_ns::RegisterBlock {
1979 Self::PTR
1980 }
1981}
1982impl Deref for SPIM3_S {
1983 type Target = spim0_ns::RegisterBlock;
1984 #[inline(always)]
1985 fn deref(&self) -> &Self::Target {
1986 unsafe { &*Self::PTR }
1987 }
1988}
1989impl core::fmt::Debug for SPIM3_S {
1990 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1991 f.debug_struct("SPIM3_S").finish()
1992 }
1993}
1994#[doc = "Serial Peripheral Interface Master with EasyDMA 9"]
1995pub use spim0_ns as spim3_s;
1996#[doc = "SPI Slave 7"]
1997pub struct SPIS3_S {
1998 _marker: PhantomData<*const ()>,
1999}
2000unsafe impl Send for SPIS3_S {}
2001impl SPIS3_S {
2002 #[doc = r"Pointer to the register block"]
2003 pub const PTR: *const spis0_ns::RegisterBlock = 0x5000_c000 as *const _;
2004 #[doc = r"Return the pointer to the register block"]
2005 #[inline(always)]
2006 pub const fn ptr() -> *const spis0_ns::RegisterBlock {
2007 Self::PTR
2008 }
2009}
2010impl Deref for SPIS3_S {
2011 type Target = spis0_ns::RegisterBlock;
2012 #[inline(always)]
2013 fn deref(&self) -> &Self::Target {
2014 unsafe { &*Self::PTR }
2015 }
2016}
2017impl core::fmt::Debug for SPIS3_S {
2018 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2019 f.debug_struct("SPIS3_S").finish()
2020 }
2021}
2022#[doc = "SPI Slave 7"]
2023pub use spis0_ns as spis3_s;
2024#[doc = "I2C compatible Two-Wire Master Interface with EasyDMA 7"]
2025pub struct TWIM3_S {
2026 _marker: PhantomData<*const ()>,
2027}
2028unsafe impl Send for TWIM3_S {}
2029impl TWIM3_S {
2030 #[doc = r"Pointer to the register block"]
2031 pub const PTR: *const twim0_ns::RegisterBlock = 0x5000_c000 as *const _;
2032 #[doc = r"Return the pointer to the register block"]
2033 #[inline(always)]
2034 pub const fn ptr() -> *const twim0_ns::RegisterBlock {
2035 Self::PTR
2036 }
2037}
2038impl Deref for TWIM3_S {
2039 type Target = twim0_ns::RegisterBlock;
2040 #[inline(always)]
2041 fn deref(&self) -> &Self::Target {
2042 unsafe { &*Self::PTR }
2043 }
2044}
2045impl core::fmt::Debug for TWIM3_S {
2046 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2047 f.debug_struct("TWIM3_S").finish()
2048 }
2049}
2050#[doc = "I2C compatible Two-Wire Master Interface with EasyDMA 7"]
2051pub use twim0_ns as twim3_s;
2052#[doc = "I2C compatible Two-Wire Slave Interface with EasyDMA 7"]
2053pub struct TWIS3_S {
2054 _marker: PhantomData<*const ()>,
2055}
2056unsafe impl Send for TWIS3_S {}
2057impl TWIS3_S {
2058 #[doc = r"Pointer to the register block"]
2059 pub const PTR: *const twis0_ns::RegisterBlock = 0x5000_c000 as *const _;
2060 #[doc = r"Return the pointer to the register block"]
2061 #[inline(always)]
2062 pub const fn ptr() -> *const twis0_ns::RegisterBlock {
2063 Self::PTR
2064 }
2065}
2066impl Deref for TWIS3_S {
2067 type Target = twis0_ns::RegisterBlock;
2068 #[inline(always)]
2069 fn deref(&self) -> &Self::Target {
2070 unsafe { &*Self::PTR }
2071 }
2072}
2073impl core::fmt::Debug for TWIS3_S {
2074 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2075 f.debug_struct("TWIS3_S").finish()
2076 }
2077}
2078#[doc = "I2C compatible Two-Wire Slave Interface with EasyDMA 7"]
2079pub use twis0_ns as twis3_s;
2080#[doc = "UART with EasyDMA 7"]
2081pub struct UARTE3_S {
2082 _marker: PhantomData<*const ()>,
2083}
2084unsafe impl Send for UARTE3_S {}
2085impl UARTE3_S {
2086 #[doc = r"Pointer to the register block"]
2087 pub const PTR: *const uarte0_ns::RegisterBlock = 0x5000_c000 as *const _;
2088 #[doc = r"Return the pointer to the register block"]
2089 #[inline(always)]
2090 pub const fn ptr() -> *const uarte0_ns::RegisterBlock {
2091 Self::PTR
2092 }
2093}
2094impl Deref for UARTE3_S {
2095 type Target = uarte0_ns::RegisterBlock;
2096 #[inline(always)]
2097 fn deref(&self) -> &Self::Target {
2098 unsafe { &*Self::PTR }
2099 }
2100}
2101impl core::fmt::Debug for UARTE3_S {
2102 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2103 f.debug_struct("UARTE3_S").finish()
2104 }
2105}
2106#[doc = "UART with EasyDMA 7"]
2107pub use uarte0_ns as uarte3_s;
2108#[doc = "GPIO Tasks and Events 0"]
2109pub struct GPIOTE0_S {
2110 _marker: PhantomData<*const ()>,
2111}
2112unsafe impl Send for GPIOTE0_S {}
2113impl GPIOTE0_S {
2114 #[doc = r"Pointer to the register block"]
2115 pub const PTR: *const gpiote0_s::RegisterBlock = 0x5000_d000 as *const _;
2116 #[doc = r"Return the pointer to the register block"]
2117 #[inline(always)]
2118 pub const fn ptr() -> *const gpiote0_s::RegisterBlock {
2119 Self::PTR
2120 }
2121}
2122impl Deref for GPIOTE0_S {
2123 type Target = gpiote0_s::RegisterBlock;
2124 #[inline(always)]
2125 fn deref(&self) -> &Self::Target {
2126 unsafe { &*Self::PTR }
2127 }
2128}
2129impl core::fmt::Debug for GPIOTE0_S {
2130 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2131 f.debug_struct("GPIOTE0_S").finish()
2132 }
2133}
2134#[doc = "GPIO Tasks and Events 0"]
2135pub mod gpiote0_s;
2136#[doc = "Analog to Digital Converter 0"]
2137pub struct SAADC_NS {
2138 _marker: PhantomData<*const ()>,
2139}
2140unsafe impl Send for SAADC_NS {}
2141impl SAADC_NS {
2142 #[doc = r"Pointer to the register block"]
2143 pub const PTR: *const saadc_ns::RegisterBlock = 0x4000_e000 as *const _;
2144 #[doc = r"Return the pointer to the register block"]
2145 #[inline(always)]
2146 pub const fn ptr() -> *const saadc_ns::RegisterBlock {
2147 Self::PTR
2148 }
2149}
2150impl Deref for SAADC_NS {
2151 type Target = saadc_ns::RegisterBlock;
2152 #[inline(always)]
2153 fn deref(&self) -> &Self::Target {
2154 unsafe { &*Self::PTR }
2155 }
2156}
2157impl core::fmt::Debug for SAADC_NS {
2158 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2159 f.debug_struct("SAADC_NS").finish()
2160 }
2161}
2162#[doc = "Analog to Digital Converter 0"]
2163pub mod saadc_ns;
2164#[doc = "Analog to Digital Converter 1"]
2165pub struct SAADC_S {
2166 _marker: PhantomData<*const ()>,
2167}
2168unsafe impl Send for SAADC_S {}
2169impl SAADC_S {
2170 #[doc = r"Pointer to the register block"]
2171 pub const PTR: *const saadc_ns::RegisterBlock = 0x5000_e000 as *const _;
2172 #[doc = r"Return the pointer to the register block"]
2173 #[inline(always)]
2174 pub const fn ptr() -> *const saadc_ns::RegisterBlock {
2175 Self::PTR
2176 }
2177}
2178impl Deref for SAADC_S {
2179 type Target = saadc_ns::RegisterBlock;
2180 #[inline(always)]
2181 fn deref(&self) -> &Self::Target {
2182 unsafe { &*Self::PTR }
2183 }
2184}
2185impl core::fmt::Debug for SAADC_S {
2186 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2187 f.debug_struct("SAADC_S").finish()
2188 }
2189}
2190#[doc = "Analog to Digital Converter 1"]
2191pub use saadc_ns as saadc_s;
2192#[doc = "Timer/Counter 0"]
2193pub struct TIMER0_NS {
2194 _marker: PhantomData<*const ()>,
2195}
2196unsafe impl Send for TIMER0_NS {}
2197impl TIMER0_NS {
2198 #[doc = r"Pointer to the register block"]
2199 pub const PTR: *const timer0_ns::RegisterBlock = 0x4000_f000 as *const _;
2200 #[doc = r"Return the pointer to the register block"]
2201 #[inline(always)]
2202 pub const fn ptr() -> *const timer0_ns::RegisterBlock {
2203 Self::PTR
2204 }
2205}
2206impl Deref for TIMER0_NS {
2207 type Target = timer0_ns::RegisterBlock;
2208 #[inline(always)]
2209 fn deref(&self) -> &Self::Target {
2210 unsafe { &*Self::PTR }
2211 }
2212}
2213impl core::fmt::Debug for TIMER0_NS {
2214 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2215 f.debug_struct("TIMER0_NS").finish()
2216 }
2217}
2218#[doc = "Timer/Counter 0"]
2219pub mod timer0_ns;
2220#[doc = "Timer/Counter 1"]
2221pub struct TIMER0_S {
2222 _marker: PhantomData<*const ()>,
2223}
2224unsafe impl Send for TIMER0_S {}
2225impl TIMER0_S {
2226 #[doc = r"Pointer to the register block"]
2227 pub const PTR: *const timer0_ns::RegisterBlock = 0x5000_f000 as *const _;
2228 #[doc = r"Return the pointer to the register block"]
2229 #[inline(always)]
2230 pub const fn ptr() -> *const timer0_ns::RegisterBlock {
2231 Self::PTR
2232 }
2233}
2234impl Deref for TIMER0_S {
2235 type Target = timer0_ns::RegisterBlock;
2236 #[inline(always)]
2237 fn deref(&self) -> &Self::Target {
2238 unsafe { &*Self::PTR }
2239 }
2240}
2241impl core::fmt::Debug for TIMER0_S {
2242 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2243 f.debug_struct("TIMER0_S").finish()
2244 }
2245}
2246#[doc = "Timer/Counter 1"]
2247pub use timer0_ns as timer0_s;
2248#[doc = "Timer/Counter 2"]
2249pub struct TIMER1_NS {
2250 _marker: PhantomData<*const ()>,
2251}
2252unsafe impl Send for TIMER1_NS {}
2253impl TIMER1_NS {
2254 #[doc = r"Pointer to the register block"]
2255 pub const PTR: *const timer0_ns::RegisterBlock = 0x4001_0000 as *const _;
2256 #[doc = r"Return the pointer to the register block"]
2257 #[inline(always)]
2258 pub const fn ptr() -> *const timer0_ns::RegisterBlock {
2259 Self::PTR
2260 }
2261}
2262impl Deref for TIMER1_NS {
2263 type Target = timer0_ns::RegisterBlock;
2264 #[inline(always)]
2265 fn deref(&self) -> &Self::Target {
2266 unsafe { &*Self::PTR }
2267 }
2268}
2269impl core::fmt::Debug for TIMER1_NS {
2270 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2271 f.debug_struct("TIMER1_NS").finish()
2272 }
2273}
2274#[doc = "Timer/Counter 2"]
2275pub use timer0_ns as timer1_ns;
2276#[doc = "Timer/Counter 3"]
2277pub struct TIMER1_S {
2278 _marker: PhantomData<*const ()>,
2279}
2280unsafe impl Send for TIMER1_S {}
2281impl TIMER1_S {
2282 #[doc = r"Pointer to the register block"]
2283 pub const PTR: *const timer0_ns::RegisterBlock = 0x5001_0000 as *const _;
2284 #[doc = r"Return the pointer to the register block"]
2285 #[inline(always)]
2286 pub const fn ptr() -> *const timer0_ns::RegisterBlock {
2287 Self::PTR
2288 }
2289}
2290impl Deref for TIMER1_S {
2291 type Target = timer0_ns::RegisterBlock;
2292 #[inline(always)]
2293 fn deref(&self) -> &Self::Target {
2294 unsafe { &*Self::PTR }
2295 }
2296}
2297impl core::fmt::Debug for TIMER1_S {
2298 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2299 f.debug_struct("TIMER1_S").finish()
2300 }
2301}
2302#[doc = "Timer/Counter 3"]
2303pub use timer0_ns as timer1_s;
2304#[doc = "Timer/Counter 4"]
2305pub struct TIMER2_NS {
2306 _marker: PhantomData<*const ()>,
2307}
2308unsafe impl Send for TIMER2_NS {}
2309impl TIMER2_NS {
2310 #[doc = r"Pointer to the register block"]
2311 pub const PTR: *const timer0_ns::RegisterBlock = 0x4001_1000 as *const _;
2312 #[doc = r"Return the pointer to the register block"]
2313 #[inline(always)]
2314 pub const fn ptr() -> *const timer0_ns::RegisterBlock {
2315 Self::PTR
2316 }
2317}
2318impl Deref for TIMER2_NS {
2319 type Target = timer0_ns::RegisterBlock;
2320 #[inline(always)]
2321 fn deref(&self) -> &Self::Target {
2322 unsafe { &*Self::PTR }
2323 }
2324}
2325impl core::fmt::Debug for TIMER2_NS {
2326 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2327 f.debug_struct("TIMER2_NS").finish()
2328 }
2329}
2330#[doc = "Timer/Counter 4"]
2331pub use timer0_ns as timer2_ns;
2332#[doc = "Timer/Counter 5"]
2333pub struct TIMER2_S {
2334 _marker: PhantomData<*const ()>,
2335}
2336unsafe impl Send for TIMER2_S {}
2337impl TIMER2_S {
2338 #[doc = r"Pointer to the register block"]
2339 pub const PTR: *const timer0_ns::RegisterBlock = 0x5001_1000 as *const _;
2340 #[doc = r"Return the pointer to the register block"]
2341 #[inline(always)]
2342 pub const fn ptr() -> *const timer0_ns::RegisterBlock {
2343 Self::PTR
2344 }
2345}
2346impl Deref for TIMER2_S {
2347 type Target = timer0_ns::RegisterBlock;
2348 #[inline(always)]
2349 fn deref(&self) -> &Self::Target {
2350 unsafe { &*Self::PTR }
2351 }
2352}
2353impl core::fmt::Debug for TIMER2_S {
2354 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2355 f.debug_struct("TIMER2_S").finish()
2356 }
2357}
2358#[doc = "Timer/Counter 5"]
2359pub use timer0_ns as timer2_s;
2360#[doc = "Real-time counter 0"]
2361pub struct RTC0_NS {
2362 _marker: PhantomData<*const ()>,
2363}
2364unsafe impl Send for RTC0_NS {}
2365impl RTC0_NS {
2366 #[doc = r"Pointer to the register block"]
2367 pub const PTR: *const rtc0_ns::RegisterBlock = 0x4001_4000 as *const _;
2368 #[doc = r"Return the pointer to the register block"]
2369 #[inline(always)]
2370 pub const fn ptr() -> *const rtc0_ns::RegisterBlock {
2371 Self::PTR
2372 }
2373}
2374impl Deref for RTC0_NS {
2375 type Target = rtc0_ns::RegisterBlock;
2376 #[inline(always)]
2377 fn deref(&self) -> &Self::Target {
2378 unsafe { &*Self::PTR }
2379 }
2380}
2381impl core::fmt::Debug for RTC0_NS {
2382 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2383 f.debug_struct("RTC0_NS").finish()
2384 }
2385}
2386#[doc = "Real-time counter 0"]
2387pub mod rtc0_ns;
2388#[doc = "Real-time counter 1"]
2389pub struct RTC0_S {
2390 _marker: PhantomData<*const ()>,
2391}
2392unsafe impl Send for RTC0_S {}
2393impl RTC0_S {
2394 #[doc = r"Pointer to the register block"]
2395 pub const PTR: *const rtc0_ns::RegisterBlock = 0x5001_4000 as *const _;
2396 #[doc = r"Return the pointer to the register block"]
2397 #[inline(always)]
2398 pub const fn ptr() -> *const rtc0_ns::RegisterBlock {
2399 Self::PTR
2400 }
2401}
2402impl Deref for RTC0_S {
2403 type Target = rtc0_ns::RegisterBlock;
2404 #[inline(always)]
2405 fn deref(&self) -> &Self::Target {
2406 unsafe { &*Self::PTR }
2407 }
2408}
2409impl core::fmt::Debug for RTC0_S {
2410 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2411 f.debug_struct("RTC0_S").finish()
2412 }
2413}
2414#[doc = "Real-time counter 1"]
2415pub use rtc0_ns as rtc0_s;
2416#[doc = "Real-time counter 2"]
2417pub struct RTC1_NS {
2418 _marker: PhantomData<*const ()>,
2419}
2420unsafe impl Send for RTC1_NS {}
2421impl RTC1_NS {
2422 #[doc = r"Pointer to the register block"]
2423 pub const PTR: *const rtc0_ns::RegisterBlock = 0x4001_5000 as *const _;
2424 #[doc = r"Return the pointer to the register block"]
2425 #[inline(always)]
2426 pub const fn ptr() -> *const rtc0_ns::RegisterBlock {
2427 Self::PTR
2428 }
2429}
2430impl Deref for RTC1_NS {
2431 type Target = rtc0_ns::RegisterBlock;
2432 #[inline(always)]
2433 fn deref(&self) -> &Self::Target {
2434 unsafe { &*Self::PTR }
2435 }
2436}
2437impl core::fmt::Debug for RTC1_NS {
2438 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2439 f.debug_struct("RTC1_NS").finish()
2440 }
2441}
2442#[doc = "Real-time counter 2"]
2443pub use rtc0_ns as rtc1_ns;
2444#[doc = "Real-time counter 3"]
2445pub struct RTC1_S {
2446 _marker: PhantomData<*const ()>,
2447}
2448unsafe impl Send for RTC1_S {}
2449impl RTC1_S {
2450 #[doc = r"Pointer to the register block"]
2451 pub const PTR: *const rtc0_ns::RegisterBlock = 0x5001_5000 as *const _;
2452 #[doc = r"Return the pointer to the register block"]
2453 #[inline(always)]
2454 pub const fn ptr() -> *const rtc0_ns::RegisterBlock {
2455 Self::PTR
2456 }
2457}
2458impl Deref for RTC1_S {
2459 type Target = rtc0_ns::RegisterBlock;
2460 #[inline(always)]
2461 fn deref(&self) -> &Self::Target {
2462 unsafe { &*Self::PTR }
2463 }
2464}
2465impl core::fmt::Debug for RTC1_S {
2466 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2467 f.debug_struct("RTC1_S").finish()
2468 }
2469}
2470#[doc = "Real-time counter 3"]
2471pub use rtc0_ns as rtc1_s;
2472#[doc = "Distributed programmable peripheral interconnect controller 0"]
2473pub struct DPPIC_NS {
2474 _marker: PhantomData<*const ()>,
2475}
2476unsafe impl Send for DPPIC_NS {}
2477impl DPPIC_NS {
2478 #[doc = r"Pointer to the register block"]
2479 pub const PTR: *const dppic_ns::RegisterBlock = 0x4001_7000 as *const _;
2480 #[doc = r"Return the pointer to the register block"]
2481 #[inline(always)]
2482 pub const fn ptr() -> *const dppic_ns::RegisterBlock {
2483 Self::PTR
2484 }
2485}
2486impl Deref for DPPIC_NS {
2487 type Target = dppic_ns::RegisterBlock;
2488 #[inline(always)]
2489 fn deref(&self) -> &Self::Target {
2490 unsafe { &*Self::PTR }
2491 }
2492}
2493impl core::fmt::Debug for DPPIC_NS {
2494 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2495 f.debug_struct("DPPIC_NS").finish()
2496 }
2497}
2498#[doc = "Distributed programmable peripheral interconnect controller 0"]
2499pub mod dppic_ns;
2500#[doc = "Distributed programmable peripheral interconnect controller 1"]
2501pub struct DPPIC_S {
2502 _marker: PhantomData<*const ()>,
2503}
2504unsafe impl Send for DPPIC_S {}
2505impl DPPIC_S {
2506 #[doc = r"Pointer to the register block"]
2507 pub const PTR: *const dppic_ns::RegisterBlock = 0x5001_7000 as *const _;
2508 #[doc = r"Return the pointer to the register block"]
2509 #[inline(always)]
2510 pub const fn ptr() -> *const dppic_ns::RegisterBlock {
2511 Self::PTR
2512 }
2513}
2514impl Deref for DPPIC_S {
2515 type Target = dppic_ns::RegisterBlock;
2516 #[inline(always)]
2517 fn deref(&self) -> &Self::Target {
2518 unsafe { &*Self::PTR }
2519 }
2520}
2521impl core::fmt::Debug for DPPIC_S {
2522 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2523 f.debug_struct("DPPIC_S").finish()
2524 }
2525}
2526#[doc = "Distributed programmable peripheral interconnect controller 1"]
2527pub use dppic_ns as dppic_s;
2528#[doc = "Watchdog Timer 0"]
2529pub struct WDT0_NS {
2530 _marker: PhantomData<*const ()>,
2531}
2532unsafe impl Send for WDT0_NS {}
2533impl WDT0_NS {
2534 #[doc = r"Pointer to the register block"]
2535 pub const PTR: *const wdt0_ns::RegisterBlock = 0x4001_8000 as *const _;
2536 #[doc = r"Return the pointer to the register block"]
2537 #[inline(always)]
2538 pub const fn ptr() -> *const wdt0_ns::RegisterBlock {
2539 Self::PTR
2540 }
2541}
2542impl Deref for WDT0_NS {
2543 type Target = wdt0_ns::RegisterBlock;
2544 #[inline(always)]
2545 fn deref(&self) -> &Self::Target {
2546 unsafe { &*Self::PTR }
2547 }
2548}
2549impl core::fmt::Debug for WDT0_NS {
2550 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2551 f.debug_struct("WDT0_NS").finish()
2552 }
2553}
2554#[doc = "Watchdog Timer 0"]
2555pub mod wdt0_ns;
2556#[doc = "Watchdog Timer 1"]
2557pub struct WDT0_S {
2558 _marker: PhantomData<*const ()>,
2559}
2560unsafe impl Send for WDT0_S {}
2561impl WDT0_S {
2562 #[doc = r"Pointer to the register block"]
2563 pub const PTR: *const wdt0_ns::RegisterBlock = 0x5001_8000 as *const _;
2564 #[doc = r"Return the pointer to the register block"]
2565 #[inline(always)]
2566 pub const fn ptr() -> *const wdt0_ns::RegisterBlock {
2567 Self::PTR
2568 }
2569}
2570impl Deref for WDT0_S {
2571 type Target = wdt0_ns::RegisterBlock;
2572 #[inline(always)]
2573 fn deref(&self) -> &Self::Target {
2574 unsafe { &*Self::PTR }
2575 }
2576}
2577impl core::fmt::Debug for WDT0_S {
2578 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2579 f.debug_struct("WDT0_S").finish()
2580 }
2581}
2582#[doc = "Watchdog Timer 1"]
2583pub use wdt0_ns as wdt0_s;
2584#[doc = "Watchdog Timer 2"]
2585pub struct WDT1_NS {
2586 _marker: PhantomData<*const ()>,
2587}
2588unsafe impl Send for WDT1_NS {}
2589impl WDT1_NS {
2590 #[doc = r"Pointer to the register block"]
2591 pub const PTR: *const wdt0_ns::RegisterBlock = 0x4001_9000 as *const _;
2592 #[doc = r"Return the pointer to the register block"]
2593 #[inline(always)]
2594 pub const fn ptr() -> *const wdt0_ns::RegisterBlock {
2595 Self::PTR
2596 }
2597}
2598impl Deref for WDT1_NS {
2599 type Target = wdt0_ns::RegisterBlock;
2600 #[inline(always)]
2601 fn deref(&self) -> &Self::Target {
2602 unsafe { &*Self::PTR }
2603 }
2604}
2605impl core::fmt::Debug for WDT1_NS {
2606 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2607 f.debug_struct("WDT1_NS").finish()
2608 }
2609}
2610#[doc = "Watchdog Timer 2"]
2611pub use wdt0_ns as wdt1_ns;
2612#[doc = "Watchdog Timer 3"]
2613pub struct WDT1_S {
2614 _marker: PhantomData<*const ()>,
2615}
2616unsafe impl Send for WDT1_S {}
2617impl WDT1_S {
2618 #[doc = r"Pointer to the register block"]
2619 pub const PTR: *const wdt0_ns::RegisterBlock = 0x5001_9000 as *const _;
2620 #[doc = r"Return the pointer to the register block"]
2621 #[inline(always)]
2622 pub const fn ptr() -> *const wdt0_ns::RegisterBlock {
2623 Self::PTR
2624 }
2625}
2626impl Deref for WDT1_S {
2627 type Target = wdt0_ns::RegisterBlock;
2628 #[inline(always)]
2629 fn deref(&self) -> &Self::Target {
2630 unsafe { &*Self::PTR }
2631 }
2632}
2633impl core::fmt::Debug for WDT1_S {
2634 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2635 f.debug_struct("WDT1_S").finish()
2636 }
2637}
2638#[doc = "Watchdog Timer 3"]
2639pub use wdt0_ns as wdt1_s;
2640#[doc = "Comparator 0"]
2641pub struct COMP_NS {
2642 _marker: PhantomData<*const ()>,
2643}
2644unsafe impl Send for COMP_NS {}
2645impl COMP_NS {
2646 #[doc = r"Pointer to the register block"]
2647 pub const PTR: *const comp_ns::RegisterBlock = 0x4001_a000 as *const _;
2648 #[doc = r"Return the pointer to the register block"]
2649 #[inline(always)]
2650 pub const fn ptr() -> *const comp_ns::RegisterBlock {
2651 Self::PTR
2652 }
2653}
2654impl Deref for COMP_NS {
2655 type Target = comp_ns::RegisterBlock;
2656 #[inline(always)]
2657 fn deref(&self) -> &Self::Target {
2658 unsafe { &*Self::PTR }
2659 }
2660}
2661impl core::fmt::Debug for COMP_NS {
2662 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2663 f.debug_struct("COMP_NS").finish()
2664 }
2665}
2666#[doc = "Comparator 0"]
2667pub mod comp_ns;
2668#[doc = "Low-power comparator 0"]
2669pub struct LPCOMP_NS {
2670 _marker: PhantomData<*const ()>,
2671}
2672unsafe impl Send for LPCOMP_NS {}
2673impl LPCOMP_NS {
2674 #[doc = r"Pointer to the register block"]
2675 pub const PTR: *const lpcomp_ns::RegisterBlock = 0x4001_a000 as *const _;
2676 #[doc = r"Return the pointer to the register block"]
2677 #[inline(always)]
2678 pub const fn ptr() -> *const lpcomp_ns::RegisterBlock {
2679 Self::PTR
2680 }
2681}
2682impl Deref for LPCOMP_NS {
2683 type Target = lpcomp_ns::RegisterBlock;
2684 #[inline(always)]
2685 fn deref(&self) -> &Self::Target {
2686 unsafe { &*Self::PTR }
2687 }
2688}
2689impl core::fmt::Debug for LPCOMP_NS {
2690 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2691 f.debug_struct("LPCOMP_NS").finish()
2692 }
2693}
2694#[doc = "Low-power comparator 0"]
2695pub mod lpcomp_ns;
2696#[doc = "Comparator 1"]
2697pub struct COMP_S {
2698 _marker: PhantomData<*const ()>,
2699}
2700unsafe impl Send for COMP_S {}
2701impl COMP_S {
2702 #[doc = r"Pointer to the register block"]
2703 pub const PTR: *const comp_ns::RegisterBlock = 0x5001_a000 as *const _;
2704 #[doc = r"Return the pointer to the register block"]
2705 #[inline(always)]
2706 pub const fn ptr() -> *const comp_ns::RegisterBlock {
2707 Self::PTR
2708 }
2709}
2710impl Deref for COMP_S {
2711 type Target = comp_ns::RegisterBlock;
2712 #[inline(always)]
2713 fn deref(&self) -> &Self::Target {
2714 unsafe { &*Self::PTR }
2715 }
2716}
2717impl core::fmt::Debug for COMP_S {
2718 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2719 f.debug_struct("COMP_S").finish()
2720 }
2721}
2722#[doc = "Comparator 1"]
2723pub use comp_ns as comp_s;
2724#[doc = "Low-power comparator 1"]
2725pub struct LPCOMP_S {
2726 _marker: PhantomData<*const ()>,
2727}
2728unsafe impl Send for LPCOMP_S {}
2729impl LPCOMP_S {
2730 #[doc = r"Pointer to the register block"]
2731 pub const PTR: *const lpcomp_ns::RegisterBlock = 0x5001_a000 as *const _;
2732 #[doc = r"Return the pointer to the register block"]
2733 #[inline(always)]
2734 pub const fn ptr() -> *const lpcomp_ns::RegisterBlock {
2735 Self::PTR
2736 }
2737}
2738impl Deref for LPCOMP_S {
2739 type Target = lpcomp_ns::RegisterBlock;
2740 #[inline(always)]
2741 fn deref(&self) -> &Self::Target {
2742 unsafe { &*Self::PTR }
2743 }
2744}
2745impl core::fmt::Debug for LPCOMP_S {
2746 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2747 f.debug_struct("LPCOMP_S").finish()
2748 }
2749}
2750#[doc = "Low-power comparator 1"]
2751pub use lpcomp_ns as lpcomp_s;
2752#[doc = "Event generator unit 0"]
2753pub struct EGU0_NS {
2754 _marker: PhantomData<*const ()>,
2755}
2756unsafe impl Send for EGU0_NS {}
2757impl EGU0_NS {
2758 #[doc = r"Pointer to the register block"]
2759 pub const PTR: *const egu0_ns::RegisterBlock = 0x4001_b000 as *const _;
2760 #[doc = r"Return the pointer to the register block"]
2761 #[inline(always)]
2762 pub const fn ptr() -> *const egu0_ns::RegisterBlock {
2763 Self::PTR
2764 }
2765}
2766impl Deref for EGU0_NS {
2767 type Target = egu0_ns::RegisterBlock;
2768 #[inline(always)]
2769 fn deref(&self) -> &Self::Target {
2770 unsafe { &*Self::PTR }
2771 }
2772}
2773impl core::fmt::Debug for EGU0_NS {
2774 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2775 f.debug_struct("EGU0_NS").finish()
2776 }
2777}
2778#[doc = "Event generator unit 0"]
2779pub mod egu0_ns;
2780#[doc = "Event generator unit 1"]
2781pub struct EGU0_S {
2782 _marker: PhantomData<*const ()>,
2783}
2784unsafe impl Send for EGU0_S {}
2785impl EGU0_S {
2786 #[doc = r"Pointer to the register block"]
2787 pub const PTR: *const egu0_ns::RegisterBlock = 0x5001_b000 as *const _;
2788 #[doc = r"Return the pointer to the register block"]
2789 #[inline(always)]
2790 pub const fn ptr() -> *const egu0_ns::RegisterBlock {
2791 Self::PTR
2792 }
2793}
2794impl Deref for EGU0_S {
2795 type Target = egu0_ns::RegisterBlock;
2796 #[inline(always)]
2797 fn deref(&self) -> &Self::Target {
2798 unsafe { &*Self::PTR }
2799 }
2800}
2801impl core::fmt::Debug for EGU0_S {
2802 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2803 f.debug_struct("EGU0_S").finish()
2804 }
2805}
2806#[doc = "Event generator unit 1"]
2807pub use egu0_ns as egu0_s;
2808#[doc = "Event generator unit 2"]
2809pub struct EGU1_NS {
2810 _marker: PhantomData<*const ()>,
2811}
2812unsafe impl Send for EGU1_NS {}
2813impl EGU1_NS {
2814 #[doc = r"Pointer to the register block"]
2815 pub const PTR: *const egu0_ns::RegisterBlock = 0x4001_c000 as *const _;
2816 #[doc = r"Return the pointer to the register block"]
2817 #[inline(always)]
2818 pub const fn ptr() -> *const egu0_ns::RegisterBlock {
2819 Self::PTR
2820 }
2821}
2822impl Deref for EGU1_NS {
2823 type Target = egu0_ns::RegisterBlock;
2824 #[inline(always)]
2825 fn deref(&self) -> &Self::Target {
2826 unsafe { &*Self::PTR }
2827 }
2828}
2829impl core::fmt::Debug for EGU1_NS {
2830 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2831 f.debug_struct("EGU1_NS").finish()
2832 }
2833}
2834#[doc = "Event generator unit 2"]
2835pub use egu0_ns as egu1_ns;
2836#[doc = "Event generator unit 3"]
2837pub struct EGU1_S {
2838 _marker: PhantomData<*const ()>,
2839}
2840unsafe impl Send for EGU1_S {}
2841impl EGU1_S {
2842 #[doc = r"Pointer to the register block"]
2843 pub const PTR: *const egu0_ns::RegisterBlock = 0x5001_c000 as *const _;
2844 #[doc = r"Return the pointer to the register block"]
2845 #[inline(always)]
2846 pub const fn ptr() -> *const egu0_ns::RegisterBlock {
2847 Self::PTR
2848 }
2849}
2850impl Deref for EGU1_S {
2851 type Target = egu0_ns::RegisterBlock;
2852 #[inline(always)]
2853 fn deref(&self) -> &Self::Target {
2854 unsafe { &*Self::PTR }
2855 }
2856}
2857impl core::fmt::Debug for EGU1_S {
2858 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2859 f.debug_struct("EGU1_S").finish()
2860 }
2861}
2862#[doc = "Event generator unit 3"]
2863pub use egu0_ns as egu1_s;
2864#[doc = "Event generator unit 4"]
2865pub struct EGU2_NS {
2866 _marker: PhantomData<*const ()>,
2867}
2868unsafe impl Send for EGU2_NS {}
2869impl EGU2_NS {
2870 #[doc = r"Pointer to the register block"]
2871 pub const PTR: *const egu0_ns::RegisterBlock = 0x4001_d000 as *const _;
2872 #[doc = r"Return the pointer to the register block"]
2873 #[inline(always)]
2874 pub const fn ptr() -> *const egu0_ns::RegisterBlock {
2875 Self::PTR
2876 }
2877}
2878impl Deref for EGU2_NS {
2879 type Target = egu0_ns::RegisterBlock;
2880 #[inline(always)]
2881 fn deref(&self) -> &Self::Target {
2882 unsafe { &*Self::PTR }
2883 }
2884}
2885impl core::fmt::Debug for EGU2_NS {
2886 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2887 f.debug_struct("EGU2_NS").finish()
2888 }
2889}
2890#[doc = "Event generator unit 4"]
2891pub use egu0_ns as egu2_ns;
2892#[doc = "Event generator unit 5"]
2893pub struct EGU2_S {
2894 _marker: PhantomData<*const ()>,
2895}
2896unsafe impl Send for EGU2_S {}
2897impl EGU2_S {
2898 #[doc = r"Pointer to the register block"]
2899 pub const PTR: *const egu0_ns::RegisterBlock = 0x5001_d000 as *const _;
2900 #[doc = r"Return the pointer to the register block"]
2901 #[inline(always)]
2902 pub const fn ptr() -> *const egu0_ns::RegisterBlock {
2903 Self::PTR
2904 }
2905}
2906impl Deref for EGU2_S {
2907 type Target = egu0_ns::RegisterBlock;
2908 #[inline(always)]
2909 fn deref(&self) -> &Self::Target {
2910 unsafe { &*Self::PTR }
2911 }
2912}
2913impl core::fmt::Debug for EGU2_S {
2914 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2915 f.debug_struct("EGU2_S").finish()
2916 }
2917}
2918#[doc = "Event generator unit 5"]
2919pub use egu0_ns as egu2_s;
2920#[doc = "Event generator unit 6"]
2921pub struct EGU3_NS {
2922 _marker: PhantomData<*const ()>,
2923}
2924unsafe impl Send for EGU3_NS {}
2925impl EGU3_NS {
2926 #[doc = r"Pointer to the register block"]
2927 pub const PTR: *const egu0_ns::RegisterBlock = 0x4001_e000 as *const _;
2928 #[doc = r"Return the pointer to the register block"]
2929 #[inline(always)]
2930 pub const fn ptr() -> *const egu0_ns::RegisterBlock {
2931 Self::PTR
2932 }
2933}
2934impl Deref for EGU3_NS {
2935 type Target = egu0_ns::RegisterBlock;
2936 #[inline(always)]
2937 fn deref(&self) -> &Self::Target {
2938 unsafe { &*Self::PTR }
2939 }
2940}
2941impl core::fmt::Debug for EGU3_NS {
2942 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2943 f.debug_struct("EGU3_NS").finish()
2944 }
2945}
2946#[doc = "Event generator unit 6"]
2947pub use egu0_ns as egu3_ns;
2948#[doc = "Event generator unit 7"]
2949pub struct EGU3_S {
2950 _marker: PhantomData<*const ()>,
2951}
2952unsafe impl Send for EGU3_S {}
2953impl EGU3_S {
2954 #[doc = r"Pointer to the register block"]
2955 pub const PTR: *const egu0_ns::RegisterBlock = 0x5001_e000 as *const _;
2956 #[doc = r"Return the pointer to the register block"]
2957 #[inline(always)]
2958 pub const fn ptr() -> *const egu0_ns::RegisterBlock {
2959 Self::PTR
2960 }
2961}
2962impl Deref for EGU3_S {
2963 type Target = egu0_ns::RegisterBlock;
2964 #[inline(always)]
2965 fn deref(&self) -> &Self::Target {
2966 unsafe { &*Self::PTR }
2967 }
2968}
2969impl core::fmt::Debug for EGU3_S {
2970 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2971 f.debug_struct("EGU3_S").finish()
2972 }
2973}
2974#[doc = "Event generator unit 7"]
2975pub use egu0_ns as egu3_s;
2976#[doc = "Event generator unit 8"]
2977pub struct EGU4_NS {
2978 _marker: PhantomData<*const ()>,
2979}
2980unsafe impl Send for EGU4_NS {}
2981impl EGU4_NS {
2982 #[doc = r"Pointer to the register block"]
2983 pub const PTR: *const egu0_ns::RegisterBlock = 0x4001_f000 as *const _;
2984 #[doc = r"Return the pointer to the register block"]
2985 #[inline(always)]
2986 pub const fn ptr() -> *const egu0_ns::RegisterBlock {
2987 Self::PTR
2988 }
2989}
2990impl Deref for EGU4_NS {
2991 type Target = egu0_ns::RegisterBlock;
2992 #[inline(always)]
2993 fn deref(&self) -> &Self::Target {
2994 unsafe { &*Self::PTR }
2995 }
2996}
2997impl core::fmt::Debug for EGU4_NS {
2998 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2999 f.debug_struct("EGU4_NS").finish()
3000 }
3001}
3002#[doc = "Event generator unit 8"]
3003pub use egu0_ns as egu4_ns;
3004#[doc = "Event generator unit 9"]
3005pub struct EGU4_S {
3006 _marker: PhantomData<*const ()>,
3007}
3008unsafe impl Send for EGU4_S {}
3009impl EGU4_S {
3010 #[doc = r"Pointer to the register block"]
3011 pub const PTR: *const egu0_ns::RegisterBlock = 0x5001_f000 as *const _;
3012 #[doc = r"Return the pointer to the register block"]
3013 #[inline(always)]
3014 pub const fn ptr() -> *const egu0_ns::RegisterBlock {
3015 Self::PTR
3016 }
3017}
3018impl Deref for EGU4_S {
3019 type Target = egu0_ns::RegisterBlock;
3020 #[inline(always)]
3021 fn deref(&self) -> &Self::Target {
3022 unsafe { &*Self::PTR }
3023 }
3024}
3025impl core::fmt::Debug for EGU4_S {
3026 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3027 f.debug_struct("EGU4_S").finish()
3028 }
3029}
3030#[doc = "Event generator unit 9"]
3031pub use egu0_ns as egu4_s;
3032#[doc = "Event generator unit 10"]
3033pub struct EGU5_NS {
3034 _marker: PhantomData<*const ()>,
3035}
3036unsafe impl Send for EGU5_NS {}
3037impl EGU5_NS {
3038 #[doc = r"Pointer to the register block"]
3039 pub const PTR: *const egu0_ns::RegisterBlock = 0x4002_0000 as *const _;
3040 #[doc = r"Return the pointer to the register block"]
3041 #[inline(always)]
3042 pub const fn ptr() -> *const egu0_ns::RegisterBlock {
3043 Self::PTR
3044 }
3045}
3046impl Deref for EGU5_NS {
3047 type Target = egu0_ns::RegisterBlock;
3048 #[inline(always)]
3049 fn deref(&self) -> &Self::Target {
3050 unsafe { &*Self::PTR }
3051 }
3052}
3053impl core::fmt::Debug for EGU5_NS {
3054 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3055 f.debug_struct("EGU5_NS").finish()
3056 }
3057}
3058#[doc = "Event generator unit 10"]
3059pub use egu0_ns as egu5_ns;
3060#[doc = "Event generator unit 11"]
3061pub struct EGU5_S {
3062 _marker: PhantomData<*const ()>,
3063}
3064unsafe impl Send for EGU5_S {}
3065impl EGU5_S {
3066 #[doc = r"Pointer to the register block"]
3067 pub const PTR: *const egu0_ns::RegisterBlock = 0x5002_0000 as *const _;
3068 #[doc = r"Return the pointer to the register block"]
3069 #[inline(always)]
3070 pub const fn ptr() -> *const egu0_ns::RegisterBlock {
3071 Self::PTR
3072 }
3073}
3074impl Deref for EGU5_S {
3075 type Target = egu0_ns::RegisterBlock;
3076 #[inline(always)]
3077 fn deref(&self) -> &Self::Target {
3078 unsafe { &*Self::PTR }
3079 }
3080}
3081impl core::fmt::Debug for EGU5_S {
3082 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3083 f.debug_struct("EGU5_S").finish()
3084 }
3085}
3086#[doc = "Event generator unit 11"]
3087pub use egu0_ns as egu5_s;
3088#[doc = "Pulse width modulation unit 0"]
3089pub struct PWM0_NS {
3090 _marker: PhantomData<*const ()>,
3091}
3092unsafe impl Send for PWM0_NS {}
3093impl PWM0_NS {
3094 #[doc = r"Pointer to the register block"]
3095 pub const PTR: *const pwm0_ns::RegisterBlock = 0x4002_1000 as *const _;
3096 #[doc = r"Return the pointer to the register block"]
3097 #[inline(always)]
3098 pub const fn ptr() -> *const pwm0_ns::RegisterBlock {
3099 Self::PTR
3100 }
3101}
3102impl Deref for PWM0_NS {
3103 type Target = pwm0_ns::RegisterBlock;
3104 #[inline(always)]
3105 fn deref(&self) -> &Self::Target {
3106 unsafe { &*Self::PTR }
3107 }
3108}
3109impl core::fmt::Debug for PWM0_NS {
3110 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3111 f.debug_struct("PWM0_NS").finish()
3112 }
3113}
3114#[doc = "Pulse width modulation unit 0"]
3115pub mod pwm0_ns;
3116#[doc = "Pulse width modulation unit 1"]
3117pub struct PWM0_S {
3118 _marker: PhantomData<*const ()>,
3119}
3120unsafe impl Send for PWM0_S {}
3121impl PWM0_S {
3122 #[doc = r"Pointer to the register block"]
3123 pub const PTR: *const pwm0_ns::RegisterBlock = 0x5002_1000 as *const _;
3124 #[doc = r"Return the pointer to the register block"]
3125 #[inline(always)]
3126 pub const fn ptr() -> *const pwm0_ns::RegisterBlock {
3127 Self::PTR
3128 }
3129}
3130impl Deref for PWM0_S {
3131 type Target = pwm0_ns::RegisterBlock;
3132 #[inline(always)]
3133 fn deref(&self) -> &Self::Target {
3134 unsafe { &*Self::PTR }
3135 }
3136}
3137impl core::fmt::Debug for PWM0_S {
3138 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3139 f.debug_struct("PWM0_S").finish()
3140 }
3141}
3142#[doc = "Pulse width modulation unit 1"]
3143pub use pwm0_ns as pwm0_s;
3144#[doc = "Pulse width modulation unit 2"]
3145pub struct PWM1_NS {
3146 _marker: PhantomData<*const ()>,
3147}
3148unsafe impl Send for PWM1_NS {}
3149impl PWM1_NS {
3150 #[doc = r"Pointer to the register block"]
3151 pub const PTR: *const pwm0_ns::RegisterBlock = 0x4002_2000 as *const _;
3152 #[doc = r"Return the pointer to the register block"]
3153 #[inline(always)]
3154 pub const fn ptr() -> *const pwm0_ns::RegisterBlock {
3155 Self::PTR
3156 }
3157}
3158impl Deref for PWM1_NS {
3159 type Target = pwm0_ns::RegisterBlock;
3160 #[inline(always)]
3161 fn deref(&self) -> &Self::Target {
3162 unsafe { &*Self::PTR }
3163 }
3164}
3165impl core::fmt::Debug for PWM1_NS {
3166 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3167 f.debug_struct("PWM1_NS").finish()
3168 }
3169}
3170#[doc = "Pulse width modulation unit 2"]
3171pub use pwm0_ns as pwm1_ns;
3172#[doc = "Pulse width modulation unit 3"]
3173pub struct PWM1_S {
3174 _marker: PhantomData<*const ()>,
3175}
3176unsafe impl Send for PWM1_S {}
3177impl PWM1_S {
3178 #[doc = r"Pointer to the register block"]
3179 pub const PTR: *const pwm0_ns::RegisterBlock = 0x5002_2000 as *const _;
3180 #[doc = r"Return the pointer to the register block"]
3181 #[inline(always)]
3182 pub const fn ptr() -> *const pwm0_ns::RegisterBlock {
3183 Self::PTR
3184 }
3185}
3186impl Deref for PWM1_S {
3187 type Target = pwm0_ns::RegisterBlock;
3188 #[inline(always)]
3189 fn deref(&self) -> &Self::Target {
3190 unsafe { &*Self::PTR }
3191 }
3192}
3193impl core::fmt::Debug for PWM1_S {
3194 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3195 f.debug_struct("PWM1_S").finish()
3196 }
3197}
3198#[doc = "Pulse width modulation unit 3"]
3199pub use pwm0_ns as pwm1_s;
3200#[doc = "Pulse width modulation unit 4"]
3201pub struct PWM2_NS {
3202 _marker: PhantomData<*const ()>,
3203}
3204unsafe impl Send for PWM2_NS {}
3205impl PWM2_NS {
3206 #[doc = r"Pointer to the register block"]
3207 pub const PTR: *const pwm0_ns::RegisterBlock = 0x4002_3000 as *const _;
3208 #[doc = r"Return the pointer to the register block"]
3209 #[inline(always)]
3210 pub const fn ptr() -> *const pwm0_ns::RegisterBlock {
3211 Self::PTR
3212 }
3213}
3214impl Deref for PWM2_NS {
3215 type Target = pwm0_ns::RegisterBlock;
3216 #[inline(always)]
3217 fn deref(&self) -> &Self::Target {
3218 unsafe { &*Self::PTR }
3219 }
3220}
3221impl core::fmt::Debug for PWM2_NS {
3222 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3223 f.debug_struct("PWM2_NS").finish()
3224 }
3225}
3226#[doc = "Pulse width modulation unit 4"]
3227pub use pwm0_ns as pwm2_ns;
3228#[doc = "Pulse width modulation unit 5"]
3229pub struct PWM2_S {
3230 _marker: PhantomData<*const ()>,
3231}
3232unsafe impl Send for PWM2_S {}
3233impl PWM2_S {
3234 #[doc = r"Pointer to the register block"]
3235 pub const PTR: *const pwm0_ns::RegisterBlock = 0x5002_3000 as *const _;
3236 #[doc = r"Return the pointer to the register block"]
3237 #[inline(always)]
3238 pub const fn ptr() -> *const pwm0_ns::RegisterBlock {
3239 Self::PTR
3240 }
3241}
3242impl Deref for PWM2_S {
3243 type Target = pwm0_ns::RegisterBlock;
3244 #[inline(always)]
3245 fn deref(&self) -> &Self::Target {
3246 unsafe { &*Self::PTR }
3247 }
3248}
3249impl core::fmt::Debug for PWM2_S {
3250 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3251 f.debug_struct("PWM2_S").finish()
3252 }
3253}
3254#[doc = "Pulse width modulation unit 5"]
3255pub use pwm0_ns as pwm2_s;
3256#[doc = "Pulse width modulation unit 6"]
3257pub struct PWM3_NS {
3258 _marker: PhantomData<*const ()>,
3259}
3260unsafe impl Send for PWM3_NS {}
3261impl PWM3_NS {
3262 #[doc = r"Pointer to the register block"]
3263 pub const PTR: *const pwm0_ns::RegisterBlock = 0x4002_4000 as *const _;
3264 #[doc = r"Return the pointer to the register block"]
3265 #[inline(always)]
3266 pub const fn ptr() -> *const pwm0_ns::RegisterBlock {
3267 Self::PTR
3268 }
3269}
3270impl Deref for PWM3_NS {
3271 type Target = pwm0_ns::RegisterBlock;
3272 #[inline(always)]
3273 fn deref(&self) -> &Self::Target {
3274 unsafe { &*Self::PTR }
3275 }
3276}
3277impl core::fmt::Debug for PWM3_NS {
3278 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3279 f.debug_struct("PWM3_NS").finish()
3280 }
3281}
3282#[doc = "Pulse width modulation unit 6"]
3283pub use pwm0_ns as pwm3_ns;
3284#[doc = "Pulse width modulation unit 7"]
3285pub struct PWM3_S {
3286 _marker: PhantomData<*const ()>,
3287}
3288unsafe impl Send for PWM3_S {}
3289impl PWM3_S {
3290 #[doc = r"Pointer to the register block"]
3291 pub const PTR: *const pwm0_ns::RegisterBlock = 0x5002_4000 as *const _;
3292 #[doc = r"Return the pointer to the register block"]
3293 #[inline(always)]
3294 pub const fn ptr() -> *const pwm0_ns::RegisterBlock {
3295 Self::PTR
3296 }
3297}
3298impl Deref for PWM3_S {
3299 type Target = pwm0_ns::RegisterBlock;
3300 #[inline(always)]
3301 fn deref(&self) -> &Self::Target {
3302 unsafe { &*Self::PTR }
3303 }
3304}
3305impl core::fmt::Debug for PWM3_S {
3306 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3307 f.debug_struct("PWM3_S").finish()
3308 }
3309}
3310#[doc = "Pulse width modulation unit 7"]
3311pub use pwm0_ns as pwm3_s;
3312#[doc = "Pulse Density Modulation (Digital Microphone) Interface 0"]
3313pub struct PDM0_NS {
3314 _marker: PhantomData<*const ()>,
3315}
3316unsafe impl Send for PDM0_NS {}
3317impl PDM0_NS {
3318 #[doc = r"Pointer to the register block"]
3319 pub const PTR: *const pdm0_ns::RegisterBlock = 0x4002_6000 as *const _;
3320 #[doc = r"Return the pointer to the register block"]
3321 #[inline(always)]
3322 pub const fn ptr() -> *const pdm0_ns::RegisterBlock {
3323 Self::PTR
3324 }
3325}
3326impl Deref for PDM0_NS {
3327 type Target = pdm0_ns::RegisterBlock;
3328 #[inline(always)]
3329 fn deref(&self) -> &Self::Target {
3330 unsafe { &*Self::PTR }
3331 }
3332}
3333impl core::fmt::Debug for PDM0_NS {
3334 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3335 f.debug_struct("PDM0_NS").finish()
3336 }
3337}
3338#[doc = "Pulse Density Modulation (Digital Microphone) Interface 0"]
3339pub mod pdm0_ns;
3340#[doc = "Pulse Density Modulation (Digital Microphone) Interface 1"]
3341pub struct PDM0_S {
3342 _marker: PhantomData<*const ()>,
3343}
3344unsafe impl Send for PDM0_S {}
3345impl PDM0_S {
3346 #[doc = r"Pointer to the register block"]
3347 pub const PTR: *const pdm0_ns::RegisterBlock = 0x5002_6000 as *const _;
3348 #[doc = r"Return the pointer to the register block"]
3349 #[inline(always)]
3350 pub const fn ptr() -> *const pdm0_ns::RegisterBlock {
3351 Self::PTR
3352 }
3353}
3354impl Deref for PDM0_S {
3355 type Target = pdm0_ns::RegisterBlock;
3356 #[inline(always)]
3357 fn deref(&self) -> &Self::Target {
3358 unsafe { &*Self::PTR }
3359 }
3360}
3361impl core::fmt::Debug for PDM0_S {
3362 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3363 f.debug_struct("PDM0_S").finish()
3364 }
3365}
3366#[doc = "Pulse Density Modulation (Digital Microphone) Interface 1"]
3367pub use pdm0_ns as pdm0_s;
3368#[doc = "Inter-IC Sound 0"]
3369pub struct I2S0_NS {
3370 _marker: PhantomData<*const ()>,
3371}
3372unsafe impl Send for I2S0_NS {}
3373impl I2S0_NS {
3374 #[doc = r"Pointer to the register block"]
3375 pub const PTR: *const i2s0_ns::RegisterBlock = 0x4002_8000 as *const _;
3376 #[doc = r"Return the pointer to the register block"]
3377 #[inline(always)]
3378 pub const fn ptr() -> *const i2s0_ns::RegisterBlock {
3379 Self::PTR
3380 }
3381}
3382impl Deref for I2S0_NS {
3383 type Target = i2s0_ns::RegisterBlock;
3384 #[inline(always)]
3385 fn deref(&self) -> &Self::Target {
3386 unsafe { &*Self::PTR }
3387 }
3388}
3389impl core::fmt::Debug for I2S0_NS {
3390 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3391 f.debug_struct("I2S0_NS").finish()
3392 }
3393}
3394#[doc = "Inter-IC Sound 0"]
3395pub mod i2s0_ns;
3396#[doc = "Inter-IC Sound 1"]
3397pub struct I2S0_S {
3398 _marker: PhantomData<*const ()>,
3399}
3400unsafe impl Send for I2S0_S {}
3401impl I2S0_S {
3402 #[doc = r"Pointer to the register block"]
3403 pub const PTR: *const i2s0_ns::RegisterBlock = 0x5002_8000 as *const _;
3404 #[doc = r"Return the pointer to the register block"]
3405 #[inline(always)]
3406 pub const fn ptr() -> *const i2s0_ns::RegisterBlock {
3407 Self::PTR
3408 }
3409}
3410impl Deref for I2S0_S {
3411 type Target = i2s0_ns::RegisterBlock;
3412 #[inline(always)]
3413 fn deref(&self) -> &Self::Target {
3414 unsafe { &*Self::PTR }
3415 }
3416}
3417impl core::fmt::Debug for I2S0_S {
3418 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3419 f.debug_struct("I2S0_S").finish()
3420 }
3421}
3422#[doc = "Inter-IC Sound 1"]
3423pub use i2s0_ns as i2s0_s;
3424#[doc = "Interprocessor communication 0"]
3425pub struct IPC_NS {
3426 _marker: PhantomData<*const ()>,
3427}
3428unsafe impl Send for IPC_NS {}
3429impl IPC_NS {
3430 #[doc = r"Pointer to the register block"]
3431 pub const PTR: *const ipc_ns::RegisterBlock = 0x4002_a000 as *const _;
3432 #[doc = r"Return the pointer to the register block"]
3433 #[inline(always)]
3434 pub const fn ptr() -> *const ipc_ns::RegisterBlock {
3435 Self::PTR
3436 }
3437}
3438impl Deref for IPC_NS {
3439 type Target = ipc_ns::RegisterBlock;
3440 #[inline(always)]
3441 fn deref(&self) -> &Self::Target {
3442 unsafe { &*Self::PTR }
3443 }
3444}
3445impl core::fmt::Debug for IPC_NS {
3446 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3447 f.debug_struct("IPC_NS").finish()
3448 }
3449}
3450#[doc = "Interprocessor communication 0"]
3451pub mod ipc_ns;
3452#[doc = "Interprocessor communication 1"]
3453pub struct IPC_S {
3454 _marker: PhantomData<*const ()>,
3455}
3456unsafe impl Send for IPC_S {}
3457impl IPC_S {
3458 #[doc = r"Pointer to the register block"]
3459 pub const PTR: *const ipc_ns::RegisterBlock = 0x5002_a000 as *const _;
3460 #[doc = r"Return the pointer to the register block"]
3461 #[inline(always)]
3462 pub const fn ptr() -> *const ipc_ns::RegisterBlock {
3463 Self::PTR
3464 }
3465}
3466impl Deref for IPC_S {
3467 type Target = ipc_ns::RegisterBlock;
3468 #[inline(always)]
3469 fn deref(&self) -> &Self::Target {
3470 unsafe { &*Self::PTR }
3471 }
3472}
3473impl core::fmt::Debug for IPC_S {
3474 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3475 f.debug_struct("IPC_S").finish()
3476 }
3477}
3478#[doc = "Interprocessor communication 1"]
3479pub use ipc_ns as ipc_s;
3480#[doc = "External flash interface 0"]
3481pub struct QSPI_NS {
3482 _marker: PhantomData<*const ()>,
3483}
3484unsafe impl Send for QSPI_NS {}
3485impl QSPI_NS {
3486 #[doc = r"Pointer to the register block"]
3487 pub const PTR: *const qspi_ns::RegisterBlock = 0x4002_b000 as *const _;
3488 #[doc = r"Return the pointer to the register block"]
3489 #[inline(always)]
3490 pub const fn ptr() -> *const qspi_ns::RegisterBlock {
3491 Self::PTR
3492 }
3493}
3494impl Deref for QSPI_NS {
3495 type Target = qspi_ns::RegisterBlock;
3496 #[inline(always)]
3497 fn deref(&self) -> &Self::Target {
3498 unsafe { &*Self::PTR }
3499 }
3500}
3501impl core::fmt::Debug for QSPI_NS {
3502 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3503 f.debug_struct("QSPI_NS").finish()
3504 }
3505}
3506#[doc = "External flash interface 0"]
3507pub mod qspi_ns;
3508#[doc = "External flash interface 1"]
3509pub struct QSPI_S {
3510 _marker: PhantomData<*const ()>,
3511}
3512unsafe impl Send for QSPI_S {}
3513impl QSPI_S {
3514 #[doc = r"Pointer to the register block"]
3515 pub const PTR: *const qspi_ns::RegisterBlock = 0x5002_b000 as *const _;
3516 #[doc = r"Return the pointer to the register block"]
3517 #[inline(always)]
3518 pub const fn ptr() -> *const qspi_ns::RegisterBlock {
3519 Self::PTR
3520 }
3521}
3522impl Deref for QSPI_S {
3523 type Target = qspi_ns::RegisterBlock;
3524 #[inline(always)]
3525 fn deref(&self) -> &Self::Target {
3526 unsafe { &*Self::PTR }
3527 }
3528}
3529impl core::fmt::Debug for QSPI_S {
3530 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3531 f.debug_struct("QSPI_S").finish()
3532 }
3533}
3534#[doc = "External flash interface 1"]
3535pub use qspi_ns as qspi_s;
3536#[doc = "NFC-A compatible radio 0"]
3537pub struct NFCT_NS {
3538 _marker: PhantomData<*const ()>,
3539}
3540unsafe impl Send for NFCT_NS {}
3541impl NFCT_NS {
3542 #[doc = r"Pointer to the register block"]
3543 pub const PTR: *const nfct_ns::RegisterBlock = 0x4002_d000 as *const _;
3544 #[doc = r"Return the pointer to the register block"]
3545 #[inline(always)]
3546 pub const fn ptr() -> *const nfct_ns::RegisterBlock {
3547 Self::PTR
3548 }
3549}
3550impl Deref for NFCT_NS {
3551 type Target = nfct_ns::RegisterBlock;
3552 #[inline(always)]
3553 fn deref(&self) -> &Self::Target {
3554 unsafe { &*Self::PTR }
3555 }
3556}
3557impl core::fmt::Debug for NFCT_NS {
3558 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3559 f.debug_struct("NFCT_NS").finish()
3560 }
3561}
3562#[doc = "NFC-A compatible radio 0"]
3563pub mod nfct_ns;
3564#[doc = "NFC-A compatible radio 1"]
3565pub struct NFCT_S {
3566 _marker: PhantomData<*const ()>,
3567}
3568unsafe impl Send for NFCT_S {}
3569impl NFCT_S {
3570 #[doc = r"Pointer to the register block"]
3571 pub const PTR: *const nfct_ns::RegisterBlock = 0x5002_d000 as *const _;
3572 #[doc = r"Return the pointer to the register block"]
3573 #[inline(always)]
3574 pub const fn ptr() -> *const nfct_ns::RegisterBlock {
3575 Self::PTR
3576 }
3577}
3578impl Deref for NFCT_S {
3579 type Target = nfct_ns::RegisterBlock;
3580 #[inline(always)]
3581 fn deref(&self) -> &Self::Target {
3582 unsafe { &*Self::PTR }
3583 }
3584}
3585impl core::fmt::Debug for NFCT_S {
3586 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3587 f.debug_struct("NFCT_S").finish()
3588 }
3589}
3590#[doc = "NFC-A compatible radio 1"]
3591pub use nfct_ns as nfct_s;
3592#[doc = "GPIO Tasks and Events 1"]
3593pub struct GPIOTE1_NS {
3594 _marker: PhantomData<*const ()>,
3595}
3596unsafe impl Send for GPIOTE1_NS {}
3597impl GPIOTE1_NS {
3598 #[doc = r"Pointer to the register block"]
3599 pub const PTR: *const gpiote0_s::RegisterBlock = 0x4002_f000 as *const _;
3600 #[doc = r"Return the pointer to the register block"]
3601 #[inline(always)]
3602 pub const fn ptr() -> *const gpiote0_s::RegisterBlock {
3603 Self::PTR
3604 }
3605}
3606impl Deref for GPIOTE1_NS {
3607 type Target = gpiote0_s::RegisterBlock;
3608 #[inline(always)]
3609 fn deref(&self) -> &Self::Target {
3610 unsafe { &*Self::PTR }
3611 }
3612}
3613impl core::fmt::Debug for GPIOTE1_NS {
3614 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3615 f.debug_struct("GPIOTE1_NS").finish()
3616 }
3617}
3618#[doc = "GPIO Tasks and Events 1"]
3619pub use gpiote0_s as gpiote1_ns;
3620#[doc = "MUTEX 0"]
3621pub struct MUTEX_NS {
3622 _marker: PhantomData<*const ()>,
3623}
3624unsafe impl Send for MUTEX_NS {}
3625impl MUTEX_NS {
3626 #[doc = r"Pointer to the register block"]
3627 pub const PTR: *const mutex_ns::RegisterBlock = 0x4003_0000 as *const _;
3628 #[doc = r"Return the pointer to the register block"]
3629 #[inline(always)]
3630 pub const fn ptr() -> *const mutex_ns::RegisterBlock {
3631 Self::PTR
3632 }
3633}
3634impl Deref for MUTEX_NS {
3635 type Target = mutex_ns::RegisterBlock;
3636 #[inline(always)]
3637 fn deref(&self) -> &Self::Target {
3638 unsafe { &*Self::PTR }
3639 }
3640}
3641impl core::fmt::Debug for MUTEX_NS {
3642 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3643 f.debug_struct("MUTEX_NS").finish()
3644 }
3645}
3646#[doc = "MUTEX 0"]
3647pub mod mutex_ns;
3648#[doc = "MUTEX 1"]
3649pub struct MUTEX_S {
3650 _marker: PhantomData<*const ()>,
3651}
3652unsafe impl Send for MUTEX_S {}
3653impl MUTEX_S {
3654 #[doc = r"Pointer to the register block"]
3655 pub const PTR: *const mutex_ns::RegisterBlock = 0x5003_0000 as *const _;
3656 #[doc = r"Return the pointer to the register block"]
3657 #[inline(always)]
3658 pub const fn ptr() -> *const mutex_ns::RegisterBlock {
3659 Self::PTR
3660 }
3661}
3662impl Deref for MUTEX_S {
3663 type Target = mutex_ns::RegisterBlock;
3664 #[inline(always)]
3665 fn deref(&self) -> &Self::Target {
3666 unsafe { &*Self::PTR }
3667 }
3668}
3669impl core::fmt::Debug for MUTEX_S {
3670 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3671 f.debug_struct("MUTEX_S").finish()
3672 }
3673}
3674#[doc = "MUTEX 1"]
3675pub use mutex_ns as mutex_s;
3676#[doc = "Quadrature Decoder 0"]
3677pub struct QDEC0_NS {
3678 _marker: PhantomData<*const ()>,
3679}
3680unsafe impl Send for QDEC0_NS {}
3681impl QDEC0_NS {
3682 #[doc = r"Pointer to the register block"]
3683 pub const PTR: *const qdec0_ns::RegisterBlock = 0x4003_3000 as *const _;
3684 #[doc = r"Return the pointer to the register block"]
3685 #[inline(always)]
3686 pub const fn ptr() -> *const qdec0_ns::RegisterBlock {
3687 Self::PTR
3688 }
3689}
3690impl Deref for QDEC0_NS {
3691 type Target = qdec0_ns::RegisterBlock;
3692 #[inline(always)]
3693 fn deref(&self) -> &Self::Target {
3694 unsafe { &*Self::PTR }
3695 }
3696}
3697impl core::fmt::Debug for QDEC0_NS {
3698 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3699 f.debug_struct("QDEC0_NS").finish()
3700 }
3701}
3702#[doc = "Quadrature Decoder 0"]
3703pub mod qdec0_ns;
3704#[doc = "Quadrature Decoder 1"]
3705pub struct QDEC0_S {
3706 _marker: PhantomData<*const ()>,
3707}
3708unsafe impl Send for QDEC0_S {}
3709impl QDEC0_S {
3710 #[doc = r"Pointer to the register block"]
3711 pub const PTR: *const qdec0_ns::RegisterBlock = 0x5003_3000 as *const _;
3712 #[doc = r"Return the pointer to the register block"]
3713 #[inline(always)]
3714 pub const fn ptr() -> *const qdec0_ns::RegisterBlock {
3715 Self::PTR
3716 }
3717}
3718impl Deref for QDEC0_S {
3719 type Target = qdec0_ns::RegisterBlock;
3720 #[inline(always)]
3721 fn deref(&self) -> &Self::Target {
3722 unsafe { &*Self::PTR }
3723 }
3724}
3725impl core::fmt::Debug for QDEC0_S {
3726 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3727 f.debug_struct("QDEC0_S").finish()
3728 }
3729}
3730#[doc = "Quadrature Decoder 1"]
3731pub use qdec0_ns as qdec0_s;
3732#[doc = "Quadrature Decoder 2"]
3733pub struct QDEC1_NS {
3734 _marker: PhantomData<*const ()>,
3735}
3736unsafe impl Send for QDEC1_NS {}
3737impl QDEC1_NS {
3738 #[doc = r"Pointer to the register block"]
3739 pub const PTR: *const qdec0_ns::RegisterBlock = 0x4003_4000 as *const _;
3740 #[doc = r"Return the pointer to the register block"]
3741 #[inline(always)]
3742 pub const fn ptr() -> *const qdec0_ns::RegisterBlock {
3743 Self::PTR
3744 }
3745}
3746impl Deref for QDEC1_NS {
3747 type Target = qdec0_ns::RegisterBlock;
3748 #[inline(always)]
3749 fn deref(&self) -> &Self::Target {
3750 unsafe { &*Self::PTR }
3751 }
3752}
3753impl core::fmt::Debug for QDEC1_NS {
3754 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3755 f.debug_struct("QDEC1_NS").finish()
3756 }
3757}
3758#[doc = "Quadrature Decoder 2"]
3759pub use qdec0_ns as qdec1_ns;
3760#[doc = "Quadrature Decoder 3"]
3761pub struct QDEC1_S {
3762 _marker: PhantomData<*const ()>,
3763}
3764unsafe impl Send for QDEC1_S {}
3765impl QDEC1_S {
3766 #[doc = r"Pointer to the register block"]
3767 pub const PTR: *const qdec0_ns::RegisterBlock = 0x5003_4000 as *const _;
3768 #[doc = r"Return the pointer to the register block"]
3769 #[inline(always)]
3770 pub const fn ptr() -> *const qdec0_ns::RegisterBlock {
3771 Self::PTR
3772 }
3773}
3774impl Deref for QDEC1_S {
3775 type Target = qdec0_ns::RegisterBlock;
3776 #[inline(always)]
3777 fn deref(&self) -> &Self::Target {
3778 unsafe { &*Self::PTR }
3779 }
3780}
3781impl core::fmt::Debug for QDEC1_S {
3782 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3783 f.debug_struct("QDEC1_S").finish()
3784 }
3785}
3786#[doc = "Quadrature Decoder 3"]
3787pub use qdec0_ns as qdec1_s;
3788#[doc = "Universal serial bus device 0"]
3789pub struct USBD_NS {
3790 _marker: PhantomData<*const ()>,
3791}
3792unsafe impl Send for USBD_NS {}
3793impl USBD_NS {
3794 #[doc = r"Pointer to the register block"]
3795 pub const PTR: *const usbd_ns::RegisterBlock = 0x4003_6000 as *const _;
3796 #[doc = r"Return the pointer to the register block"]
3797 #[inline(always)]
3798 pub const fn ptr() -> *const usbd_ns::RegisterBlock {
3799 Self::PTR
3800 }
3801}
3802impl Deref for USBD_NS {
3803 type Target = usbd_ns::RegisterBlock;
3804 #[inline(always)]
3805 fn deref(&self) -> &Self::Target {
3806 unsafe { &*Self::PTR }
3807 }
3808}
3809impl core::fmt::Debug for USBD_NS {
3810 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3811 f.debug_struct("USBD_NS").finish()
3812 }
3813}
3814#[doc = "Universal serial bus device 0"]
3815pub mod usbd_ns;
3816#[doc = "Universal serial bus device 1"]
3817pub struct USBD_S {
3818 _marker: PhantomData<*const ()>,
3819}
3820unsafe impl Send for USBD_S {}
3821impl USBD_S {
3822 #[doc = r"Pointer to the register block"]
3823 pub const PTR: *const usbd_ns::RegisterBlock = 0x5003_6000 as *const _;
3824 #[doc = r"Return the pointer to the register block"]
3825 #[inline(always)]
3826 pub const fn ptr() -> *const usbd_ns::RegisterBlock {
3827 Self::PTR
3828 }
3829}
3830impl Deref for USBD_S {
3831 type Target = usbd_ns::RegisterBlock;
3832 #[inline(always)]
3833 fn deref(&self) -> &Self::Target {
3834 unsafe { &*Self::PTR }
3835 }
3836}
3837impl core::fmt::Debug for USBD_S {
3838 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3839 f.debug_struct("USBD_S").finish()
3840 }
3841}
3842#[doc = "Universal serial bus device 1"]
3843pub use usbd_ns as usbd_s;
3844#[doc = "USB Regulator 0"]
3845pub struct USBREGULATOR_NS {
3846 _marker: PhantomData<*const ()>,
3847}
3848unsafe impl Send for USBREGULATOR_NS {}
3849impl USBREGULATOR_NS {
3850 #[doc = r"Pointer to the register block"]
3851 pub const PTR: *const usbregulator_ns::RegisterBlock = 0x4003_7000 as *const _;
3852 #[doc = r"Return the pointer to the register block"]
3853 #[inline(always)]
3854 pub const fn ptr() -> *const usbregulator_ns::RegisterBlock {
3855 Self::PTR
3856 }
3857}
3858impl Deref for USBREGULATOR_NS {
3859 type Target = usbregulator_ns::RegisterBlock;
3860 #[inline(always)]
3861 fn deref(&self) -> &Self::Target {
3862 unsafe { &*Self::PTR }
3863 }
3864}
3865impl core::fmt::Debug for USBREGULATOR_NS {
3866 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3867 f.debug_struct("USBREGULATOR_NS").finish()
3868 }
3869}
3870#[doc = "USB Regulator 0"]
3871pub mod usbregulator_ns;
3872#[doc = "USB Regulator 1"]
3873pub struct USBREGULATOR_S {
3874 _marker: PhantomData<*const ()>,
3875}
3876unsafe impl Send for USBREGULATOR_S {}
3877impl USBREGULATOR_S {
3878 #[doc = r"Pointer to the register block"]
3879 pub const PTR: *const usbregulator_ns::RegisterBlock = 0x5003_7000 as *const _;
3880 #[doc = r"Return the pointer to the register block"]
3881 #[inline(always)]
3882 pub const fn ptr() -> *const usbregulator_ns::RegisterBlock {
3883 Self::PTR
3884 }
3885}
3886impl Deref for USBREGULATOR_S {
3887 type Target = usbregulator_ns::RegisterBlock;
3888 #[inline(always)]
3889 fn deref(&self) -> &Self::Target {
3890 unsafe { &*Self::PTR }
3891 }
3892}
3893impl core::fmt::Debug for USBREGULATOR_S {
3894 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3895 f.debug_struct("USBREGULATOR_S").finish()
3896 }
3897}
3898#[doc = "USB Regulator 1"]
3899pub use usbregulator_ns as usbregulator_s;
3900#[doc = "Key management unit 0"]
3901pub struct KMU_NS {
3902 _marker: PhantomData<*const ()>,
3903}
3904unsafe impl Send for KMU_NS {}
3905impl KMU_NS {
3906 #[doc = r"Pointer to the register block"]
3907 pub const PTR: *const kmu_ns::RegisterBlock = 0x4003_9000 as *const _;
3908 #[doc = r"Return the pointer to the register block"]
3909 #[inline(always)]
3910 pub const fn ptr() -> *const kmu_ns::RegisterBlock {
3911 Self::PTR
3912 }
3913}
3914impl Deref for KMU_NS {
3915 type Target = kmu_ns::RegisterBlock;
3916 #[inline(always)]
3917 fn deref(&self) -> &Self::Target {
3918 unsafe { &*Self::PTR }
3919 }
3920}
3921impl core::fmt::Debug for KMU_NS {
3922 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3923 f.debug_struct("KMU_NS").finish()
3924 }
3925}
3926#[doc = "Key management unit 0"]
3927pub mod kmu_ns;
3928#[doc = "Non-volatile memory controller 0"]
3929pub struct NVMC_NS {
3930 _marker: PhantomData<*const ()>,
3931}
3932unsafe impl Send for NVMC_NS {}
3933impl NVMC_NS {
3934 #[doc = r"Pointer to the register block"]
3935 pub const PTR: *const nvmc_ns::RegisterBlock = 0x4003_9000 as *const _;
3936 #[doc = r"Return the pointer to the register block"]
3937 #[inline(always)]
3938 pub const fn ptr() -> *const nvmc_ns::RegisterBlock {
3939 Self::PTR
3940 }
3941}
3942impl Deref for NVMC_NS {
3943 type Target = nvmc_ns::RegisterBlock;
3944 #[inline(always)]
3945 fn deref(&self) -> &Self::Target {
3946 unsafe { &*Self::PTR }
3947 }
3948}
3949impl core::fmt::Debug for NVMC_NS {
3950 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3951 f.debug_struct("NVMC_NS").finish()
3952 }
3953}
3954#[doc = "Non-volatile memory controller 0"]
3955pub mod nvmc_ns;
3956#[doc = "Key management unit 1"]
3957pub struct KMU_S {
3958 _marker: PhantomData<*const ()>,
3959}
3960unsafe impl Send for KMU_S {}
3961impl KMU_S {
3962 #[doc = r"Pointer to the register block"]
3963 pub const PTR: *const kmu_ns::RegisterBlock = 0x5003_9000 as *const _;
3964 #[doc = r"Return the pointer to the register block"]
3965 #[inline(always)]
3966 pub const fn ptr() -> *const kmu_ns::RegisterBlock {
3967 Self::PTR
3968 }
3969}
3970impl Deref for KMU_S {
3971 type Target = kmu_ns::RegisterBlock;
3972 #[inline(always)]
3973 fn deref(&self) -> &Self::Target {
3974 unsafe { &*Self::PTR }
3975 }
3976}
3977impl core::fmt::Debug for KMU_S {
3978 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3979 f.debug_struct("KMU_S").finish()
3980 }
3981}
3982#[doc = "Key management unit 1"]
3983pub use kmu_ns as kmu_s;
3984#[doc = "Non-volatile memory controller 1"]
3985pub struct NVMC_S {
3986 _marker: PhantomData<*const ()>,
3987}
3988unsafe impl Send for NVMC_S {}
3989impl NVMC_S {
3990 #[doc = r"Pointer to the register block"]
3991 pub const PTR: *const nvmc_ns::RegisterBlock = 0x5003_9000 as *const _;
3992 #[doc = r"Return the pointer to the register block"]
3993 #[inline(always)]
3994 pub const fn ptr() -> *const nvmc_ns::RegisterBlock {
3995 Self::PTR
3996 }
3997}
3998impl Deref for NVMC_S {
3999 type Target = nvmc_ns::RegisterBlock;
4000 #[inline(always)]
4001 fn deref(&self) -> &Self::Target {
4002 unsafe { &*Self::PTR }
4003 }
4004}
4005impl core::fmt::Debug for NVMC_S {
4006 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4007 f.debug_struct("NVMC_S").finish()
4008 }
4009}
4010#[doc = "Non-volatile memory controller 1"]
4011pub use nvmc_ns as nvmc_s;
4012#[doc = "GPIO Port 0"]
4013pub struct P0_NS {
4014 _marker: PhantomData<*const ()>,
4015}
4016unsafe impl Send for P0_NS {}
4017impl P0_NS {
4018 #[doc = r"Pointer to the register block"]
4019 pub const PTR: *const p0_ns::RegisterBlock = 0x4084_2500 as *const _;
4020 #[doc = r"Return the pointer to the register block"]
4021 #[inline(always)]
4022 pub const fn ptr() -> *const p0_ns::RegisterBlock {
4023 Self::PTR
4024 }
4025}
4026impl Deref for P0_NS {
4027 type Target = p0_ns::RegisterBlock;
4028 #[inline(always)]
4029 fn deref(&self) -> &Self::Target {
4030 unsafe { &*Self::PTR }
4031 }
4032}
4033impl core::fmt::Debug for P0_NS {
4034 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4035 f.debug_struct("P0_NS").finish()
4036 }
4037}
4038#[doc = "GPIO Port 0"]
4039pub mod p0_ns;
4040#[doc = "GPIO Port 1"]
4041pub struct P1_NS {
4042 _marker: PhantomData<*const ()>,
4043}
4044unsafe impl Send for P1_NS {}
4045impl P1_NS {
4046 #[doc = r"Pointer to the register block"]
4047 pub const PTR: *const p0_ns::RegisterBlock = 0x4084_2800 as *const _;
4048 #[doc = r"Return the pointer to the register block"]
4049 #[inline(always)]
4050 pub const fn ptr() -> *const p0_ns::RegisterBlock {
4051 Self::PTR
4052 }
4053}
4054impl Deref for P1_NS {
4055 type Target = p0_ns::RegisterBlock;
4056 #[inline(always)]
4057 fn deref(&self) -> &Self::Target {
4058 unsafe { &*Self::PTR }
4059 }
4060}
4061impl core::fmt::Debug for P1_NS {
4062 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4063 f.debug_struct("P1_NS").finish()
4064 }
4065}
4066#[doc = "GPIO Port 1"]
4067pub use p0_ns as p1_ns;
4068#[doc = "GPIO Port 2"]
4069pub struct P0_S {
4070 _marker: PhantomData<*const ()>,
4071}
4072unsafe impl Send for P0_S {}
4073impl P0_S {
4074 #[doc = r"Pointer to the register block"]
4075 pub const PTR: *const p0_ns::RegisterBlock = 0x5084_2500 as *const _;
4076 #[doc = r"Return the pointer to the register block"]
4077 #[inline(always)]
4078 pub const fn ptr() -> *const p0_ns::RegisterBlock {
4079 Self::PTR
4080 }
4081}
4082impl Deref for P0_S {
4083 type Target = p0_ns::RegisterBlock;
4084 #[inline(always)]
4085 fn deref(&self) -> &Self::Target {
4086 unsafe { &*Self::PTR }
4087 }
4088}
4089impl core::fmt::Debug for P0_S {
4090 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4091 f.debug_struct("P0_S").finish()
4092 }
4093}
4094#[doc = "GPIO Port 2"]
4095pub use p0_ns as p0_s;
4096#[doc = "GPIO Port 3"]
4097pub struct P1_S {
4098 _marker: PhantomData<*const ()>,
4099}
4100unsafe impl Send for P1_S {}
4101impl P1_S {
4102 #[doc = r"Pointer to the register block"]
4103 pub const PTR: *const p0_ns::RegisterBlock = 0x5084_2800 as *const _;
4104 #[doc = r"Return the pointer to the register block"]
4105 #[inline(always)]
4106 pub const fn ptr() -> *const p0_ns::RegisterBlock {
4107 Self::PTR
4108 }
4109}
4110impl Deref for P1_S {
4111 type Target = p0_ns::RegisterBlock;
4112 #[inline(always)]
4113 fn deref(&self) -> &Self::Target {
4114 unsafe { &*Self::PTR }
4115 }
4116}
4117impl core::fmt::Debug for P1_S {
4118 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4119 f.debug_struct("P1_S").finish()
4120 }
4121}
4122#[doc = "GPIO Port 3"]
4123pub use p0_ns as p1_s;
4124#[doc = "ARM TrustZone CryptoCell register interface"]
4125pub struct CRYPTOCELL_S {
4126 _marker: PhantomData<*const ()>,
4127}
4128unsafe impl Send for CRYPTOCELL_S {}
4129impl CRYPTOCELL_S {
4130 #[doc = r"Pointer to the register block"]
4131 pub const PTR: *const cryptocell_s::RegisterBlock = 0x5084_4000 as *const _;
4132 #[doc = r"Return the pointer to the register block"]
4133 #[inline(always)]
4134 pub const fn ptr() -> *const cryptocell_s::RegisterBlock {
4135 Self::PTR
4136 }
4137}
4138impl Deref for CRYPTOCELL_S {
4139 type Target = cryptocell_s::RegisterBlock;
4140 #[inline(always)]
4141 fn deref(&self) -> &Self::Target {
4142 unsafe { &*Self::PTR }
4143 }
4144}
4145impl core::fmt::Debug for CRYPTOCELL_S {
4146 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4147 f.debug_struct("CRYPTOCELL_S").finish()
4148 }
4149}
4150#[doc = "ARM TrustZone CryptoCell register interface"]
4151pub mod cryptocell_s;
4152#[doc = "Volatile Memory controller 0"]
4153pub struct VMC_NS {
4154 _marker: PhantomData<*const ()>,
4155}
4156unsafe impl Send for VMC_NS {}
4157impl VMC_NS {
4158 #[doc = r"Pointer to the register block"]
4159 pub const PTR: *const vmc_ns::RegisterBlock = 0x4008_1000 as *const _;
4160 #[doc = r"Return the pointer to the register block"]
4161 #[inline(always)]
4162 pub const fn ptr() -> *const vmc_ns::RegisterBlock {
4163 Self::PTR
4164 }
4165}
4166impl Deref for VMC_NS {
4167 type Target = vmc_ns::RegisterBlock;
4168 #[inline(always)]
4169 fn deref(&self) -> &Self::Target {
4170 unsafe { &*Self::PTR }
4171 }
4172}
4173impl core::fmt::Debug for VMC_NS {
4174 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4175 f.debug_struct("VMC_NS").finish()
4176 }
4177}
4178#[doc = "Volatile Memory controller 0"]
4179pub mod vmc_ns;
4180#[doc = "Volatile Memory controller 1"]
4181pub struct VMC_S {
4182 _marker: PhantomData<*const ()>,
4183}
4184unsafe impl Send for VMC_S {}
4185impl VMC_S {
4186 #[doc = r"Pointer to the register block"]
4187 pub const PTR: *const vmc_ns::RegisterBlock = 0x5008_1000 as *const _;
4188 #[doc = r"Return the pointer to the register block"]
4189 #[inline(always)]
4190 pub const fn ptr() -> *const vmc_ns::RegisterBlock {
4191 Self::PTR
4192 }
4193}
4194impl Deref for VMC_S {
4195 type Target = vmc_ns::RegisterBlock;
4196 #[inline(always)]
4197 fn deref(&self) -> &Self::Target {
4198 unsafe { &*Self::PTR }
4199 }
4200}
4201impl core::fmt::Debug for VMC_S {
4202 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4203 f.debug_struct("VMC_S").finish()
4204 }
4205}
4206#[doc = "Volatile Memory controller 1"]
4207pub use vmc_ns as vmc_s;
4208#[no_mangle]
4209static mut DEVICE_PERIPHERALS: bool = false;
4210#[doc = r"All the peripherals"]
4211#[allow(non_snake_case)]
4212pub struct Peripherals {
4213 #[doc = "CACHEDATA_S"]
4214 pub CACHEDATA_S: CACHEDATA_S,
4215 #[doc = "CACHEINFO_S"]
4216 pub CACHEINFO_S: CACHEINFO_S,
4217 #[doc = "FICR_S"]
4218 pub FICR_S: FICR_S,
4219 #[doc = "UICR_S"]
4220 pub UICR_S: UICR_S,
4221 #[doc = "CTI_S"]
4222 pub CTI_S: CTI_S,
4223 #[doc = "TAD_S"]
4224 pub TAD_S: TAD_S,
4225 #[doc = "DCNF_NS"]
4226 pub DCNF_NS: DCNF_NS,
4227 #[doc = "FPU_NS"]
4228 pub FPU_NS: FPU_NS,
4229 #[doc = "DCNF_S"]
4230 pub DCNF_S: DCNF_S,
4231 #[doc = "FPU_S"]
4232 pub FPU_S: FPU_S,
4233 #[doc = "CACHE_S"]
4234 pub CACHE_S: CACHE_S,
4235 #[doc = "SPU_S"]
4236 pub SPU_S: SPU_S,
4237 #[doc = "OSCILLATORS_NS"]
4238 pub OSCILLATORS_NS: OSCILLATORS_NS,
4239 #[doc = "REGULATORS_NS"]
4240 pub REGULATORS_NS: REGULATORS_NS,
4241 #[doc = "OSCILLATORS_S"]
4242 pub OSCILLATORS_S: OSCILLATORS_S,
4243 #[doc = "REGULATORS_S"]
4244 pub REGULATORS_S: REGULATORS_S,
4245 #[doc = "CLOCK_NS"]
4246 pub CLOCK_NS: CLOCK_NS,
4247 #[doc = "POWER_NS"]
4248 pub POWER_NS: POWER_NS,
4249 #[doc = "RESET_NS"]
4250 pub RESET_NS: RESET_NS,
4251 #[doc = "CLOCK_S"]
4252 pub CLOCK_S: CLOCK_S,
4253 #[doc = "POWER_S"]
4254 pub POWER_S: POWER_S,
4255 #[doc = "RESET_S"]
4256 pub RESET_S: RESET_S,
4257 #[doc = "CTRLAP_NS"]
4258 pub CTRLAP_NS: CTRLAP_NS,
4259 #[doc = "CTRLAP_S"]
4260 pub CTRLAP_S: CTRLAP_S,
4261 #[doc = "SPIM0_NS"]
4262 pub SPIM0_NS: SPIM0_NS,
4263 #[doc = "SPIS0_NS"]
4264 pub SPIS0_NS: SPIS0_NS,
4265 #[doc = "TWIM0_NS"]
4266 pub TWIM0_NS: TWIM0_NS,
4267 #[doc = "TWIS0_NS"]
4268 pub TWIS0_NS: TWIS0_NS,
4269 #[doc = "UARTE0_NS"]
4270 pub UARTE0_NS: UARTE0_NS,
4271 #[doc = "SPIM0_S"]
4272 pub SPIM0_S: SPIM0_S,
4273 #[doc = "SPIS0_S"]
4274 pub SPIS0_S: SPIS0_S,
4275 #[doc = "TWIM0_S"]
4276 pub TWIM0_S: TWIM0_S,
4277 #[doc = "TWIS0_S"]
4278 pub TWIS0_S: TWIS0_S,
4279 #[doc = "UARTE0_S"]
4280 pub UARTE0_S: UARTE0_S,
4281 #[doc = "SPIM1_NS"]
4282 pub SPIM1_NS: SPIM1_NS,
4283 #[doc = "SPIS1_NS"]
4284 pub SPIS1_NS: SPIS1_NS,
4285 #[doc = "TWIM1_NS"]
4286 pub TWIM1_NS: TWIM1_NS,
4287 #[doc = "TWIS1_NS"]
4288 pub TWIS1_NS: TWIS1_NS,
4289 #[doc = "UARTE1_NS"]
4290 pub UARTE1_NS: UARTE1_NS,
4291 #[doc = "SPIM1_S"]
4292 pub SPIM1_S: SPIM1_S,
4293 #[doc = "SPIS1_S"]
4294 pub SPIS1_S: SPIS1_S,
4295 #[doc = "TWIM1_S"]
4296 pub TWIM1_S: TWIM1_S,
4297 #[doc = "TWIS1_S"]
4298 pub TWIS1_S: TWIS1_S,
4299 #[doc = "UARTE1_S"]
4300 pub UARTE1_S: UARTE1_S,
4301 #[doc = "SPIM4_NS"]
4302 pub SPIM4_NS: SPIM4_NS,
4303 #[doc = "SPIM4_S"]
4304 pub SPIM4_S: SPIM4_S,
4305 #[doc = "SPIM2_NS"]
4306 pub SPIM2_NS: SPIM2_NS,
4307 #[doc = "SPIS2_NS"]
4308 pub SPIS2_NS: SPIS2_NS,
4309 #[doc = "TWIM2_NS"]
4310 pub TWIM2_NS: TWIM2_NS,
4311 #[doc = "TWIS2_NS"]
4312 pub TWIS2_NS: TWIS2_NS,
4313 #[doc = "UARTE2_NS"]
4314 pub UARTE2_NS: UARTE2_NS,
4315 #[doc = "SPIM2_S"]
4316 pub SPIM2_S: SPIM2_S,
4317 #[doc = "SPIS2_S"]
4318 pub SPIS2_S: SPIS2_S,
4319 #[doc = "TWIM2_S"]
4320 pub TWIM2_S: TWIM2_S,
4321 #[doc = "TWIS2_S"]
4322 pub TWIS2_S: TWIS2_S,
4323 #[doc = "UARTE2_S"]
4324 pub UARTE2_S: UARTE2_S,
4325 #[doc = "SPIM3_NS"]
4326 pub SPIM3_NS: SPIM3_NS,
4327 #[doc = "SPIS3_NS"]
4328 pub SPIS3_NS: SPIS3_NS,
4329 #[doc = "TWIM3_NS"]
4330 pub TWIM3_NS: TWIM3_NS,
4331 #[doc = "TWIS3_NS"]
4332 pub TWIS3_NS: TWIS3_NS,
4333 #[doc = "UARTE3_NS"]
4334 pub UARTE3_NS: UARTE3_NS,
4335 #[doc = "SPIM3_S"]
4336 pub SPIM3_S: SPIM3_S,
4337 #[doc = "SPIS3_S"]
4338 pub SPIS3_S: SPIS3_S,
4339 #[doc = "TWIM3_S"]
4340 pub TWIM3_S: TWIM3_S,
4341 #[doc = "TWIS3_S"]
4342 pub TWIS3_S: TWIS3_S,
4343 #[doc = "UARTE3_S"]
4344 pub UARTE3_S: UARTE3_S,
4345 #[doc = "GPIOTE0_S"]
4346 pub GPIOTE0_S: GPIOTE0_S,
4347 #[doc = "SAADC_NS"]
4348 pub SAADC_NS: SAADC_NS,
4349 #[doc = "SAADC_S"]
4350 pub SAADC_S: SAADC_S,
4351 #[doc = "TIMER0_NS"]
4352 pub TIMER0_NS: TIMER0_NS,
4353 #[doc = "TIMER0_S"]
4354 pub TIMER0_S: TIMER0_S,
4355 #[doc = "TIMER1_NS"]
4356 pub TIMER1_NS: TIMER1_NS,
4357 #[doc = "TIMER1_S"]
4358 pub TIMER1_S: TIMER1_S,
4359 #[doc = "TIMER2_NS"]
4360 pub TIMER2_NS: TIMER2_NS,
4361 #[doc = "TIMER2_S"]
4362 pub TIMER2_S: TIMER2_S,
4363 #[doc = "RTC0_NS"]
4364 pub RTC0_NS: RTC0_NS,
4365 #[doc = "RTC0_S"]
4366 pub RTC0_S: RTC0_S,
4367 #[doc = "RTC1_NS"]
4368 pub RTC1_NS: RTC1_NS,
4369 #[doc = "RTC1_S"]
4370 pub RTC1_S: RTC1_S,
4371 #[doc = "DPPIC_NS"]
4372 pub DPPIC_NS: DPPIC_NS,
4373 #[doc = "DPPIC_S"]
4374 pub DPPIC_S: DPPIC_S,
4375 #[doc = "WDT0_NS"]
4376 pub WDT0_NS: WDT0_NS,
4377 #[doc = "WDT0_S"]
4378 pub WDT0_S: WDT0_S,
4379 #[doc = "WDT1_NS"]
4380 pub WDT1_NS: WDT1_NS,
4381 #[doc = "WDT1_S"]
4382 pub WDT1_S: WDT1_S,
4383 #[doc = "COMP_NS"]
4384 pub COMP_NS: COMP_NS,
4385 #[doc = "LPCOMP_NS"]
4386 pub LPCOMP_NS: LPCOMP_NS,
4387 #[doc = "COMP_S"]
4388 pub COMP_S: COMP_S,
4389 #[doc = "LPCOMP_S"]
4390 pub LPCOMP_S: LPCOMP_S,
4391 #[doc = "EGU0_NS"]
4392 pub EGU0_NS: EGU0_NS,
4393 #[doc = "EGU0_S"]
4394 pub EGU0_S: EGU0_S,
4395 #[doc = "EGU1_NS"]
4396 pub EGU1_NS: EGU1_NS,
4397 #[doc = "EGU1_S"]
4398 pub EGU1_S: EGU1_S,
4399 #[doc = "EGU2_NS"]
4400 pub EGU2_NS: EGU2_NS,
4401 #[doc = "EGU2_S"]
4402 pub EGU2_S: EGU2_S,
4403 #[doc = "EGU3_NS"]
4404 pub EGU3_NS: EGU3_NS,
4405 #[doc = "EGU3_S"]
4406 pub EGU3_S: EGU3_S,
4407 #[doc = "EGU4_NS"]
4408 pub EGU4_NS: EGU4_NS,
4409 #[doc = "EGU4_S"]
4410 pub EGU4_S: EGU4_S,
4411 #[doc = "EGU5_NS"]
4412 pub EGU5_NS: EGU5_NS,
4413 #[doc = "EGU5_S"]
4414 pub EGU5_S: EGU5_S,
4415 #[doc = "PWM0_NS"]
4416 pub PWM0_NS: PWM0_NS,
4417 #[doc = "PWM0_S"]
4418 pub PWM0_S: PWM0_S,
4419 #[doc = "PWM1_NS"]
4420 pub PWM1_NS: PWM1_NS,
4421 #[doc = "PWM1_S"]
4422 pub PWM1_S: PWM1_S,
4423 #[doc = "PWM2_NS"]
4424 pub PWM2_NS: PWM2_NS,
4425 #[doc = "PWM2_S"]
4426 pub PWM2_S: PWM2_S,
4427 #[doc = "PWM3_NS"]
4428 pub PWM3_NS: PWM3_NS,
4429 #[doc = "PWM3_S"]
4430 pub PWM3_S: PWM3_S,
4431 #[doc = "PDM0_NS"]
4432 pub PDM0_NS: PDM0_NS,
4433 #[doc = "PDM0_S"]
4434 pub PDM0_S: PDM0_S,
4435 #[doc = "I2S0_NS"]
4436 pub I2S0_NS: I2S0_NS,
4437 #[doc = "I2S0_S"]
4438 pub I2S0_S: I2S0_S,
4439 #[doc = "IPC_NS"]
4440 pub IPC_NS: IPC_NS,
4441 #[doc = "IPC_S"]
4442 pub IPC_S: IPC_S,
4443 #[doc = "QSPI_NS"]
4444 pub QSPI_NS: QSPI_NS,
4445 #[doc = "QSPI_S"]
4446 pub QSPI_S: QSPI_S,
4447 #[doc = "NFCT_NS"]
4448 pub NFCT_NS: NFCT_NS,
4449 #[doc = "NFCT_S"]
4450 pub NFCT_S: NFCT_S,
4451 #[doc = "GPIOTE1_NS"]
4452 pub GPIOTE1_NS: GPIOTE1_NS,
4453 #[doc = "MUTEX_NS"]
4454 pub MUTEX_NS: MUTEX_NS,
4455 #[doc = "MUTEX_S"]
4456 pub MUTEX_S: MUTEX_S,
4457 #[doc = "QDEC0_NS"]
4458 pub QDEC0_NS: QDEC0_NS,
4459 #[doc = "QDEC0_S"]
4460 pub QDEC0_S: QDEC0_S,
4461 #[doc = "QDEC1_NS"]
4462 pub QDEC1_NS: QDEC1_NS,
4463 #[doc = "QDEC1_S"]
4464 pub QDEC1_S: QDEC1_S,
4465 #[doc = "USBD_NS"]
4466 pub USBD_NS: USBD_NS,
4467 #[doc = "USBD_S"]
4468 pub USBD_S: USBD_S,
4469 #[doc = "USBREGULATOR_NS"]
4470 pub USBREGULATOR_NS: USBREGULATOR_NS,
4471 #[doc = "USBREGULATOR_S"]
4472 pub USBREGULATOR_S: USBREGULATOR_S,
4473 #[doc = "KMU_NS"]
4474 pub KMU_NS: KMU_NS,
4475 #[doc = "NVMC_NS"]
4476 pub NVMC_NS: NVMC_NS,
4477 #[doc = "KMU_S"]
4478 pub KMU_S: KMU_S,
4479 #[doc = "NVMC_S"]
4480 pub NVMC_S: NVMC_S,
4481 #[doc = "P0_NS"]
4482 pub P0_NS: P0_NS,
4483 #[doc = "P1_NS"]
4484 pub P1_NS: P1_NS,
4485 #[doc = "P0_S"]
4486 pub P0_S: P0_S,
4487 #[doc = "P1_S"]
4488 pub P1_S: P1_S,
4489 #[doc = "CRYPTOCELL_S"]
4490 pub CRYPTOCELL_S: CRYPTOCELL_S,
4491 #[doc = "VMC_NS"]
4492 pub VMC_NS: VMC_NS,
4493 #[doc = "VMC_S"]
4494 pub VMC_S: VMC_S,
4495}
4496impl Peripherals {
4497 #[doc = r"Returns all the peripherals *once*"]
4498 #[inline]
4499 pub fn take() -> Option<Self> {
4500 cortex_m::interrupt::free(|_| {
4501 if unsafe { DEVICE_PERIPHERALS } {
4502 None
4503 } else {
4504 Some(unsafe { Peripherals::steal() })
4505 }
4506 })
4507 }
4508 #[doc = r"Unchecked version of `Peripherals::take`"]
4509 #[inline]
4510 pub unsafe fn steal() -> Self {
4511 DEVICE_PERIPHERALS = true;
4512 Peripherals {
4513 CACHEDATA_S: CACHEDATA_S {
4514 _marker: PhantomData,
4515 },
4516 CACHEINFO_S: CACHEINFO_S {
4517 _marker: PhantomData,
4518 },
4519 FICR_S: FICR_S {
4520 _marker: PhantomData,
4521 },
4522 UICR_S: UICR_S {
4523 _marker: PhantomData,
4524 },
4525 CTI_S: CTI_S {
4526 _marker: PhantomData,
4527 },
4528 TAD_S: TAD_S {
4529 _marker: PhantomData,
4530 },
4531 DCNF_NS: DCNF_NS {
4532 _marker: PhantomData,
4533 },
4534 FPU_NS: FPU_NS {
4535 _marker: PhantomData,
4536 },
4537 DCNF_S: DCNF_S {
4538 _marker: PhantomData,
4539 },
4540 FPU_S: FPU_S {
4541 _marker: PhantomData,
4542 },
4543 CACHE_S: CACHE_S {
4544 _marker: PhantomData,
4545 },
4546 SPU_S: SPU_S {
4547 _marker: PhantomData,
4548 },
4549 OSCILLATORS_NS: OSCILLATORS_NS {
4550 _marker: PhantomData,
4551 },
4552 REGULATORS_NS: REGULATORS_NS {
4553 _marker: PhantomData,
4554 },
4555 OSCILLATORS_S: OSCILLATORS_S {
4556 _marker: PhantomData,
4557 },
4558 REGULATORS_S: REGULATORS_S {
4559 _marker: PhantomData,
4560 },
4561 CLOCK_NS: CLOCK_NS {
4562 _marker: PhantomData,
4563 },
4564 POWER_NS: POWER_NS {
4565 _marker: PhantomData,
4566 },
4567 RESET_NS: RESET_NS {
4568 _marker: PhantomData,
4569 },
4570 CLOCK_S: CLOCK_S {
4571 _marker: PhantomData,
4572 },
4573 POWER_S: POWER_S {
4574 _marker: PhantomData,
4575 },
4576 RESET_S: RESET_S {
4577 _marker: PhantomData,
4578 },
4579 CTRLAP_NS: CTRLAP_NS {
4580 _marker: PhantomData,
4581 },
4582 CTRLAP_S: CTRLAP_S {
4583 _marker: PhantomData,
4584 },
4585 SPIM0_NS: SPIM0_NS {
4586 _marker: PhantomData,
4587 },
4588 SPIS0_NS: SPIS0_NS {
4589 _marker: PhantomData,
4590 },
4591 TWIM0_NS: TWIM0_NS {
4592 _marker: PhantomData,
4593 },
4594 TWIS0_NS: TWIS0_NS {
4595 _marker: PhantomData,
4596 },
4597 UARTE0_NS: UARTE0_NS {
4598 _marker: PhantomData,
4599 },
4600 SPIM0_S: SPIM0_S {
4601 _marker: PhantomData,
4602 },
4603 SPIS0_S: SPIS0_S {
4604 _marker: PhantomData,
4605 },
4606 TWIM0_S: TWIM0_S {
4607 _marker: PhantomData,
4608 },
4609 TWIS0_S: TWIS0_S {
4610 _marker: PhantomData,
4611 },
4612 UARTE0_S: UARTE0_S {
4613 _marker: PhantomData,
4614 },
4615 SPIM1_NS: SPIM1_NS {
4616 _marker: PhantomData,
4617 },
4618 SPIS1_NS: SPIS1_NS {
4619 _marker: PhantomData,
4620 },
4621 TWIM1_NS: TWIM1_NS {
4622 _marker: PhantomData,
4623 },
4624 TWIS1_NS: TWIS1_NS {
4625 _marker: PhantomData,
4626 },
4627 UARTE1_NS: UARTE1_NS {
4628 _marker: PhantomData,
4629 },
4630 SPIM1_S: SPIM1_S {
4631 _marker: PhantomData,
4632 },
4633 SPIS1_S: SPIS1_S {
4634 _marker: PhantomData,
4635 },
4636 TWIM1_S: TWIM1_S {
4637 _marker: PhantomData,
4638 },
4639 TWIS1_S: TWIS1_S {
4640 _marker: PhantomData,
4641 },
4642 UARTE1_S: UARTE1_S {
4643 _marker: PhantomData,
4644 },
4645 SPIM4_NS: SPIM4_NS {
4646 _marker: PhantomData,
4647 },
4648 SPIM4_S: SPIM4_S {
4649 _marker: PhantomData,
4650 },
4651 SPIM2_NS: SPIM2_NS {
4652 _marker: PhantomData,
4653 },
4654 SPIS2_NS: SPIS2_NS {
4655 _marker: PhantomData,
4656 },
4657 TWIM2_NS: TWIM2_NS {
4658 _marker: PhantomData,
4659 },
4660 TWIS2_NS: TWIS2_NS {
4661 _marker: PhantomData,
4662 },
4663 UARTE2_NS: UARTE2_NS {
4664 _marker: PhantomData,
4665 },
4666 SPIM2_S: SPIM2_S {
4667 _marker: PhantomData,
4668 },
4669 SPIS2_S: SPIS2_S {
4670 _marker: PhantomData,
4671 },
4672 TWIM2_S: TWIM2_S {
4673 _marker: PhantomData,
4674 },
4675 TWIS2_S: TWIS2_S {
4676 _marker: PhantomData,
4677 },
4678 UARTE2_S: UARTE2_S {
4679 _marker: PhantomData,
4680 },
4681 SPIM3_NS: SPIM3_NS {
4682 _marker: PhantomData,
4683 },
4684 SPIS3_NS: SPIS3_NS {
4685 _marker: PhantomData,
4686 },
4687 TWIM3_NS: TWIM3_NS {
4688 _marker: PhantomData,
4689 },
4690 TWIS3_NS: TWIS3_NS {
4691 _marker: PhantomData,
4692 },
4693 UARTE3_NS: UARTE3_NS {
4694 _marker: PhantomData,
4695 },
4696 SPIM3_S: SPIM3_S {
4697 _marker: PhantomData,
4698 },
4699 SPIS3_S: SPIS3_S {
4700 _marker: PhantomData,
4701 },
4702 TWIM3_S: TWIM3_S {
4703 _marker: PhantomData,
4704 },
4705 TWIS3_S: TWIS3_S {
4706 _marker: PhantomData,
4707 },
4708 UARTE3_S: UARTE3_S {
4709 _marker: PhantomData,
4710 },
4711 GPIOTE0_S: GPIOTE0_S {
4712 _marker: PhantomData,
4713 },
4714 SAADC_NS: SAADC_NS {
4715 _marker: PhantomData,
4716 },
4717 SAADC_S: SAADC_S {
4718 _marker: PhantomData,
4719 },
4720 TIMER0_NS: TIMER0_NS {
4721 _marker: PhantomData,
4722 },
4723 TIMER0_S: TIMER0_S {
4724 _marker: PhantomData,
4725 },
4726 TIMER1_NS: TIMER1_NS {
4727 _marker: PhantomData,
4728 },
4729 TIMER1_S: TIMER1_S {
4730 _marker: PhantomData,
4731 },
4732 TIMER2_NS: TIMER2_NS {
4733 _marker: PhantomData,
4734 },
4735 TIMER2_S: TIMER2_S {
4736 _marker: PhantomData,
4737 },
4738 RTC0_NS: RTC0_NS {
4739 _marker: PhantomData,
4740 },
4741 RTC0_S: RTC0_S {
4742 _marker: PhantomData,
4743 },
4744 RTC1_NS: RTC1_NS {
4745 _marker: PhantomData,
4746 },
4747 RTC1_S: RTC1_S {
4748 _marker: PhantomData,
4749 },
4750 DPPIC_NS: DPPIC_NS {
4751 _marker: PhantomData,
4752 },
4753 DPPIC_S: DPPIC_S {
4754 _marker: PhantomData,
4755 },
4756 WDT0_NS: WDT0_NS {
4757 _marker: PhantomData,
4758 },
4759 WDT0_S: WDT0_S {
4760 _marker: PhantomData,
4761 },
4762 WDT1_NS: WDT1_NS {
4763 _marker: PhantomData,
4764 },
4765 WDT1_S: WDT1_S {
4766 _marker: PhantomData,
4767 },
4768 COMP_NS: COMP_NS {
4769 _marker: PhantomData,
4770 },
4771 LPCOMP_NS: LPCOMP_NS {
4772 _marker: PhantomData,
4773 },
4774 COMP_S: COMP_S {
4775 _marker: PhantomData,
4776 },
4777 LPCOMP_S: LPCOMP_S {
4778 _marker: PhantomData,
4779 },
4780 EGU0_NS: EGU0_NS {
4781 _marker: PhantomData,
4782 },
4783 EGU0_S: EGU0_S {
4784 _marker: PhantomData,
4785 },
4786 EGU1_NS: EGU1_NS {
4787 _marker: PhantomData,
4788 },
4789 EGU1_S: EGU1_S {
4790 _marker: PhantomData,
4791 },
4792 EGU2_NS: EGU2_NS {
4793 _marker: PhantomData,
4794 },
4795 EGU2_S: EGU2_S {
4796 _marker: PhantomData,
4797 },
4798 EGU3_NS: EGU3_NS {
4799 _marker: PhantomData,
4800 },
4801 EGU3_S: EGU3_S {
4802 _marker: PhantomData,
4803 },
4804 EGU4_NS: EGU4_NS {
4805 _marker: PhantomData,
4806 },
4807 EGU4_S: EGU4_S {
4808 _marker: PhantomData,
4809 },
4810 EGU5_NS: EGU5_NS {
4811 _marker: PhantomData,
4812 },
4813 EGU5_S: EGU5_S {
4814 _marker: PhantomData,
4815 },
4816 PWM0_NS: PWM0_NS {
4817 _marker: PhantomData,
4818 },
4819 PWM0_S: PWM0_S {
4820 _marker: PhantomData,
4821 },
4822 PWM1_NS: PWM1_NS {
4823 _marker: PhantomData,
4824 },
4825 PWM1_S: PWM1_S {
4826 _marker: PhantomData,
4827 },
4828 PWM2_NS: PWM2_NS {
4829 _marker: PhantomData,
4830 },
4831 PWM2_S: PWM2_S {
4832 _marker: PhantomData,
4833 },
4834 PWM3_NS: PWM3_NS {
4835 _marker: PhantomData,
4836 },
4837 PWM3_S: PWM3_S {
4838 _marker: PhantomData,
4839 },
4840 PDM0_NS: PDM0_NS {
4841 _marker: PhantomData,
4842 },
4843 PDM0_S: PDM0_S {
4844 _marker: PhantomData,
4845 },
4846 I2S0_NS: I2S0_NS {
4847 _marker: PhantomData,
4848 },
4849 I2S0_S: I2S0_S {
4850 _marker: PhantomData,
4851 },
4852 IPC_NS: IPC_NS {
4853 _marker: PhantomData,
4854 },
4855 IPC_S: IPC_S {
4856 _marker: PhantomData,
4857 },
4858 QSPI_NS: QSPI_NS {
4859 _marker: PhantomData,
4860 },
4861 QSPI_S: QSPI_S {
4862 _marker: PhantomData,
4863 },
4864 NFCT_NS: NFCT_NS {
4865 _marker: PhantomData,
4866 },
4867 NFCT_S: NFCT_S {
4868 _marker: PhantomData,
4869 },
4870 GPIOTE1_NS: GPIOTE1_NS {
4871 _marker: PhantomData,
4872 },
4873 MUTEX_NS: MUTEX_NS {
4874 _marker: PhantomData,
4875 },
4876 MUTEX_S: MUTEX_S {
4877 _marker: PhantomData,
4878 },
4879 QDEC0_NS: QDEC0_NS {
4880 _marker: PhantomData,
4881 },
4882 QDEC0_S: QDEC0_S {
4883 _marker: PhantomData,
4884 },
4885 QDEC1_NS: QDEC1_NS {
4886 _marker: PhantomData,
4887 },
4888 QDEC1_S: QDEC1_S {
4889 _marker: PhantomData,
4890 },
4891 USBD_NS: USBD_NS {
4892 _marker: PhantomData,
4893 },
4894 USBD_S: USBD_S {
4895 _marker: PhantomData,
4896 },
4897 USBREGULATOR_NS: USBREGULATOR_NS {
4898 _marker: PhantomData,
4899 },
4900 USBREGULATOR_S: USBREGULATOR_S {
4901 _marker: PhantomData,
4902 },
4903 KMU_NS: KMU_NS {
4904 _marker: PhantomData,
4905 },
4906 NVMC_NS: NVMC_NS {
4907 _marker: PhantomData,
4908 },
4909 KMU_S: KMU_S {
4910 _marker: PhantomData,
4911 },
4912 NVMC_S: NVMC_S {
4913 _marker: PhantomData,
4914 },
4915 P0_NS: P0_NS {
4916 _marker: PhantomData,
4917 },
4918 P1_NS: P1_NS {
4919 _marker: PhantomData,
4920 },
4921 P0_S: P0_S {
4922 _marker: PhantomData,
4923 },
4924 P1_S: P1_S {
4925 _marker: PhantomData,
4926 },
4927 CRYPTOCELL_S: CRYPTOCELL_S {
4928 _marker: PhantomData,
4929 },
4930 VMC_NS: VMC_NS {
4931 _marker: PhantomData,
4932 },
4933 VMC_S: VMC_S {
4934 _marker: PhantomData,
4935 },
4936 }
4937 }
4938}