1#![doc = "Peripheral access API for NRF9160 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 SPU();
38 fn CLOCK_POWER();
39 fn UARTE0_SPIM0_SPIS0_TWIM0_TWIS0();
40 fn UARTE1_SPIM1_SPIS1_TWIM1_TWIS1();
41 fn UARTE2_SPIM2_SPIS2_TWIM2_TWIS2();
42 fn UARTE3_SPIM3_SPIS3_TWIM3_TWIS3();
43 fn GPIOTE0();
44 fn SAADC();
45 fn TIMER0();
46 fn TIMER1();
47 fn TIMER2();
48 fn RTC0();
49 fn RTC1();
50 fn WDT();
51 fn EGU0();
52 fn EGU1();
53 fn EGU2();
54 fn EGU3();
55 fn EGU4();
56 fn EGU5();
57 fn PWM0();
58 fn PWM1();
59 fn PWM2();
60 fn PWM3();
61 fn PDM();
62 fn I2S();
63 fn IPC();
64 fn FPU();
65 fn GPIOTE1();
66 fn KMU();
67 fn CRYPTOCELL();
68}
69#[doc(hidden)]
70pub union Vector {
71 _handler: unsafe extern "C" fn(),
72 _reserved: u32,
73}
74#[cfg(feature = "rt")]
75#[doc(hidden)]
76#[link_section = ".vector_table.interrupts"]
77#[no_mangle]
78pub static __INTERRUPTS: [Vector; 65] = [
79 Vector { _reserved: 0 },
80 Vector { _reserved: 0 },
81 Vector { _reserved: 0 },
82 Vector { _handler: SPU },
83 Vector { _reserved: 0 },
84 Vector {
85 _handler: CLOCK_POWER,
86 },
87 Vector { _reserved: 0 },
88 Vector { _reserved: 0 },
89 Vector {
90 _handler: UARTE0_SPIM0_SPIS0_TWIM0_TWIS0,
91 },
92 Vector {
93 _handler: UARTE1_SPIM1_SPIS1_TWIM1_TWIS1,
94 },
95 Vector {
96 _handler: UARTE2_SPIM2_SPIS2_TWIM2_TWIS2,
97 },
98 Vector {
99 _handler: UARTE3_SPIM3_SPIS3_TWIM3_TWIS3,
100 },
101 Vector { _reserved: 0 },
102 Vector { _handler: GPIOTE0 },
103 Vector { _handler: SAADC },
104 Vector { _handler: TIMER0 },
105 Vector { _handler: TIMER1 },
106 Vector { _handler: TIMER2 },
107 Vector { _reserved: 0 },
108 Vector { _reserved: 0 },
109 Vector { _handler: RTC0 },
110 Vector { _handler: RTC1 },
111 Vector { _reserved: 0 },
112 Vector { _reserved: 0 },
113 Vector { _handler: WDT },
114 Vector { _reserved: 0 },
115 Vector { _reserved: 0 },
116 Vector { _handler: EGU0 },
117 Vector { _handler: EGU1 },
118 Vector { _handler: EGU2 },
119 Vector { _handler: EGU3 },
120 Vector { _handler: EGU4 },
121 Vector { _handler: EGU5 },
122 Vector { _handler: PWM0 },
123 Vector { _handler: PWM1 },
124 Vector { _handler: PWM2 },
125 Vector { _handler: PWM3 },
126 Vector { _reserved: 0 },
127 Vector { _handler: PDM },
128 Vector { _reserved: 0 },
129 Vector { _handler: I2S },
130 Vector { _reserved: 0 },
131 Vector { _handler: IPC },
132 Vector { _reserved: 0 },
133 Vector { _handler: FPU },
134 Vector { _reserved: 0 },
135 Vector { _reserved: 0 },
136 Vector { _reserved: 0 },
137 Vector { _reserved: 0 },
138 Vector { _handler: GPIOTE1 },
139 Vector { _reserved: 0 },
140 Vector { _reserved: 0 },
141 Vector { _reserved: 0 },
142 Vector { _reserved: 0 },
143 Vector { _reserved: 0 },
144 Vector { _reserved: 0 },
145 Vector { _reserved: 0 },
146 Vector { _handler: KMU },
147 Vector { _reserved: 0 },
148 Vector { _reserved: 0 },
149 Vector { _reserved: 0 },
150 Vector { _reserved: 0 },
151 Vector { _reserved: 0 },
152 Vector { _reserved: 0 },
153 Vector {
154 _handler: CRYPTOCELL,
155 },
156];
157#[doc = r"Enumeration of all the interrupts."]
158#[derive(Copy, Clone, Debug, PartialEq, Eq)]
159#[repr(u16)]
160pub enum Interrupt {
161 #[doc = "3 - SPU"]
162 SPU = 3,
163 #[doc = "5 - CLOCK_POWER"]
164 CLOCK_POWER = 5,
165 #[doc = "8 - UARTE0_SPIM0_SPIS0_TWIM0_TWIS0"]
166 UARTE0_SPIM0_SPIS0_TWIM0_TWIS0 = 8,
167 #[doc = "9 - UARTE1_SPIM1_SPIS1_TWIM1_TWIS1"]
168 UARTE1_SPIM1_SPIS1_TWIM1_TWIS1 = 9,
169 #[doc = "10 - UARTE2_SPIM2_SPIS2_TWIM2_TWIS2"]
170 UARTE2_SPIM2_SPIS2_TWIM2_TWIS2 = 10,
171 #[doc = "11 - UARTE3_SPIM3_SPIS3_TWIM3_TWIS3"]
172 UARTE3_SPIM3_SPIS3_TWIM3_TWIS3 = 11,
173 #[doc = "13 - GPIOTE0"]
174 GPIOTE0 = 13,
175 #[doc = "14 - SAADC"]
176 SAADC = 14,
177 #[doc = "15 - TIMER0"]
178 TIMER0 = 15,
179 #[doc = "16 - TIMER1"]
180 TIMER1 = 16,
181 #[doc = "17 - TIMER2"]
182 TIMER2 = 17,
183 #[doc = "20 - RTC0"]
184 RTC0 = 20,
185 #[doc = "21 - RTC1"]
186 RTC1 = 21,
187 #[doc = "24 - WDT"]
188 WDT = 24,
189 #[doc = "27 - EGU0"]
190 EGU0 = 27,
191 #[doc = "28 - EGU1"]
192 EGU1 = 28,
193 #[doc = "29 - EGU2"]
194 EGU2 = 29,
195 #[doc = "30 - EGU3"]
196 EGU3 = 30,
197 #[doc = "31 - EGU4"]
198 EGU4 = 31,
199 #[doc = "32 - EGU5"]
200 EGU5 = 32,
201 #[doc = "33 - PWM0"]
202 PWM0 = 33,
203 #[doc = "34 - PWM1"]
204 PWM1 = 34,
205 #[doc = "35 - PWM2"]
206 PWM2 = 35,
207 #[doc = "36 - PWM3"]
208 PWM3 = 36,
209 #[doc = "38 - PDM"]
210 PDM = 38,
211 #[doc = "40 - I2S"]
212 I2S = 40,
213 #[doc = "42 - IPC"]
214 IPC = 42,
215 #[doc = "44 - FPU"]
216 FPU = 44,
217 #[doc = "49 - GPIOTE1"]
218 GPIOTE1 = 49,
219 #[doc = "57 - KMU"]
220 KMU = 57,
221 #[doc = "64 - CRYPTOCELL"]
222 CRYPTOCELL = 64,
223}
224unsafe impl cortex_m::interrupt::InterruptNumber for Interrupt {
225 #[inline(always)]
226 fn number(self) -> u16 {
227 self as u16
228 }
229}
230#[doc = "Factory Information Configuration Registers"]
231pub struct FICR_S {
232 _marker: PhantomData<*const ()>,
233}
234unsafe impl Send for FICR_S {}
235impl FICR_S {
236 #[doc = r"Pointer to the register block"]
237 pub const PTR: *const ficr_s::RegisterBlock = 0x00ff_0000 as *const _;
238 #[doc = r"Return the pointer to the register block"]
239 #[inline(always)]
240 pub const fn ptr() -> *const ficr_s::RegisterBlock {
241 Self::PTR
242 }
243}
244impl Deref for FICR_S {
245 type Target = ficr_s::RegisterBlock;
246 #[inline(always)]
247 fn deref(&self) -> &Self::Target {
248 unsafe { &*Self::PTR }
249 }
250}
251impl core::fmt::Debug for FICR_S {
252 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
253 f.debug_struct("FICR_S").finish()
254 }
255}
256#[doc = "Factory Information Configuration Registers"]
257pub mod ficr_s;
258#[doc = "User information configuration registers User information configuration registers"]
259pub struct UICR_S {
260 _marker: PhantomData<*const ()>,
261}
262unsafe impl Send for UICR_S {}
263impl UICR_S {
264 #[doc = r"Pointer to the register block"]
265 pub const PTR: *const uicr_s::RegisterBlock = 0x00ff_8000 as *const _;
266 #[doc = r"Return the pointer to the register block"]
267 #[inline(always)]
268 pub const fn ptr() -> *const uicr_s::RegisterBlock {
269 Self::PTR
270 }
271}
272impl Deref for UICR_S {
273 type Target = uicr_s::RegisterBlock;
274 #[inline(always)]
275 fn deref(&self) -> &Self::Target {
276 unsafe { &*Self::PTR }
277 }
278}
279impl core::fmt::Debug for UICR_S {
280 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
281 f.debug_struct("UICR_S").finish()
282 }
283}
284#[doc = "User information configuration registers User information configuration registers"]
285pub mod uicr_s;
286#[doc = "Trace and debug control"]
287pub struct TAD_S {
288 _marker: PhantomData<*const ()>,
289}
290unsafe impl Send for TAD_S {}
291impl TAD_S {
292 #[doc = r"Pointer to the register block"]
293 pub const PTR: *const tad_s::RegisterBlock = 0xe008_0000 as *const _;
294 #[doc = r"Return the pointer to the register block"]
295 #[inline(always)]
296 pub const fn ptr() -> *const tad_s::RegisterBlock {
297 Self::PTR
298 }
299}
300impl Deref for TAD_S {
301 type Target = tad_s::RegisterBlock;
302 #[inline(always)]
303 fn deref(&self) -> &Self::Target {
304 unsafe { &*Self::PTR }
305 }
306}
307impl core::fmt::Debug for TAD_S {
308 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
309 f.debug_struct("TAD_S").finish()
310 }
311}
312#[doc = "Trace and debug control"]
313pub mod tad_s;
314#[doc = "System protection unit"]
315pub struct SPU_S {
316 _marker: PhantomData<*const ()>,
317}
318unsafe impl Send for SPU_S {}
319impl SPU_S {
320 #[doc = r"Pointer to the register block"]
321 pub const PTR: *const spu_s::RegisterBlock = 0x5000_3000 as *const _;
322 #[doc = r"Return the pointer to the register block"]
323 #[inline(always)]
324 pub const fn ptr() -> *const spu_s::RegisterBlock {
325 Self::PTR
326 }
327}
328impl Deref for SPU_S {
329 type Target = spu_s::RegisterBlock;
330 #[inline(always)]
331 fn deref(&self) -> &Self::Target {
332 unsafe { &*Self::PTR }
333 }
334}
335impl core::fmt::Debug for SPU_S {
336 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
337 f.debug_struct("SPU_S").finish()
338 }
339}
340#[doc = "System protection unit"]
341pub mod spu_s;
342#[doc = "Voltage regulators control 0"]
343pub struct REGULATORS_NS {
344 _marker: PhantomData<*const ()>,
345}
346unsafe impl Send for REGULATORS_NS {}
347impl REGULATORS_NS {
348 #[doc = r"Pointer to the register block"]
349 pub const PTR: *const regulators_ns::RegisterBlock = 0x4000_4000 as *const _;
350 #[doc = r"Return the pointer to the register block"]
351 #[inline(always)]
352 pub const fn ptr() -> *const regulators_ns::RegisterBlock {
353 Self::PTR
354 }
355}
356impl Deref for REGULATORS_NS {
357 type Target = regulators_ns::RegisterBlock;
358 #[inline(always)]
359 fn deref(&self) -> &Self::Target {
360 unsafe { &*Self::PTR }
361 }
362}
363impl core::fmt::Debug for REGULATORS_NS {
364 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
365 f.debug_struct("REGULATORS_NS").finish()
366 }
367}
368#[doc = "Voltage regulators control 0"]
369pub mod regulators_ns;
370#[doc = "Voltage regulators control 1"]
371pub struct REGULATORS_S {
372 _marker: PhantomData<*const ()>,
373}
374unsafe impl Send for REGULATORS_S {}
375impl REGULATORS_S {
376 #[doc = r"Pointer to the register block"]
377 pub const PTR: *const regulators_ns::RegisterBlock = 0x5000_4000 as *const _;
378 #[doc = r"Return the pointer to the register block"]
379 #[inline(always)]
380 pub const fn ptr() -> *const regulators_ns::RegisterBlock {
381 Self::PTR
382 }
383}
384impl Deref for REGULATORS_S {
385 type Target = regulators_ns::RegisterBlock;
386 #[inline(always)]
387 fn deref(&self) -> &Self::Target {
388 unsafe { &*Self::PTR }
389 }
390}
391impl core::fmt::Debug for REGULATORS_S {
392 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
393 f.debug_struct("REGULATORS_S").finish()
394 }
395}
396#[doc = "Voltage regulators control 1"]
397pub use regulators_ns as regulators_s;
398#[doc = "Clock management 0"]
399pub struct CLOCK_NS {
400 _marker: PhantomData<*const ()>,
401}
402unsafe impl Send for CLOCK_NS {}
403impl CLOCK_NS {
404 #[doc = r"Pointer to the register block"]
405 pub const PTR: *const clock_ns::RegisterBlock = 0x4000_5000 as *const _;
406 #[doc = r"Return the pointer to the register block"]
407 #[inline(always)]
408 pub const fn ptr() -> *const clock_ns::RegisterBlock {
409 Self::PTR
410 }
411}
412impl Deref for CLOCK_NS {
413 type Target = clock_ns::RegisterBlock;
414 #[inline(always)]
415 fn deref(&self) -> &Self::Target {
416 unsafe { &*Self::PTR }
417 }
418}
419impl core::fmt::Debug for CLOCK_NS {
420 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
421 f.debug_struct("CLOCK_NS").finish()
422 }
423}
424#[doc = "Clock management 0"]
425pub mod clock_ns;
426#[doc = "Power control 0"]
427pub struct POWER_NS {
428 _marker: PhantomData<*const ()>,
429}
430unsafe impl Send for POWER_NS {}
431impl POWER_NS {
432 #[doc = r"Pointer to the register block"]
433 pub const PTR: *const power_ns::RegisterBlock = 0x4000_5000 as *const _;
434 #[doc = r"Return the pointer to the register block"]
435 #[inline(always)]
436 pub const fn ptr() -> *const power_ns::RegisterBlock {
437 Self::PTR
438 }
439}
440impl Deref for POWER_NS {
441 type Target = power_ns::RegisterBlock;
442 #[inline(always)]
443 fn deref(&self) -> &Self::Target {
444 unsafe { &*Self::PTR }
445 }
446}
447impl core::fmt::Debug for POWER_NS {
448 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
449 f.debug_struct("POWER_NS").finish()
450 }
451}
452#[doc = "Power control 0"]
453pub mod power_ns;
454#[doc = "Clock management 1"]
455pub struct CLOCK_S {
456 _marker: PhantomData<*const ()>,
457}
458unsafe impl Send for CLOCK_S {}
459impl CLOCK_S {
460 #[doc = r"Pointer to the register block"]
461 pub const PTR: *const clock_ns::RegisterBlock = 0x5000_5000 as *const _;
462 #[doc = r"Return the pointer to the register block"]
463 #[inline(always)]
464 pub const fn ptr() -> *const clock_ns::RegisterBlock {
465 Self::PTR
466 }
467}
468impl Deref for CLOCK_S {
469 type Target = clock_ns::RegisterBlock;
470 #[inline(always)]
471 fn deref(&self) -> &Self::Target {
472 unsafe { &*Self::PTR }
473 }
474}
475impl core::fmt::Debug for CLOCK_S {
476 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
477 f.debug_struct("CLOCK_S").finish()
478 }
479}
480#[doc = "Clock management 1"]
481pub use clock_ns as clock_s;
482#[doc = "Power control 1"]
483pub struct POWER_S {
484 _marker: PhantomData<*const ()>,
485}
486unsafe impl Send for POWER_S {}
487impl POWER_S {
488 #[doc = r"Pointer to the register block"]
489 pub const PTR: *const power_ns::RegisterBlock = 0x5000_5000 as *const _;
490 #[doc = r"Return the pointer to the register block"]
491 #[inline(always)]
492 pub const fn ptr() -> *const power_ns::RegisterBlock {
493 Self::PTR
494 }
495}
496impl Deref for POWER_S {
497 type Target = power_ns::RegisterBlock;
498 #[inline(always)]
499 fn deref(&self) -> &Self::Target {
500 unsafe { &*Self::PTR }
501 }
502}
503impl core::fmt::Debug for POWER_S {
504 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
505 f.debug_struct("POWER_S").finish()
506 }
507}
508#[doc = "Power control 1"]
509pub use power_ns as power_s;
510#[doc = "Control access port"]
511pub struct CTRL_AP_PERI_S {
512 _marker: PhantomData<*const ()>,
513}
514unsafe impl Send for CTRL_AP_PERI_S {}
515impl CTRL_AP_PERI_S {
516 #[doc = r"Pointer to the register block"]
517 pub const PTR: *const ctrl_ap_peri_s::RegisterBlock = 0x5000_6000 as *const _;
518 #[doc = r"Return the pointer to the register block"]
519 #[inline(always)]
520 pub const fn ptr() -> *const ctrl_ap_peri_s::RegisterBlock {
521 Self::PTR
522 }
523}
524impl Deref for CTRL_AP_PERI_S {
525 type Target = ctrl_ap_peri_s::RegisterBlock;
526 #[inline(always)]
527 fn deref(&self) -> &Self::Target {
528 unsafe { &*Self::PTR }
529 }
530}
531impl core::fmt::Debug for CTRL_AP_PERI_S {
532 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
533 f.debug_struct("CTRL_AP_PERI_S").finish()
534 }
535}
536#[doc = "Control access port"]
537pub mod ctrl_ap_peri_s;
538#[doc = "Serial Peripheral Interface Master with EasyDMA 0"]
539pub struct SPIM0_NS {
540 _marker: PhantomData<*const ()>,
541}
542unsafe impl Send for SPIM0_NS {}
543impl SPIM0_NS {
544 #[doc = r"Pointer to the register block"]
545 pub const PTR: *const spim0_ns::RegisterBlock = 0x4000_8000 as *const _;
546 #[doc = r"Return the pointer to the register block"]
547 #[inline(always)]
548 pub const fn ptr() -> *const spim0_ns::RegisterBlock {
549 Self::PTR
550 }
551}
552impl Deref for SPIM0_NS {
553 type Target = spim0_ns::RegisterBlock;
554 #[inline(always)]
555 fn deref(&self) -> &Self::Target {
556 unsafe { &*Self::PTR }
557 }
558}
559impl core::fmt::Debug for SPIM0_NS {
560 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
561 f.debug_struct("SPIM0_NS").finish()
562 }
563}
564#[doc = "Serial Peripheral Interface Master with EasyDMA 0"]
565pub mod spim0_ns;
566#[doc = "SPI Slave 0"]
567pub struct SPIS0_NS {
568 _marker: PhantomData<*const ()>,
569}
570unsafe impl Send for SPIS0_NS {}
571impl SPIS0_NS {
572 #[doc = r"Pointer to the register block"]
573 pub const PTR: *const spis0_ns::RegisterBlock = 0x4000_8000 as *const _;
574 #[doc = r"Return the pointer to the register block"]
575 #[inline(always)]
576 pub const fn ptr() -> *const spis0_ns::RegisterBlock {
577 Self::PTR
578 }
579}
580impl Deref for SPIS0_NS {
581 type Target = spis0_ns::RegisterBlock;
582 #[inline(always)]
583 fn deref(&self) -> &Self::Target {
584 unsafe { &*Self::PTR }
585 }
586}
587impl core::fmt::Debug for SPIS0_NS {
588 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
589 f.debug_struct("SPIS0_NS").finish()
590 }
591}
592#[doc = "SPI Slave 0"]
593pub mod spis0_ns;
594#[doc = "I2C compatible Two-Wire Master Interface with EasyDMA 0"]
595pub struct TWIM0_NS {
596 _marker: PhantomData<*const ()>,
597}
598unsafe impl Send for TWIM0_NS {}
599impl TWIM0_NS {
600 #[doc = r"Pointer to the register block"]
601 pub const PTR: *const twim0_ns::RegisterBlock = 0x4000_8000 as *const _;
602 #[doc = r"Return the pointer to the register block"]
603 #[inline(always)]
604 pub const fn ptr() -> *const twim0_ns::RegisterBlock {
605 Self::PTR
606 }
607}
608impl Deref for TWIM0_NS {
609 type Target = twim0_ns::RegisterBlock;
610 #[inline(always)]
611 fn deref(&self) -> &Self::Target {
612 unsafe { &*Self::PTR }
613 }
614}
615impl core::fmt::Debug for TWIM0_NS {
616 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
617 f.debug_struct("TWIM0_NS").finish()
618 }
619}
620#[doc = "I2C compatible Two-Wire Master Interface with EasyDMA 0"]
621pub mod twim0_ns;
622#[doc = "I2C compatible Two-Wire Slave Interface with EasyDMA 0"]
623pub struct TWIS0_NS {
624 _marker: PhantomData<*const ()>,
625}
626unsafe impl Send for TWIS0_NS {}
627impl TWIS0_NS {
628 #[doc = r"Pointer to the register block"]
629 pub const PTR: *const twis0_ns::RegisterBlock = 0x4000_8000 as *const _;
630 #[doc = r"Return the pointer to the register block"]
631 #[inline(always)]
632 pub const fn ptr() -> *const twis0_ns::RegisterBlock {
633 Self::PTR
634 }
635}
636impl Deref for TWIS0_NS {
637 type Target = twis0_ns::RegisterBlock;
638 #[inline(always)]
639 fn deref(&self) -> &Self::Target {
640 unsafe { &*Self::PTR }
641 }
642}
643impl core::fmt::Debug for TWIS0_NS {
644 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
645 f.debug_struct("TWIS0_NS").finish()
646 }
647}
648#[doc = "I2C compatible Two-Wire Slave Interface with EasyDMA 0"]
649pub mod twis0_ns;
650#[doc = "UART with EasyDMA 0"]
651pub struct UARTE0_NS {
652 _marker: PhantomData<*const ()>,
653}
654unsafe impl Send for UARTE0_NS {}
655impl UARTE0_NS {
656 #[doc = r"Pointer to the register block"]
657 pub const PTR: *const uarte0_ns::RegisterBlock = 0x4000_8000 as *const _;
658 #[doc = r"Return the pointer to the register block"]
659 #[inline(always)]
660 pub const fn ptr() -> *const uarte0_ns::RegisterBlock {
661 Self::PTR
662 }
663}
664impl Deref for UARTE0_NS {
665 type Target = uarte0_ns::RegisterBlock;
666 #[inline(always)]
667 fn deref(&self) -> &Self::Target {
668 unsafe { &*Self::PTR }
669 }
670}
671impl core::fmt::Debug for UARTE0_NS {
672 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
673 f.debug_struct("UARTE0_NS").finish()
674 }
675}
676#[doc = "UART with EasyDMA 0"]
677pub mod uarte0_ns;
678#[doc = "Serial Peripheral Interface Master with EasyDMA 1"]
679pub struct SPIM0_S {
680 _marker: PhantomData<*const ()>,
681}
682unsafe impl Send for SPIM0_S {}
683impl SPIM0_S {
684 #[doc = r"Pointer to the register block"]
685 pub const PTR: *const spim0_ns::RegisterBlock = 0x5000_8000 as *const _;
686 #[doc = r"Return the pointer to the register block"]
687 #[inline(always)]
688 pub const fn ptr() -> *const spim0_ns::RegisterBlock {
689 Self::PTR
690 }
691}
692impl Deref for SPIM0_S {
693 type Target = spim0_ns::RegisterBlock;
694 #[inline(always)]
695 fn deref(&self) -> &Self::Target {
696 unsafe { &*Self::PTR }
697 }
698}
699impl core::fmt::Debug for SPIM0_S {
700 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
701 f.debug_struct("SPIM0_S").finish()
702 }
703}
704#[doc = "Serial Peripheral Interface Master with EasyDMA 1"]
705pub use spim0_ns as spim0_s;
706#[doc = "SPI Slave 1"]
707pub struct SPIS0_S {
708 _marker: PhantomData<*const ()>,
709}
710unsafe impl Send for SPIS0_S {}
711impl SPIS0_S {
712 #[doc = r"Pointer to the register block"]
713 pub const PTR: *const spis0_ns::RegisterBlock = 0x5000_8000 as *const _;
714 #[doc = r"Return the pointer to the register block"]
715 #[inline(always)]
716 pub const fn ptr() -> *const spis0_ns::RegisterBlock {
717 Self::PTR
718 }
719}
720impl Deref for SPIS0_S {
721 type Target = spis0_ns::RegisterBlock;
722 #[inline(always)]
723 fn deref(&self) -> &Self::Target {
724 unsafe { &*Self::PTR }
725 }
726}
727impl core::fmt::Debug for SPIS0_S {
728 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
729 f.debug_struct("SPIS0_S").finish()
730 }
731}
732#[doc = "SPI Slave 1"]
733pub use spis0_ns as spis0_s;
734#[doc = "I2C compatible Two-Wire Master Interface with EasyDMA 1"]
735pub struct TWIM0_S {
736 _marker: PhantomData<*const ()>,
737}
738unsafe impl Send for TWIM0_S {}
739impl TWIM0_S {
740 #[doc = r"Pointer to the register block"]
741 pub const PTR: *const twim0_ns::RegisterBlock = 0x5000_8000 as *const _;
742 #[doc = r"Return the pointer to the register block"]
743 #[inline(always)]
744 pub const fn ptr() -> *const twim0_ns::RegisterBlock {
745 Self::PTR
746 }
747}
748impl Deref for TWIM0_S {
749 type Target = twim0_ns::RegisterBlock;
750 #[inline(always)]
751 fn deref(&self) -> &Self::Target {
752 unsafe { &*Self::PTR }
753 }
754}
755impl core::fmt::Debug for TWIM0_S {
756 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
757 f.debug_struct("TWIM0_S").finish()
758 }
759}
760#[doc = "I2C compatible Two-Wire Master Interface with EasyDMA 1"]
761pub use twim0_ns as twim0_s;
762#[doc = "I2C compatible Two-Wire Slave Interface with EasyDMA 1"]
763pub struct TWIS0_S {
764 _marker: PhantomData<*const ()>,
765}
766unsafe impl Send for TWIS0_S {}
767impl TWIS0_S {
768 #[doc = r"Pointer to the register block"]
769 pub const PTR: *const twis0_ns::RegisterBlock = 0x5000_8000 as *const _;
770 #[doc = r"Return the pointer to the register block"]
771 #[inline(always)]
772 pub const fn ptr() -> *const twis0_ns::RegisterBlock {
773 Self::PTR
774 }
775}
776impl Deref for TWIS0_S {
777 type Target = twis0_ns::RegisterBlock;
778 #[inline(always)]
779 fn deref(&self) -> &Self::Target {
780 unsafe { &*Self::PTR }
781 }
782}
783impl core::fmt::Debug for TWIS0_S {
784 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
785 f.debug_struct("TWIS0_S").finish()
786 }
787}
788#[doc = "I2C compatible Two-Wire Slave Interface with EasyDMA 1"]
789pub use twis0_ns as twis0_s;
790#[doc = "UART with EasyDMA 1"]
791pub struct UARTE0_S {
792 _marker: PhantomData<*const ()>,
793}
794unsafe impl Send for UARTE0_S {}
795impl UARTE0_S {
796 #[doc = r"Pointer to the register block"]
797 pub const PTR: *const uarte0_ns::RegisterBlock = 0x5000_8000 as *const _;
798 #[doc = r"Return the pointer to the register block"]
799 #[inline(always)]
800 pub const fn ptr() -> *const uarte0_ns::RegisterBlock {
801 Self::PTR
802 }
803}
804impl Deref for UARTE0_S {
805 type Target = uarte0_ns::RegisterBlock;
806 #[inline(always)]
807 fn deref(&self) -> &Self::Target {
808 unsafe { &*Self::PTR }
809 }
810}
811impl core::fmt::Debug for UARTE0_S {
812 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
813 f.debug_struct("UARTE0_S").finish()
814 }
815}
816#[doc = "UART with EasyDMA 1"]
817pub use uarte0_ns as uarte0_s;
818#[doc = "Serial Peripheral Interface Master with EasyDMA 2"]
819pub struct SPIM1_NS {
820 _marker: PhantomData<*const ()>,
821}
822unsafe impl Send for SPIM1_NS {}
823impl SPIM1_NS {
824 #[doc = r"Pointer to the register block"]
825 pub const PTR: *const spim0_ns::RegisterBlock = 0x4000_9000 as *const _;
826 #[doc = r"Return the pointer to the register block"]
827 #[inline(always)]
828 pub const fn ptr() -> *const spim0_ns::RegisterBlock {
829 Self::PTR
830 }
831}
832impl Deref for SPIM1_NS {
833 type Target = spim0_ns::RegisterBlock;
834 #[inline(always)]
835 fn deref(&self) -> &Self::Target {
836 unsafe { &*Self::PTR }
837 }
838}
839impl core::fmt::Debug for SPIM1_NS {
840 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
841 f.debug_struct("SPIM1_NS").finish()
842 }
843}
844#[doc = "Serial Peripheral Interface Master with EasyDMA 2"]
845pub use spim0_ns as spim1_ns;
846#[doc = "SPI Slave 2"]
847pub struct SPIS1_NS {
848 _marker: PhantomData<*const ()>,
849}
850unsafe impl Send for SPIS1_NS {}
851impl SPIS1_NS {
852 #[doc = r"Pointer to the register block"]
853 pub const PTR: *const spis0_ns::RegisterBlock = 0x4000_9000 as *const _;
854 #[doc = r"Return the pointer to the register block"]
855 #[inline(always)]
856 pub const fn ptr() -> *const spis0_ns::RegisterBlock {
857 Self::PTR
858 }
859}
860impl Deref for SPIS1_NS {
861 type Target = spis0_ns::RegisterBlock;
862 #[inline(always)]
863 fn deref(&self) -> &Self::Target {
864 unsafe { &*Self::PTR }
865 }
866}
867impl core::fmt::Debug for SPIS1_NS {
868 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
869 f.debug_struct("SPIS1_NS").finish()
870 }
871}
872#[doc = "SPI Slave 2"]
873pub use spis0_ns as spis1_ns;
874#[doc = "I2C compatible Two-Wire Master Interface with EasyDMA 2"]
875pub struct TWIM1_NS {
876 _marker: PhantomData<*const ()>,
877}
878unsafe impl Send for TWIM1_NS {}
879impl TWIM1_NS {
880 #[doc = r"Pointer to the register block"]
881 pub const PTR: *const twim0_ns::RegisterBlock = 0x4000_9000 as *const _;
882 #[doc = r"Return the pointer to the register block"]
883 #[inline(always)]
884 pub const fn ptr() -> *const twim0_ns::RegisterBlock {
885 Self::PTR
886 }
887}
888impl Deref for TWIM1_NS {
889 type Target = twim0_ns::RegisterBlock;
890 #[inline(always)]
891 fn deref(&self) -> &Self::Target {
892 unsafe { &*Self::PTR }
893 }
894}
895impl core::fmt::Debug for TWIM1_NS {
896 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
897 f.debug_struct("TWIM1_NS").finish()
898 }
899}
900#[doc = "I2C compatible Two-Wire Master Interface with EasyDMA 2"]
901pub use twim0_ns as twim1_ns;
902#[doc = "I2C compatible Two-Wire Slave Interface with EasyDMA 2"]
903pub struct TWIS1_NS {
904 _marker: PhantomData<*const ()>,
905}
906unsafe impl Send for TWIS1_NS {}
907impl TWIS1_NS {
908 #[doc = r"Pointer to the register block"]
909 pub const PTR: *const twis0_ns::RegisterBlock = 0x4000_9000 as *const _;
910 #[doc = r"Return the pointer to the register block"]
911 #[inline(always)]
912 pub const fn ptr() -> *const twis0_ns::RegisterBlock {
913 Self::PTR
914 }
915}
916impl Deref for TWIS1_NS {
917 type Target = twis0_ns::RegisterBlock;
918 #[inline(always)]
919 fn deref(&self) -> &Self::Target {
920 unsafe { &*Self::PTR }
921 }
922}
923impl core::fmt::Debug for TWIS1_NS {
924 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
925 f.debug_struct("TWIS1_NS").finish()
926 }
927}
928#[doc = "I2C compatible Two-Wire Slave Interface with EasyDMA 2"]
929pub use twis0_ns as twis1_ns;
930#[doc = "UART with EasyDMA 2"]
931pub struct UARTE1_NS {
932 _marker: PhantomData<*const ()>,
933}
934unsafe impl Send for UARTE1_NS {}
935impl UARTE1_NS {
936 #[doc = r"Pointer to the register block"]
937 pub const PTR: *const uarte0_ns::RegisterBlock = 0x4000_9000 as *const _;
938 #[doc = r"Return the pointer to the register block"]
939 #[inline(always)]
940 pub const fn ptr() -> *const uarte0_ns::RegisterBlock {
941 Self::PTR
942 }
943}
944impl Deref for UARTE1_NS {
945 type Target = uarte0_ns::RegisterBlock;
946 #[inline(always)]
947 fn deref(&self) -> &Self::Target {
948 unsafe { &*Self::PTR }
949 }
950}
951impl core::fmt::Debug for UARTE1_NS {
952 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
953 f.debug_struct("UARTE1_NS").finish()
954 }
955}
956#[doc = "UART with EasyDMA 2"]
957pub use uarte0_ns as uarte1_ns;
958#[doc = "Serial Peripheral Interface Master with EasyDMA 3"]
959pub struct SPIM1_S {
960 _marker: PhantomData<*const ()>,
961}
962unsafe impl Send for SPIM1_S {}
963impl SPIM1_S {
964 #[doc = r"Pointer to the register block"]
965 pub const PTR: *const spim0_ns::RegisterBlock = 0x5000_9000 as *const _;
966 #[doc = r"Return the pointer to the register block"]
967 #[inline(always)]
968 pub const fn ptr() -> *const spim0_ns::RegisterBlock {
969 Self::PTR
970 }
971}
972impl Deref for SPIM1_S {
973 type Target = spim0_ns::RegisterBlock;
974 #[inline(always)]
975 fn deref(&self) -> &Self::Target {
976 unsafe { &*Self::PTR }
977 }
978}
979impl core::fmt::Debug for SPIM1_S {
980 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
981 f.debug_struct("SPIM1_S").finish()
982 }
983}
984#[doc = "Serial Peripheral Interface Master with EasyDMA 3"]
985pub use spim0_ns as spim1_s;
986#[doc = "SPI Slave 3"]
987pub struct SPIS1_S {
988 _marker: PhantomData<*const ()>,
989}
990unsafe impl Send for SPIS1_S {}
991impl SPIS1_S {
992 #[doc = r"Pointer to the register block"]
993 pub const PTR: *const spis0_ns::RegisterBlock = 0x5000_9000 as *const _;
994 #[doc = r"Return the pointer to the register block"]
995 #[inline(always)]
996 pub const fn ptr() -> *const spis0_ns::RegisterBlock {
997 Self::PTR
998 }
999}
1000impl Deref for SPIS1_S {
1001 type Target = spis0_ns::RegisterBlock;
1002 #[inline(always)]
1003 fn deref(&self) -> &Self::Target {
1004 unsafe { &*Self::PTR }
1005 }
1006}
1007impl core::fmt::Debug for SPIS1_S {
1008 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1009 f.debug_struct("SPIS1_S").finish()
1010 }
1011}
1012#[doc = "SPI Slave 3"]
1013pub use spis0_ns as spis1_s;
1014#[doc = "I2C compatible Two-Wire Master Interface with EasyDMA 3"]
1015pub struct TWIM1_S {
1016 _marker: PhantomData<*const ()>,
1017}
1018unsafe impl Send for TWIM1_S {}
1019impl TWIM1_S {
1020 #[doc = r"Pointer to the register block"]
1021 pub const PTR: *const twim0_ns::RegisterBlock = 0x5000_9000 as *const _;
1022 #[doc = r"Return the pointer to the register block"]
1023 #[inline(always)]
1024 pub const fn ptr() -> *const twim0_ns::RegisterBlock {
1025 Self::PTR
1026 }
1027}
1028impl Deref for TWIM1_S {
1029 type Target = twim0_ns::RegisterBlock;
1030 #[inline(always)]
1031 fn deref(&self) -> &Self::Target {
1032 unsafe { &*Self::PTR }
1033 }
1034}
1035impl core::fmt::Debug for TWIM1_S {
1036 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1037 f.debug_struct("TWIM1_S").finish()
1038 }
1039}
1040#[doc = "I2C compatible Two-Wire Master Interface with EasyDMA 3"]
1041pub use twim0_ns as twim1_s;
1042#[doc = "I2C compatible Two-Wire Slave Interface with EasyDMA 3"]
1043pub struct TWIS1_S {
1044 _marker: PhantomData<*const ()>,
1045}
1046unsafe impl Send for TWIS1_S {}
1047impl TWIS1_S {
1048 #[doc = r"Pointer to the register block"]
1049 pub const PTR: *const twis0_ns::RegisterBlock = 0x5000_9000 as *const _;
1050 #[doc = r"Return the pointer to the register block"]
1051 #[inline(always)]
1052 pub const fn ptr() -> *const twis0_ns::RegisterBlock {
1053 Self::PTR
1054 }
1055}
1056impl Deref for TWIS1_S {
1057 type Target = twis0_ns::RegisterBlock;
1058 #[inline(always)]
1059 fn deref(&self) -> &Self::Target {
1060 unsafe { &*Self::PTR }
1061 }
1062}
1063impl core::fmt::Debug for TWIS1_S {
1064 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1065 f.debug_struct("TWIS1_S").finish()
1066 }
1067}
1068#[doc = "I2C compatible Two-Wire Slave Interface with EasyDMA 3"]
1069pub use twis0_ns as twis1_s;
1070#[doc = "UART with EasyDMA 3"]
1071pub struct UARTE1_S {
1072 _marker: PhantomData<*const ()>,
1073}
1074unsafe impl Send for UARTE1_S {}
1075impl UARTE1_S {
1076 #[doc = r"Pointer to the register block"]
1077 pub const PTR: *const uarte0_ns::RegisterBlock = 0x5000_9000 as *const _;
1078 #[doc = r"Return the pointer to the register block"]
1079 #[inline(always)]
1080 pub const fn ptr() -> *const uarte0_ns::RegisterBlock {
1081 Self::PTR
1082 }
1083}
1084impl Deref for UARTE1_S {
1085 type Target = uarte0_ns::RegisterBlock;
1086 #[inline(always)]
1087 fn deref(&self) -> &Self::Target {
1088 unsafe { &*Self::PTR }
1089 }
1090}
1091impl core::fmt::Debug for UARTE1_S {
1092 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1093 f.debug_struct("UARTE1_S").finish()
1094 }
1095}
1096#[doc = "UART with EasyDMA 3"]
1097pub use uarte0_ns as uarte1_s;
1098#[doc = "Serial Peripheral Interface Master with EasyDMA 4"]
1099pub struct SPIM2_NS {
1100 _marker: PhantomData<*const ()>,
1101}
1102unsafe impl Send for SPIM2_NS {}
1103impl SPIM2_NS {
1104 #[doc = r"Pointer to the register block"]
1105 pub const PTR: *const spim0_ns::RegisterBlock = 0x4000_a000 as *const _;
1106 #[doc = r"Return the pointer to the register block"]
1107 #[inline(always)]
1108 pub const fn ptr() -> *const spim0_ns::RegisterBlock {
1109 Self::PTR
1110 }
1111}
1112impl Deref for SPIM2_NS {
1113 type Target = spim0_ns::RegisterBlock;
1114 #[inline(always)]
1115 fn deref(&self) -> &Self::Target {
1116 unsafe { &*Self::PTR }
1117 }
1118}
1119impl core::fmt::Debug for SPIM2_NS {
1120 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1121 f.debug_struct("SPIM2_NS").finish()
1122 }
1123}
1124#[doc = "Serial Peripheral Interface Master with EasyDMA 4"]
1125pub use spim0_ns as spim2_ns;
1126#[doc = "SPI Slave 4"]
1127pub struct SPIS2_NS {
1128 _marker: PhantomData<*const ()>,
1129}
1130unsafe impl Send for SPIS2_NS {}
1131impl SPIS2_NS {
1132 #[doc = r"Pointer to the register block"]
1133 pub const PTR: *const spis0_ns::RegisterBlock = 0x4000_a000 as *const _;
1134 #[doc = r"Return the pointer to the register block"]
1135 #[inline(always)]
1136 pub const fn ptr() -> *const spis0_ns::RegisterBlock {
1137 Self::PTR
1138 }
1139}
1140impl Deref for SPIS2_NS {
1141 type Target = spis0_ns::RegisterBlock;
1142 #[inline(always)]
1143 fn deref(&self) -> &Self::Target {
1144 unsafe { &*Self::PTR }
1145 }
1146}
1147impl core::fmt::Debug for SPIS2_NS {
1148 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1149 f.debug_struct("SPIS2_NS").finish()
1150 }
1151}
1152#[doc = "SPI Slave 4"]
1153pub use spis0_ns as spis2_ns;
1154#[doc = "I2C compatible Two-Wire Master Interface with EasyDMA 4"]
1155pub struct TWIM2_NS {
1156 _marker: PhantomData<*const ()>,
1157}
1158unsafe impl Send for TWIM2_NS {}
1159impl TWIM2_NS {
1160 #[doc = r"Pointer to the register block"]
1161 pub const PTR: *const twim0_ns::RegisterBlock = 0x4000_a000 as *const _;
1162 #[doc = r"Return the pointer to the register block"]
1163 #[inline(always)]
1164 pub const fn ptr() -> *const twim0_ns::RegisterBlock {
1165 Self::PTR
1166 }
1167}
1168impl Deref for TWIM2_NS {
1169 type Target = twim0_ns::RegisterBlock;
1170 #[inline(always)]
1171 fn deref(&self) -> &Self::Target {
1172 unsafe { &*Self::PTR }
1173 }
1174}
1175impl core::fmt::Debug for TWIM2_NS {
1176 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1177 f.debug_struct("TWIM2_NS").finish()
1178 }
1179}
1180#[doc = "I2C compatible Two-Wire Master Interface with EasyDMA 4"]
1181pub use twim0_ns as twim2_ns;
1182#[doc = "I2C compatible Two-Wire Slave Interface with EasyDMA 4"]
1183pub struct TWIS2_NS {
1184 _marker: PhantomData<*const ()>,
1185}
1186unsafe impl Send for TWIS2_NS {}
1187impl TWIS2_NS {
1188 #[doc = r"Pointer to the register block"]
1189 pub const PTR: *const twis0_ns::RegisterBlock = 0x4000_a000 as *const _;
1190 #[doc = r"Return the pointer to the register block"]
1191 #[inline(always)]
1192 pub const fn ptr() -> *const twis0_ns::RegisterBlock {
1193 Self::PTR
1194 }
1195}
1196impl Deref for TWIS2_NS {
1197 type Target = twis0_ns::RegisterBlock;
1198 #[inline(always)]
1199 fn deref(&self) -> &Self::Target {
1200 unsafe { &*Self::PTR }
1201 }
1202}
1203impl core::fmt::Debug for TWIS2_NS {
1204 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1205 f.debug_struct("TWIS2_NS").finish()
1206 }
1207}
1208#[doc = "I2C compatible Two-Wire Slave Interface with EasyDMA 4"]
1209pub use twis0_ns as twis2_ns;
1210#[doc = "UART with EasyDMA 4"]
1211pub struct UARTE2_NS {
1212 _marker: PhantomData<*const ()>,
1213}
1214unsafe impl Send for UARTE2_NS {}
1215impl UARTE2_NS {
1216 #[doc = r"Pointer to the register block"]
1217 pub const PTR: *const uarte0_ns::RegisterBlock = 0x4000_a000 as *const _;
1218 #[doc = r"Return the pointer to the register block"]
1219 #[inline(always)]
1220 pub const fn ptr() -> *const uarte0_ns::RegisterBlock {
1221 Self::PTR
1222 }
1223}
1224impl Deref for UARTE2_NS {
1225 type Target = uarte0_ns::RegisterBlock;
1226 #[inline(always)]
1227 fn deref(&self) -> &Self::Target {
1228 unsafe { &*Self::PTR }
1229 }
1230}
1231impl core::fmt::Debug for UARTE2_NS {
1232 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1233 f.debug_struct("UARTE2_NS").finish()
1234 }
1235}
1236#[doc = "UART with EasyDMA 4"]
1237pub use uarte0_ns as uarte2_ns;
1238#[doc = "Serial Peripheral Interface Master with EasyDMA 5"]
1239pub struct SPIM2_S {
1240 _marker: PhantomData<*const ()>,
1241}
1242unsafe impl Send for SPIM2_S {}
1243impl SPIM2_S {
1244 #[doc = r"Pointer to the register block"]
1245 pub const PTR: *const spim0_ns::RegisterBlock = 0x5000_a000 as *const _;
1246 #[doc = r"Return the pointer to the register block"]
1247 #[inline(always)]
1248 pub const fn ptr() -> *const spim0_ns::RegisterBlock {
1249 Self::PTR
1250 }
1251}
1252impl Deref for SPIM2_S {
1253 type Target = spim0_ns::RegisterBlock;
1254 #[inline(always)]
1255 fn deref(&self) -> &Self::Target {
1256 unsafe { &*Self::PTR }
1257 }
1258}
1259impl core::fmt::Debug for SPIM2_S {
1260 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1261 f.debug_struct("SPIM2_S").finish()
1262 }
1263}
1264#[doc = "Serial Peripheral Interface Master with EasyDMA 5"]
1265pub use spim0_ns as spim2_s;
1266#[doc = "SPI Slave 5"]
1267pub struct SPIS2_S {
1268 _marker: PhantomData<*const ()>,
1269}
1270unsafe impl Send for SPIS2_S {}
1271impl SPIS2_S {
1272 #[doc = r"Pointer to the register block"]
1273 pub const PTR: *const spis0_ns::RegisterBlock = 0x5000_a000 as *const _;
1274 #[doc = r"Return the pointer to the register block"]
1275 #[inline(always)]
1276 pub const fn ptr() -> *const spis0_ns::RegisterBlock {
1277 Self::PTR
1278 }
1279}
1280impl Deref for SPIS2_S {
1281 type Target = spis0_ns::RegisterBlock;
1282 #[inline(always)]
1283 fn deref(&self) -> &Self::Target {
1284 unsafe { &*Self::PTR }
1285 }
1286}
1287impl core::fmt::Debug for SPIS2_S {
1288 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1289 f.debug_struct("SPIS2_S").finish()
1290 }
1291}
1292#[doc = "SPI Slave 5"]
1293pub use spis0_ns as spis2_s;
1294#[doc = "I2C compatible Two-Wire Master Interface with EasyDMA 5"]
1295pub struct TWIM2_S {
1296 _marker: PhantomData<*const ()>,
1297}
1298unsafe impl Send for TWIM2_S {}
1299impl TWIM2_S {
1300 #[doc = r"Pointer to the register block"]
1301 pub const PTR: *const twim0_ns::RegisterBlock = 0x5000_a000 as *const _;
1302 #[doc = r"Return the pointer to the register block"]
1303 #[inline(always)]
1304 pub const fn ptr() -> *const twim0_ns::RegisterBlock {
1305 Self::PTR
1306 }
1307}
1308impl Deref for TWIM2_S {
1309 type Target = twim0_ns::RegisterBlock;
1310 #[inline(always)]
1311 fn deref(&self) -> &Self::Target {
1312 unsafe { &*Self::PTR }
1313 }
1314}
1315impl core::fmt::Debug for TWIM2_S {
1316 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1317 f.debug_struct("TWIM2_S").finish()
1318 }
1319}
1320#[doc = "I2C compatible Two-Wire Master Interface with EasyDMA 5"]
1321pub use twim0_ns as twim2_s;
1322#[doc = "I2C compatible Two-Wire Slave Interface with EasyDMA 5"]
1323pub struct TWIS2_S {
1324 _marker: PhantomData<*const ()>,
1325}
1326unsafe impl Send for TWIS2_S {}
1327impl TWIS2_S {
1328 #[doc = r"Pointer to the register block"]
1329 pub const PTR: *const twis0_ns::RegisterBlock = 0x5000_a000 as *const _;
1330 #[doc = r"Return the pointer to the register block"]
1331 #[inline(always)]
1332 pub const fn ptr() -> *const twis0_ns::RegisterBlock {
1333 Self::PTR
1334 }
1335}
1336impl Deref for TWIS2_S {
1337 type Target = twis0_ns::RegisterBlock;
1338 #[inline(always)]
1339 fn deref(&self) -> &Self::Target {
1340 unsafe { &*Self::PTR }
1341 }
1342}
1343impl core::fmt::Debug for TWIS2_S {
1344 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1345 f.debug_struct("TWIS2_S").finish()
1346 }
1347}
1348#[doc = "I2C compatible Two-Wire Slave Interface with EasyDMA 5"]
1349pub use twis0_ns as twis2_s;
1350#[doc = "UART with EasyDMA 5"]
1351pub struct UARTE2_S {
1352 _marker: PhantomData<*const ()>,
1353}
1354unsafe impl Send for UARTE2_S {}
1355impl UARTE2_S {
1356 #[doc = r"Pointer to the register block"]
1357 pub const PTR: *const uarte0_ns::RegisterBlock = 0x5000_a000 as *const _;
1358 #[doc = r"Return the pointer to the register block"]
1359 #[inline(always)]
1360 pub const fn ptr() -> *const uarte0_ns::RegisterBlock {
1361 Self::PTR
1362 }
1363}
1364impl Deref for UARTE2_S {
1365 type Target = uarte0_ns::RegisterBlock;
1366 #[inline(always)]
1367 fn deref(&self) -> &Self::Target {
1368 unsafe { &*Self::PTR }
1369 }
1370}
1371impl core::fmt::Debug for UARTE2_S {
1372 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1373 f.debug_struct("UARTE2_S").finish()
1374 }
1375}
1376#[doc = "UART with EasyDMA 5"]
1377pub use uarte0_ns as uarte2_s;
1378#[doc = "Serial Peripheral Interface Master with EasyDMA 6"]
1379pub struct SPIM3_NS {
1380 _marker: PhantomData<*const ()>,
1381}
1382unsafe impl Send for SPIM3_NS {}
1383impl SPIM3_NS {
1384 #[doc = r"Pointer to the register block"]
1385 pub const PTR: *const spim0_ns::RegisterBlock = 0x4000_b000 as *const _;
1386 #[doc = r"Return the pointer to the register block"]
1387 #[inline(always)]
1388 pub const fn ptr() -> *const spim0_ns::RegisterBlock {
1389 Self::PTR
1390 }
1391}
1392impl Deref for SPIM3_NS {
1393 type Target = spim0_ns::RegisterBlock;
1394 #[inline(always)]
1395 fn deref(&self) -> &Self::Target {
1396 unsafe { &*Self::PTR }
1397 }
1398}
1399impl core::fmt::Debug for SPIM3_NS {
1400 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1401 f.debug_struct("SPIM3_NS").finish()
1402 }
1403}
1404#[doc = "Serial Peripheral Interface Master with EasyDMA 6"]
1405pub use spim0_ns as spim3_ns;
1406#[doc = "SPI Slave 6"]
1407pub struct SPIS3_NS {
1408 _marker: PhantomData<*const ()>,
1409}
1410unsafe impl Send for SPIS3_NS {}
1411impl SPIS3_NS {
1412 #[doc = r"Pointer to the register block"]
1413 pub const PTR: *const spis0_ns::RegisterBlock = 0x4000_b000 as *const _;
1414 #[doc = r"Return the pointer to the register block"]
1415 #[inline(always)]
1416 pub const fn ptr() -> *const spis0_ns::RegisterBlock {
1417 Self::PTR
1418 }
1419}
1420impl Deref for SPIS3_NS {
1421 type Target = spis0_ns::RegisterBlock;
1422 #[inline(always)]
1423 fn deref(&self) -> &Self::Target {
1424 unsafe { &*Self::PTR }
1425 }
1426}
1427impl core::fmt::Debug for SPIS3_NS {
1428 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1429 f.debug_struct("SPIS3_NS").finish()
1430 }
1431}
1432#[doc = "SPI Slave 6"]
1433pub use spis0_ns as spis3_ns;
1434#[doc = "I2C compatible Two-Wire Master Interface with EasyDMA 6"]
1435pub struct TWIM3_NS {
1436 _marker: PhantomData<*const ()>,
1437}
1438unsafe impl Send for TWIM3_NS {}
1439impl TWIM3_NS {
1440 #[doc = r"Pointer to the register block"]
1441 pub const PTR: *const twim0_ns::RegisterBlock = 0x4000_b000 as *const _;
1442 #[doc = r"Return the pointer to the register block"]
1443 #[inline(always)]
1444 pub const fn ptr() -> *const twim0_ns::RegisterBlock {
1445 Self::PTR
1446 }
1447}
1448impl Deref for TWIM3_NS {
1449 type Target = twim0_ns::RegisterBlock;
1450 #[inline(always)]
1451 fn deref(&self) -> &Self::Target {
1452 unsafe { &*Self::PTR }
1453 }
1454}
1455impl core::fmt::Debug for TWIM3_NS {
1456 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1457 f.debug_struct("TWIM3_NS").finish()
1458 }
1459}
1460#[doc = "I2C compatible Two-Wire Master Interface with EasyDMA 6"]
1461pub use twim0_ns as twim3_ns;
1462#[doc = "I2C compatible Two-Wire Slave Interface with EasyDMA 6"]
1463pub struct TWIS3_NS {
1464 _marker: PhantomData<*const ()>,
1465}
1466unsafe impl Send for TWIS3_NS {}
1467impl TWIS3_NS {
1468 #[doc = r"Pointer to the register block"]
1469 pub const PTR: *const twis0_ns::RegisterBlock = 0x4000_b000 as *const _;
1470 #[doc = r"Return the pointer to the register block"]
1471 #[inline(always)]
1472 pub const fn ptr() -> *const twis0_ns::RegisterBlock {
1473 Self::PTR
1474 }
1475}
1476impl Deref for TWIS3_NS {
1477 type Target = twis0_ns::RegisterBlock;
1478 #[inline(always)]
1479 fn deref(&self) -> &Self::Target {
1480 unsafe { &*Self::PTR }
1481 }
1482}
1483impl core::fmt::Debug for TWIS3_NS {
1484 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1485 f.debug_struct("TWIS3_NS").finish()
1486 }
1487}
1488#[doc = "I2C compatible Two-Wire Slave Interface with EasyDMA 6"]
1489pub use twis0_ns as twis3_ns;
1490#[doc = "UART with EasyDMA 6"]
1491pub struct UARTE3_NS {
1492 _marker: PhantomData<*const ()>,
1493}
1494unsafe impl Send for UARTE3_NS {}
1495impl UARTE3_NS {
1496 #[doc = r"Pointer to the register block"]
1497 pub const PTR: *const uarte0_ns::RegisterBlock = 0x4000_b000 as *const _;
1498 #[doc = r"Return the pointer to the register block"]
1499 #[inline(always)]
1500 pub const fn ptr() -> *const uarte0_ns::RegisterBlock {
1501 Self::PTR
1502 }
1503}
1504impl Deref for UARTE3_NS {
1505 type Target = uarte0_ns::RegisterBlock;
1506 #[inline(always)]
1507 fn deref(&self) -> &Self::Target {
1508 unsafe { &*Self::PTR }
1509 }
1510}
1511impl core::fmt::Debug for UARTE3_NS {
1512 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1513 f.debug_struct("UARTE3_NS").finish()
1514 }
1515}
1516#[doc = "UART with EasyDMA 6"]
1517pub use uarte0_ns as uarte3_ns;
1518#[doc = "Serial Peripheral Interface Master with EasyDMA 7"]
1519pub struct SPIM3_S {
1520 _marker: PhantomData<*const ()>,
1521}
1522unsafe impl Send for SPIM3_S {}
1523impl SPIM3_S {
1524 #[doc = r"Pointer to the register block"]
1525 pub const PTR: *const spim0_ns::RegisterBlock = 0x5000_b000 as *const _;
1526 #[doc = r"Return the pointer to the register block"]
1527 #[inline(always)]
1528 pub const fn ptr() -> *const spim0_ns::RegisterBlock {
1529 Self::PTR
1530 }
1531}
1532impl Deref for SPIM3_S {
1533 type Target = spim0_ns::RegisterBlock;
1534 #[inline(always)]
1535 fn deref(&self) -> &Self::Target {
1536 unsafe { &*Self::PTR }
1537 }
1538}
1539impl core::fmt::Debug for SPIM3_S {
1540 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1541 f.debug_struct("SPIM3_S").finish()
1542 }
1543}
1544#[doc = "Serial Peripheral Interface Master with EasyDMA 7"]
1545pub use spim0_ns as spim3_s;
1546#[doc = "SPI Slave 7"]
1547pub struct SPIS3_S {
1548 _marker: PhantomData<*const ()>,
1549}
1550unsafe impl Send for SPIS3_S {}
1551impl SPIS3_S {
1552 #[doc = r"Pointer to the register block"]
1553 pub const PTR: *const spis0_ns::RegisterBlock = 0x5000_b000 as *const _;
1554 #[doc = r"Return the pointer to the register block"]
1555 #[inline(always)]
1556 pub const fn ptr() -> *const spis0_ns::RegisterBlock {
1557 Self::PTR
1558 }
1559}
1560impl Deref for SPIS3_S {
1561 type Target = spis0_ns::RegisterBlock;
1562 #[inline(always)]
1563 fn deref(&self) -> &Self::Target {
1564 unsafe { &*Self::PTR }
1565 }
1566}
1567impl core::fmt::Debug for SPIS3_S {
1568 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1569 f.debug_struct("SPIS3_S").finish()
1570 }
1571}
1572#[doc = "SPI Slave 7"]
1573pub use spis0_ns as spis3_s;
1574#[doc = "I2C compatible Two-Wire Master Interface with EasyDMA 7"]
1575pub struct TWIM3_S {
1576 _marker: PhantomData<*const ()>,
1577}
1578unsafe impl Send for TWIM3_S {}
1579impl TWIM3_S {
1580 #[doc = r"Pointer to the register block"]
1581 pub const PTR: *const twim0_ns::RegisterBlock = 0x5000_b000 as *const _;
1582 #[doc = r"Return the pointer to the register block"]
1583 #[inline(always)]
1584 pub const fn ptr() -> *const twim0_ns::RegisterBlock {
1585 Self::PTR
1586 }
1587}
1588impl Deref for TWIM3_S {
1589 type Target = twim0_ns::RegisterBlock;
1590 #[inline(always)]
1591 fn deref(&self) -> &Self::Target {
1592 unsafe { &*Self::PTR }
1593 }
1594}
1595impl core::fmt::Debug for TWIM3_S {
1596 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1597 f.debug_struct("TWIM3_S").finish()
1598 }
1599}
1600#[doc = "I2C compatible Two-Wire Master Interface with EasyDMA 7"]
1601pub use twim0_ns as twim3_s;
1602#[doc = "I2C compatible Two-Wire Slave Interface with EasyDMA 7"]
1603pub struct TWIS3_S {
1604 _marker: PhantomData<*const ()>,
1605}
1606unsafe impl Send for TWIS3_S {}
1607impl TWIS3_S {
1608 #[doc = r"Pointer to the register block"]
1609 pub const PTR: *const twis0_ns::RegisterBlock = 0x5000_b000 as *const _;
1610 #[doc = r"Return the pointer to the register block"]
1611 #[inline(always)]
1612 pub const fn ptr() -> *const twis0_ns::RegisterBlock {
1613 Self::PTR
1614 }
1615}
1616impl Deref for TWIS3_S {
1617 type Target = twis0_ns::RegisterBlock;
1618 #[inline(always)]
1619 fn deref(&self) -> &Self::Target {
1620 unsafe { &*Self::PTR }
1621 }
1622}
1623impl core::fmt::Debug for TWIS3_S {
1624 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1625 f.debug_struct("TWIS3_S").finish()
1626 }
1627}
1628#[doc = "I2C compatible Two-Wire Slave Interface with EasyDMA 7"]
1629pub use twis0_ns as twis3_s;
1630#[doc = "UART with EasyDMA 7"]
1631pub struct UARTE3_S {
1632 _marker: PhantomData<*const ()>,
1633}
1634unsafe impl Send for UARTE3_S {}
1635impl UARTE3_S {
1636 #[doc = r"Pointer to the register block"]
1637 pub const PTR: *const uarte0_ns::RegisterBlock = 0x5000_b000 as *const _;
1638 #[doc = r"Return the pointer to the register block"]
1639 #[inline(always)]
1640 pub const fn ptr() -> *const uarte0_ns::RegisterBlock {
1641 Self::PTR
1642 }
1643}
1644impl Deref for UARTE3_S {
1645 type Target = uarte0_ns::RegisterBlock;
1646 #[inline(always)]
1647 fn deref(&self) -> &Self::Target {
1648 unsafe { &*Self::PTR }
1649 }
1650}
1651impl core::fmt::Debug for UARTE3_S {
1652 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1653 f.debug_struct("UARTE3_S").finish()
1654 }
1655}
1656#[doc = "UART with EasyDMA 7"]
1657pub use uarte0_ns as uarte3_s;
1658#[doc = "GPIO Tasks and Events 0"]
1659pub struct GPIOTE0_S {
1660 _marker: PhantomData<*const ()>,
1661}
1662unsafe impl Send for GPIOTE0_S {}
1663impl GPIOTE0_S {
1664 #[doc = r"Pointer to the register block"]
1665 pub const PTR: *const gpiote0_s::RegisterBlock = 0x5000_d000 as *const _;
1666 #[doc = r"Return the pointer to the register block"]
1667 #[inline(always)]
1668 pub const fn ptr() -> *const gpiote0_s::RegisterBlock {
1669 Self::PTR
1670 }
1671}
1672impl Deref for GPIOTE0_S {
1673 type Target = gpiote0_s::RegisterBlock;
1674 #[inline(always)]
1675 fn deref(&self) -> &Self::Target {
1676 unsafe { &*Self::PTR }
1677 }
1678}
1679impl core::fmt::Debug for GPIOTE0_S {
1680 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1681 f.debug_struct("GPIOTE0_S").finish()
1682 }
1683}
1684#[doc = "GPIO Tasks and Events 0"]
1685pub mod gpiote0_s;
1686#[doc = "Analog to Digital Converter 0"]
1687pub struct SAADC_NS {
1688 _marker: PhantomData<*const ()>,
1689}
1690unsafe impl Send for SAADC_NS {}
1691impl SAADC_NS {
1692 #[doc = r"Pointer to the register block"]
1693 pub const PTR: *const saadc_ns::RegisterBlock = 0x4000_e000 as *const _;
1694 #[doc = r"Return the pointer to the register block"]
1695 #[inline(always)]
1696 pub const fn ptr() -> *const saadc_ns::RegisterBlock {
1697 Self::PTR
1698 }
1699}
1700impl Deref for SAADC_NS {
1701 type Target = saadc_ns::RegisterBlock;
1702 #[inline(always)]
1703 fn deref(&self) -> &Self::Target {
1704 unsafe { &*Self::PTR }
1705 }
1706}
1707impl core::fmt::Debug for SAADC_NS {
1708 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1709 f.debug_struct("SAADC_NS").finish()
1710 }
1711}
1712#[doc = "Analog to Digital Converter 0"]
1713pub mod saadc_ns;
1714#[doc = "Analog to Digital Converter 1"]
1715pub struct SAADC_S {
1716 _marker: PhantomData<*const ()>,
1717}
1718unsafe impl Send for SAADC_S {}
1719impl SAADC_S {
1720 #[doc = r"Pointer to the register block"]
1721 pub const PTR: *const saadc_ns::RegisterBlock = 0x5000_e000 as *const _;
1722 #[doc = r"Return the pointer to the register block"]
1723 #[inline(always)]
1724 pub const fn ptr() -> *const saadc_ns::RegisterBlock {
1725 Self::PTR
1726 }
1727}
1728impl Deref for SAADC_S {
1729 type Target = saadc_ns::RegisterBlock;
1730 #[inline(always)]
1731 fn deref(&self) -> &Self::Target {
1732 unsafe { &*Self::PTR }
1733 }
1734}
1735impl core::fmt::Debug for SAADC_S {
1736 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1737 f.debug_struct("SAADC_S").finish()
1738 }
1739}
1740#[doc = "Analog to Digital Converter 1"]
1741pub use saadc_ns as saadc_s;
1742#[doc = "Timer/Counter 0"]
1743pub struct TIMER0_NS {
1744 _marker: PhantomData<*const ()>,
1745}
1746unsafe impl Send for TIMER0_NS {}
1747impl TIMER0_NS {
1748 #[doc = r"Pointer to the register block"]
1749 pub const PTR: *const timer0_ns::RegisterBlock = 0x4000_f000 as *const _;
1750 #[doc = r"Return the pointer to the register block"]
1751 #[inline(always)]
1752 pub const fn ptr() -> *const timer0_ns::RegisterBlock {
1753 Self::PTR
1754 }
1755}
1756impl Deref for TIMER0_NS {
1757 type Target = timer0_ns::RegisterBlock;
1758 #[inline(always)]
1759 fn deref(&self) -> &Self::Target {
1760 unsafe { &*Self::PTR }
1761 }
1762}
1763impl core::fmt::Debug for TIMER0_NS {
1764 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1765 f.debug_struct("TIMER0_NS").finish()
1766 }
1767}
1768#[doc = "Timer/Counter 0"]
1769pub mod timer0_ns;
1770#[doc = "Timer/Counter 1"]
1771pub struct TIMER0_S {
1772 _marker: PhantomData<*const ()>,
1773}
1774unsafe impl Send for TIMER0_S {}
1775impl TIMER0_S {
1776 #[doc = r"Pointer to the register block"]
1777 pub const PTR: *const timer0_ns::RegisterBlock = 0x5000_f000 as *const _;
1778 #[doc = r"Return the pointer to the register block"]
1779 #[inline(always)]
1780 pub const fn ptr() -> *const timer0_ns::RegisterBlock {
1781 Self::PTR
1782 }
1783}
1784impl Deref for TIMER0_S {
1785 type Target = timer0_ns::RegisterBlock;
1786 #[inline(always)]
1787 fn deref(&self) -> &Self::Target {
1788 unsafe { &*Self::PTR }
1789 }
1790}
1791impl core::fmt::Debug for TIMER0_S {
1792 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1793 f.debug_struct("TIMER0_S").finish()
1794 }
1795}
1796#[doc = "Timer/Counter 1"]
1797pub use timer0_ns as timer0_s;
1798#[doc = "Timer/Counter 2"]
1799pub struct TIMER1_NS {
1800 _marker: PhantomData<*const ()>,
1801}
1802unsafe impl Send for TIMER1_NS {}
1803impl TIMER1_NS {
1804 #[doc = r"Pointer to the register block"]
1805 pub const PTR: *const timer0_ns::RegisterBlock = 0x4001_0000 as *const _;
1806 #[doc = r"Return the pointer to the register block"]
1807 #[inline(always)]
1808 pub const fn ptr() -> *const timer0_ns::RegisterBlock {
1809 Self::PTR
1810 }
1811}
1812impl Deref for TIMER1_NS {
1813 type Target = timer0_ns::RegisterBlock;
1814 #[inline(always)]
1815 fn deref(&self) -> &Self::Target {
1816 unsafe { &*Self::PTR }
1817 }
1818}
1819impl core::fmt::Debug for TIMER1_NS {
1820 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1821 f.debug_struct("TIMER1_NS").finish()
1822 }
1823}
1824#[doc = "Timer/Counter 2"]
1825pub use timer0_ns as timer1_ns;
1826#[doc = "Timer/Counter 3"]
1827pub struct TIMER1_S {
1828 _marker: PhantomData<*const ()>,
1829}
1830unsafe impl Send for TIMER1_S {}
1831impl TIMER1_S {
1832 #[doc = r"Pointer to the register block"]
1833 pub const PTR: *const timer0_ns::RegisterBlock = 0x5001_0000 as *const _;
1834 #[doc = r"Return the pointer to the register block"]
1835 #[inline(always)]
1836 pub const fn ptr() -> *const timer0_ns::RegisterBlock {
1837 Self::PTR
1838 }
1839}
1840impl Deref for TIMER1_S {
1841 type Target = timer0_ns::RegisterBlock;
1842 #[inline(always)]
1843 fn deref(&self) -> &Self::Target {
1844 unsafe { &*Self::PTR }
1845 }
1846}
1847impl core::fmt::Debug for TIMER1_S {
1848 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1849 f.debug_struct("TIMER1_S").finish()
1850 }
1851}
1852#[doc = "Timer/Counter 3"]
1853pub use timer0_ns as timer1_s;
1854#[doc = "Timer/Counter 4"]
1855pub struct TIMER2_NS {
1856 _marker: PhantomData<*const ()>,
1857}
1858unsafe impl Send for TIMER2_NS {}
1859impl TIMER2_NS {
1860 #[doc = r"Pointer to the register block"]
1861 pub const PTR: *const timer0_ns::RegisterBlock = 0x4001_1000 as *const _;
1862 #[doc = r"Return the pointer to the register block"]
1863 #[inline(always)]
1864 pub const fn ptr() -> *const timer0_ns::RegisterBlock {
1865 Self::PTR
1866 }
1867}
1868impl Deref for TIMER2_NS {
1869 type Target = timer0_ns::RegisterBlock;
1870 #[inline(always)]
1871 fn deref(&self) -> &Self::Target {
1872 unsafe { &*Self::PTR }
1873 }
1874}
1875impl core::fmt::Debug for TIMER2_NS {
1876 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1877 f.debug_struct("TIMER2_NS").finish()
1878 }
1879}
1880#[doc = "Timer/Counter 4"]
1881pub use timer0_ns as timer2_ns;
1882#[doc = "Timer/Counter 5"]
1883pub struct TIMER2_S {
1884 _marker: PhantomData<*const ()>,
1885}
1886unsafe impl Send for TIMER2_S {}
1887impl TIMER2_S {
1888 #[doc = r"Pointer to the register block"]
1889 pub const PTR: *const timer0_ns::RegisterBlock = 0x5001_1000 as *const _;
1890 #[doc = r"Return the pointer to the register block"]
1891 #[inline(always)]
1892 pub const fn ptr() -> *const timer0_ns::RegisterBlock {
1893 Self::PTR
1894 }
1895}
1896impl Deref for TIMER2_S {
1897 type Target = timer0_ns::RegisterBlock;
1898 #[inline(always)]
1899 fn deref(&self) -> &Self::Target {
1900 unsafe { &*Self::PTR }
1901 }
1902}
1903impl core::fmt::Debug for TIMER2_S {
1904 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1905 f.debug_struct("TIMER2_S").finish()
1906 }
1907}
1908#[doc = "Timer/Counter 5"]
1909pub use timer0_ns as timer2_s;
1910#[doc = "Real-time counter 0"]
1911pub struct RTC0_NS {
1912 _marker: PhantomData<*const ()>,
1913}
1914unsafe impl Send for RTC0_NS {}
1915impl RTC0_NS {
1916 #[doc = r"Pointer to the register block"]
1917 pub const PTR: *const rtc0_ns::RegisterBlock = 0x4001_4000 as *const _;
1918 #[doc = r"Return the pointer to the register block"]
1919 #[inline(always)]
1920 pub const fn ptr() -> *const rtc0_ns::RegisterBlock {
1921 Self::PTR
1922 }
1923}
1924impl Deref for RTC0_NS {
1925 type Target = rtc0_ns::RegisterBlock;
1926 #[inline(always)]
1927 fn deref(&self) -> &Self::Target {
1928 unsafe { &*Self::PTR }
1929 }
1930}
1931impl core::fmt::Debug for RTC0_NS {
1932 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1933 f.debug_struct("RTC0_NS").finish()
1934 }
1935}
1936#[doc = "Real-time counter 0"]
1937pub mod rtc0_ns;
1938#[doc = "Real-time counter 1"]
1939pub struct RTC0_S {
1940 _marker: PhantomData<*const ()>,
1941}
1942unsafe impl Send for RTC0_S {}
1943impl RTC0_S {
1944 #[doc = r"Pointer to the register block"]
1945 pub const PTR: *const rtc0_ns::RegisterBlock = 0x5001_4000 as *const _;
1946 #[doc = r"Return the pointer to the register block"]
1947 #[inline(always)]
1948 pub const fn ptr() -> *const rtc0_ns::RegisterBlock {
1949 Self::PTR
1950 }
1951}
1952impl Deref for RTC0_S {
1953 type Target = rtc0_ns::RegisterBlock;
1954 #[inline(always)]
1955 fn deref(&self) -> &Self::Target {
1956 unsafe { &*Self::PTR }
1957 }
1958}
1959impl core::fmt::Debug for RTC0_S {
1960 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1961 f.debug_struct("RTC0_S").finish()
1962 }
1963}
1964#[doc = "Real-time counter 1"]
1965pub use rtc0_ns as rtc0_s;
1966#[doc = "Real-time counter 2"]
1967pub struct RTC1_NS {
1968 _marker: PhantomData<*const ()>,
1969}
1970unsafe impl Send for RTC1_NS {}
1971impl RTC1_NS {
1972 #[doc = r"Pointer to the register block"]
1973 pub const PTR: *const rtc0_ns::RegisterBlock = 0x4001_5000 as *const _;
1974 #[doc = r"Return the pointer to the register block"]
1975 #[inline(always)]
1976 pub const fn ptr() -> *const rtc0_ns::RegisterBlock {
1977 Self::PTR
1978 }
1979}
1980impl Deref for RTC1_NS {
1981 type Target = rtc0_ns::RegisterBlock;
1982 #[inline(always)]
1983 fn deref(&self) -> &Self::Target {
1984 unsafe { &*Self::PTR }
1985 }
1986}
1987impl core::fmt::Debug for RTC1_NS {
1988 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1989 f.debug_struct("RTC1_NS").finish()
1990 }
1991}
1992#[doc = "Real-time counter 2"]
1993pub use rtc0_ns as rtc1_ns;
1994#[doc = "Real-time counter 3"]
1995pub struct RTC1_S {
1996 _marker: PhantomData<*const ()>,
1997}
1998unsafe impl Send for RTC1_S {}
1999impl RTC1_S {
2000 #[doc = r"Pointer to the register block"]
2001 pub const PTR: *const rtc0_ns::RegisterBlock = 0x5001_5000 as *const _;
2002 #[doc = r"Return the pointer to the register block"]
2003 #[inline(always)]
2004 pub const fn ptr() -> *const rtc0_ns::RegisterBlock {
2005 Self::PTR
2006 }
2007}
2008impl Deref for RTC1_S {
2009 type Target = rtc0_ns::RegisterBlock;
2010 #[inline(always)]
2011 fn deref(&self) -> &Self::Target {
2012 unsafe { &*Self::PTR }
2013 }
2014}
2015impl core::fmt::Debug for RTC1_S {
2016 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2017 f.debug_struct("RTC1_S").finish()
2018 }
2019}
2020#[doc = "Real-time counter 3"]
2021pub use rtc0_ns as rtc1_s;
2022#[doc = "Distributed Programmable Peripheral Interconnect Controller 0"]
2023pub struct DPPIC_NS {
2024 _marker: PhantomData<*const ()>,
2025}
2026unsafe impl Send for DPPIC_NS {}
2027impl DPPIC_NS {
2028 #[doc = r"Pointer to the register block"]
2029 pub const PTR: *const dppic_ns::RegisterBlock = 0x4001_7000 as *const _;
2030 #[doc = r"Return the pointer to the register block"]
2031 #[inline(always)]
2032 pub const fn ptr() -> *const dppic_ns::RegisterBlock {
2033 Self::PTR
2034 }
2035}
2036impl Deref for DPPIC_NS {
2037 type Target = dppic_ns::RegisterBlock;
2038 #[inline(always)]
2039 fn deref(&self) -> &Self::Target {
2040 unsafe { &*Self::PTR }
2041 }
2042}
2043impl core::fmt::Debug for DPPIC_NS {
2044 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2045 f.debug_struct("DPPIC_NS").finish()
2046 }
2047}
2048#[doc = "Distributed Programmable Peripheral Interconnect Controller 0"]
2049pub mod dppic_ns;
2050#[doc = "Distributed Programmable Peripheral Interconnect Controller 1"]
2051pub struct DPPIC_S {
2052 _marker: PhantomData<*const ()>,
2053}
2054unsafe impl Send for DPPIC_S {}
2055impl DPPIC_S {
2056 #[doc = r"Pointer to the register block"]
2057 pub const PTR: *const dppic_ns::RegisterBlock = 0x5001_7000 as *const _;
2058 #[doc = r"Return the pointer to the register block"]
2059 #[inline(always)]
2060 pub const fn ptr() -> *const dppic_ns::RegisterBlock {
2061 Self::PTR
2062 }
2063}
2064impl Deref for DPPIC_S {
2065 type Target = dppic_ns::RegisterBlock;
2066 #[inline(always)]
2067 fn deref(&self) -> &Self::Target {
2068 unsafe { &*Self::PTR }
2069 }
2070}
2071impl core::fmt::Debug for DPPIC_S {
2072 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2073 f.debug_struct("DPPIC_S").finish()
2074 }
2075}
2076#[doc = "Distributed Programmable Peripheral Interconnect Controller 1"]
2077pub use dppic_ns as dppic_s;
2078#[doc = "Watchdog Timer 0"]
2079pub struct WDT_NS {
2080 _marker: PhantomData<*const ()>,
2081}
2082unsafe impl Send for WDT_NS {}
2083impl WDT_NS {
2084 #[doc = r"Pointer to the register block"]
2085 pub const PTR: *const wdt_ns::RegisterBlock = 0x4001_8000 as *const _;
2086 #[doc = r"Return the pointer to the register block"]
2087 #[inline(always)]
2088 pub const fn ptr() -> *const wdt_ns::RegisterBlock {
2089 Self::PTR
2090 }
2091}
2092impl Deref for WDT_NS {
2093 type Target = wdt_ns::RegisterBlock;
2094 #[inline(always)]
2095 fn deref(&self) -> &Self::Target {
2096 unsafe { &*Self::PTR }
2097 }
2098}
2099impl core::fmt::Debug for WDT_NS {
2100 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2101 f.debug_struct("WDT_NS").finish()
2102 }
2103}
2104#[doc = "Watchdog Timer 0"]
2105pub mod wdt_ns;
2106#[doc = "Watchdog Timer 1"]
2107pub struct WDT_S {
2108 _marker: PhantomData<*const ()>,
2109}
2110unsafe impl Send for WDT_S {}
2111impl WDT_S {
2112 #[doc = r"Pointer to the register block"]
2113 pub const PTR: *const wdt_ns::RegisterBlock = 0x5001_8000 as *const _;
2114 #[doc = r"Return the pointer to the register block"]
2115 #[inline(always)]
2116 pub const fn ptr() -> *const wdt_ns::RegisterBlock {
2117 Self::PTR
2118 }
2119}
2120impl Deref for WDT_S {
2121 type Target = wdt_ns::RegisterBlock;
2122 #[inline(always)]
2123 fn deref(&self) -> &Self::Target {
2124 unsafe { &*Self::PTR }
2125 }
2126}
2127impl core::fmt::Debug for WDT_S {
2128 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2129 f.debug_struct("WDT_S").finish()
2130 }
2131}
2132#[doc = "Watchdog Timer 1"]
2133pub use wdt_ns as wdt_s;
2134#[doc = "Event generator unit 0"]
2135pub struct EGU0_NS {
2136 _marker: PhantomData<*const ()>,
2137}
2138unsafe impl Send for EGU0_NS {}
2139impl EGU0_NS {
2140 #[doc = r"Pointer to the register block"]
2141 pub const PTR: *const egu0_ns::RegisterBlock = 0x4001_b000 as *const _;
2142 #[doc = r"Return the pointer to the register block"]
2143 #[inline(always)]
2144 pub const fn ptr() -> *const egu0_ns::RegisterBlock {
2145 Self::PTR
2146 }
2147}
2148impl Deref for EGU0_NS {
2149 type Target = egu0_ns::RegisterBlock;
2150 #[inline(always)]
2151 fn deref(&self) -> &Self::Target {
2152 unsafe { &*Self::PTR }
2153 }
2154}
2155impl core::fmt::Debug for EGU0_NS {
2156 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2157 f.debug_struct("EGU0_NS").finish()
2158 }
2159}
2160#[doc = "Event generator unit 0"]
2161pub mod egu0_ns;
2162#[doc = "Event generator unit 1"]
2163pub struct EGU0_S {
2164 _marker: PhantomData<*const ()>,
2165}
2166unsafe impl Send for EGU0_S {}
2167impl EGU0_S {
2168 #[doc = r"Pointer to the register block"]
2169 pub const PTR: *const egu0_ns::RegisterBlock = 0x5001_b000 as *const _;
2170 #[doc = r"Return the pointer to the register block"]
2171 #[inline(always)]
2172 pub const fn ptr() -> *const egu0_ns::RegisterBlock {
2173 Self::PTR
2174 }
2175}
2176impl Deref for EGU0_S {
2177 type Target = egu0_ns::RegisterBlock;
2178 #[inline(always)]
2179 fn deref(&self) -> &Self::Target {
2180 unsafe { &*Self::PTR }
2181 }
2182}
2183impl core::fmt::Debug for EGU0_S {
2184 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2185 f.debug_struct("EGU0_S").finish()
2186 }
2187}
2188#[doc = "Event generator unit 1"]
2189pub use egu0_ns as egu0_s;
2190#[doc = "Event generator unit 2"]
2191pub struct EGU1_NS {
2192 _marker: PhantomData<*const ()>,
2193}
2194unsafe impl Send for EGU1_NS {}
2195impl EGU1_NS {
2196 #[doc = r"Pointer to the register block"]
2197 pub const PTR: *const egu0_ns::RegisterBlock = 0x4001_c000 as *const _;
2198 #[doc = r"Return the pointer to the register block"]
2199 #[inline(always)]
2200 pub const fn ptr() -> *const egu0_ns::RegisterBlock {
2201 Self::PTR
2202 }
2203}
2204impl Deref for EGU1_NS {
2205 type Target = egu0_ns::RegisterBlock;
2206 #[inline(always)]
2207 fn deref(&self) -> &Self::Target {
2208 unsafe { &*Self::PTR }
2209 }
2210}
2211impl core::fmt::Debug for EGU1_NS {
2212 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2213 f.debug_struct("EGU1_NS").finish()
2214 }
2215}
2216#[doc = "Event generator unit 2"]
2217pub use egu0_ns as egu1_ns;
2218#[doc = "Event generator unit 3"]
2219pub struct EGU1_S {
2220 _marker: PhantomData<*const ()>,
2221}
2222unsafe impl Send for EGU1_S {}
2223impl EGU1_S {
2224 #[doc = r"Pointer to the register block"]
2225 pub const PTR: *const egu0_ns::RegisterBlock = 0x5001_c000 as *const _;
2226 #[doc = r"Return the pointer to the register block"]
2227 #[inline(always)]
2228 pub const fn ptr() -> *const egu0_ns::RegisterBlock {
2229 Self::PTR
2230 }
2231}
2232impl Deref for EGU1_S {
2233 type Target = egu0_ns::RegisterBlock;
2234 #[inline(always)]
2235 fn deref(&self) -> &Self::Target {
2236 unsafe { &*Self::PTR }
2237 }
2238}
2239impl core::fmt::Debug for EGU1_S {
2240 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2241 f.debug_struct("EGU1_S").finish()
2242 }
2243}
2244#[doc = "Event generator unit 3"]
2245pub use egu0_ns as egu1_s;
2246#[doc = "Event generator unit 4"]
2247pub struct EGU2_NS {
2248 _marker: PhantomData<*const ()>,
2249}
2250unsafe impl Send for EGU2_NS {}
2251impl EGU2_NS {
2252 #[doc = r"Pointer to the register block"]
2253 pub const PTR: *const egu0_ns::RegisterBlock = 0x4001_d000 as *const _;
2254 #[doc = r"Return the pointer to the register block"]
2255 #[inline(always)]
2256 pub const fn ptr() -> *const egu0_ns::RegisterBlock {
2257 Self::PTR
2258 }
2259}
2260impl Deref for EGU2_NS {
2261 type Target = egu0_ns::RegisterBlock;
2262 #[inline(always)]
2263 fn deref(&self) -> &Self::Target {
2264 unsafe { &*Self::PTR }
2265 }
2266}
2267impl core::fmt::Debug for EGU2_NS {
2268 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2269 f.debug_struct("EGU2_NS").finish()
2270 }
2271}
2272#[doc = "Event generator unit 4"]
2273pub use egu0_ns as egu2_ns;
2274#[doc = "Event generator unit 5"]
2275pub struct EGU2_S {
2276 _marker: PhantomData<*const ()>,
2277}
2278unsafe impl Send for EGU2_S {}
2279impl EGU2_S {
2280 #[doc = r"Pointer to the register block"]
2281 pub const PTR: *const egu0_ns::RegisterBlock = 0x5001_d000 as *const _;
2282 #[doc = r"Return the pointer to the register block"]
2283 #[inline(always)]
2284 pub const fn ptr() -> *const egu0_ns::RegisterBlock {
2285 Self::PTR
2286 }
2287}
2288impl Deref for EGU2_S {
2289 type Target = egu0_ns::RegisterBlock;
2290 #[inline(always)]
2291 fn deref(&self) -> &Self::Target {
2292 unsafe { &*Self::PTR }
2293 }
2294}
2295impl core::fmt::Debug for EGU2_S {
2296 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2297 f.debug_struct("EGU2_S").finish()
2298 }
2299}
2300#[doc = "Event generator unit 5"]
2301pub use egu0_ns as egu2_s;
2302#[doc = "Event generator unit 6"]
2303pub struct EGU3_NS {
2304 _marker: PhantomData<*const ()>,
2305}
2306unsafe impl Send for EGU3_NS {}
2307impl EGU3_NS {
2308 #[doc = r"Pointer to the register block"]
2309 pub const PTR: *const egu0_ns::RegisterBlock = 0x4001_e000 as *const _;
2310 #[doc = r"Return the pointer to the register block"]
2311 #[inline(always)]
2312 pub const fn ptr() -> *const egu0_ns::RegisterBlock {
2313 Self::PTR
2314 }
2315}
2316impl Deref for EGU3_NS {
2317 type Target = egu0_ns::RegisterBlock;
2318 #[inline(always)]
2319 fn deref(&self) -> &Self::Target {
2320 unsafe { &*Self::PTR }
2321 }
2322}
2323impl core::fmt::Debug for EGU3_NS {
2324 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2325 f.debug_struct("EGU3_NS").finish()
2326 }
2327}
2328#[doc = "Event generator unit 6"]
2329pub use egu0_ns as egu3_ns;
2330#[doc = "Event generator unit 7"]
2331pub struct EGU3_S {
2332 _marker: PhantomData<*const ()>,
2333}
2334unsafe impl Send for EGU3_S {}
2335impl EGU3_S {
2336 #[doc = r"Pointer to the register block"]
2337 pub const PTR: *const egu0_ns::RegisterBlock = 0x5001_e000 as *const _;
2338 #[doc = r"Return the pointer to the register block"]
2339 #[inline(always)]
2340 pub const fn ptr() -> *const egu0_ns::RegisterBlock {
2341 Self::PTR
2342 }
2343}
2344impl Deref for EGU3_S {
2345 type Target = egu0_ns::RegisterBlock;
2346 #[inline(always)]
2347 fn deref(&self) -> &Self::Target {
2348 unsafe { &*Self::PTR }
2349 }
2350}
2351impl core::fmt::Debug for EGU3_S {
2352 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2353 f.debug_struct("EGU3_S").finish()
2354 }
2355}
2356#[doc = "Event generator unit 7"]
2357pub use egu0_ns as egu3_s;
2358#[doc = "Event generator unit 8"]
2359pub struct EGU4_NS {
2360 _marker: PhantomData<*const ()>,
2361}
2362unsafe impl Send for EGU4_NS {}
2363impl EGU4_NS {
2364 #[doc = r"Pointer to the register block"]
2365 pub const PTR: *const egu0_ns::RegisterBlock = 0x4001_f000 as *const _;
2366 #[doc = r"Return the pointer to the register block"]
2367 #[inline(always)]
2368 pub const fn ptr() -> *const egu0_ns::RegisterBlock {
2369 Self::PTR
2370 }
2371}
2372impl Deref for EGU4_NS {
2373 type Target = egu0_ns::RegisterBlock;
2374 #[inline(always)]
2375 fn deref(&self) -> &Self::Target {
2376 unsafe { &*Self::PTR }
2377 }
2378}
2379impl core::fmt::Debug for EGU4_NS {
2380 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2381 f.debug_struct("EGU4_NS").finish()
2382 }
2383}
2384#[doc = "Event generator unit 8"]
2385pub use egu0_ns as egu4_ns;
2386#[doc = "Event generator unit 9"]
2387pub struct EGU4_S {
2388 _marker: PhantomData<*const ()>,
2389}
2390unsafe impl Send for EGU4_S {}
2391impl EGU4_S {
2392 #[doc = r"Pointer to the register block"]
2393 pub const PTR: *const egu0_ns::RegisterBlock = 0x5001_f000 as *const _;
2394 #[doc = r"Return the pointer to the register block"]
2395 #[inline(always)]
2396 pub const fn ptr() -> *const egu0_ns::RegisterBlock {
2397 Self::PTR
2398 }
2399}
2400impl Deref for EGU4_S {
2401 type Target = egu0_ns::RegisterBlock;
2402 #[inline(always)]
2403 fn deref(&self) -> &Self::Target {
2404 unsafe { &*Self::PTR }
2405 }
2406}
2407impl core::fmt::Debug for EGU4_S {
2408 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2409 f.debug_struct("EGU4_S").finish()
2410 }
2411}
2412#[doc = "Event generator unit 9"]
2413pub use egu0_ns as egu4_s;
2414#[doc = "Event generator unit 10"]
2415pub struct EGU5_NS {
2416 _marker: PhantomData<*const ()>,
2417}
2418unsafe impl Send for EGU5_NS {}
2419impl EGU5_NS {
2420 #[doc = r"Pointer to the register block"]
2421 pub const PTR: *const egu0_ns::RegisterBlock = 0x4002_0000 as *const _;
2422 #[doc = r"Return the pointer to the register block"]
2423 #[inline(always)]
2424 pub const fn ptr() -> *const egu0_ns::RegisterBlock {
2425 Self::PTR
2426 }
2427}
2428impl Deref for EGU5_NS {
2429 type Target = egu0_ns::RegisterBlock;
2430 #[inline(always)]
2431 fn deref(&self) -> &Self::Target {
2432 unsafe { &*Self::PTR }
2433 }
2434}
2435impl core::fmt::Debug for EGU5_NS {
2436 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2437 f.debug_struct("EGU5_NS").finish()
2438 }
2439}
2440#[doc = "Event generator unit 10"]
2441pub use egu0_ns as egu5_ns;
2442#[doc = "Event generator unit 11"]
2443pub struct EGU5_S {
2444 _marker: PhantomData<*const ()>,
2445}
2446unsafe impl Send for EGU5_S {}
2447impl EGU5_S {
2448 #[doc = r"Pointer to the register block"]
2449 pub const PTR: *const egu0_ns::RegisterBlock = 0x5002_0000 as *const _;
2450 #[doc = r"Return the pointer to the register block"]
2451 #[inline(always)]
2452 pub const fn ptr() -> *const egu0_ns::RegisterBlock {
2453 Self::PTR
2454 }
2455}
2456impl Deref for EGU5_S {
2457 type Target = egu0_ns::RegisterBlock;
2458 #[inline(always)]
2459 fn deref(&self) -> &Self::Target {
2460 unsafe { &*Self::PTR }
2461 }
2462}
2463impl core::fmt::Debug for EGU5_S {
2464 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2465 f.debug_struct("EGU5_S").finish()
2466 }
2467}
2468#[doc = "Event generator unit 11"]
2469pub use egu0_ns as egu5_s;
2470#[doc = "Pulse width modulation unit 0"]
2471pub struct PWM0_NS {
2472 _marker: PhantomData<*const ()>,
2473}
2474unsafe impl Send for PWM0_NS {}
2475impl PWM0_NS {
2476 #[doc = r"Pointer to the register block"]
2477 pub const PTR: *const pwm0_ns::RegisterBlock = 0x4002_1000 as *const _;
2478 #[doc = r"Return the pointer to the register block"]
2479 #[inline(always)]
2480 pub const fn ptr() -> *const pwm0_ns::RegisterBlock {
2481 Self::PTR
2482 }
2483}
2484impl Deref for PWM0_NS {
2485 type Target = pwm0_ns::RegisterBlock;
2486 #[inline(always)]
2487 fn deref(&self) -> &Self::Target {
2488 unsafe { &*Self::PTR }
2489 }
2490}
2491impl core::fmt::Debug for PWM0_NS {
2492 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2493 f.debug_struct("PWM0_NS").finish()
2494 }
2495}
2496#[doc = "Pulse width modulation unit 0"]
2497pub mod pwm0_ns;
2498#[doc = "Pulse width modulation unit 1"]
2499pub struct PWM0_S {
2500 _marker: PhantomData<*const ()>,
2501}
2502unsafe impl Send for PWM0_S {}
2503impl PWM0_S {
2504 #[doc = r"Pointer to the register block"]
2505 pub const PTR: *const pwm0_ns::RegisterBlock = 0x5002_1000 as *const _;
2506 #[doc = r"Return the pointer to the register block"]
2507 #[inline(always)]
2508 pub const fn ptr() -> *const pwm0_ns::RegisterBlock {
2509 Self::PTR
2510 }
2511}
2512impl Deref for PWM0_S {
2513 type Target = pwm0_ns::RegisterBlock;
2514 #[inline(always)]
2515 fn deref(&self) -> &Self::Target {
2516 unsafe { &*Self::PTR }
2517 }
2518}
2519impl core::fmt::Debug for PWM0_S {
2520 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2521 f.debug_struct("PWM0_S").finish()
2522 }
2523}
2524#[doc = "Pulse width modulation unit 1"]
2525pub use pwm0_ns as pwm0_s;
2526#[doc = "Pulse width modulation unit 2"]
2527pub struct PWM1_NS {
2528 _marker: PhantomData<*const ()>,
2529}
2530unsafe impl Send for PWM1_NS {}
2531impl PWM1_NS {
2532 #[doc = r"Pointer to the register block"]
2533 pub const PTR: *const pwm0_ns::RegisterBlock = 0x4002_2000 as *const _;
2534 #[doc = r"Return the pointer to the register block"]
2535 #[inline(always)]
2536 pub const fn ptr() -> *const pwm0_ns::RegisterBlock {
2537 Self::PTR
2538 }
2539}
2540impl Deref for PWM1_NS {
2541 type Target = pwm0_ns::RegisterBlock;
2542 #[inline(always)]
2543 fn deref(&self) -> &Self::Target {
2544 unsafe { &*Self::PTR }
2545 }
2546}
2547impl core::fmt::Debug for PWM1_NS {
2548 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2549 f.debug_struct("PWM1_NS").finish()
2550 }
2551}
2552#[doc = "Pulse width modulation unit 2"]
2553pub use pwm0_ns as pwm1_ns;
2554#[doc = "Pulse width modulation unit 3"]
2555pub struct PWM1_S {
2556 _marker: PhantomData<*const ()>,
2557}
2558unsafe impl Send for PWM1_S {}
2559impl PWM1_S {
2560 #[doc = r"Pointer to the register block"]
2561 pub const PTR: *const pwm0_ns::RegisterBlock = 0x5002_2000 as *const _;
2562 #[doc = r"Return the pointer to the register block"]
2563 #[inline(always)]
2564 pub const fn ptr() -> *const pwm0_ns::RegisterBlock {
2565 Self::PTR
2566 }
2567}
2568impl Deref for PWM1_S {
2569 type Target = pwm0_ns::RegisterBlock;
2570 #[inline(always)]
2571 fn deref(&self) -> &Self::Target {
2572 unsafe { &*Self::PTR }
2573 }
2574}
2575impl core::fmt::Debug for PWM1_S {
2576 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2577 f.debug_struct("PWM1_S").finish()
2578 }
2579}
2580#[doc = "Pulse width modulation unit 3"]
2581pub use pwm0_ns as pwm1_s;
2582#[doc = "Pulse width modulation unit 4"]
2583pub struct PWM2_NS {
2584 _marker: PhantomData<*const ()>,
2585}
2586unsafe impl Send for PWM2_NS {}
2587impl PWM2_NS {
2588 #[doc = r"Pointer to the register block"]
2589 pub const PTR: *const pwm0_ns::RegisterBlock = 0x4002_3000 as *const _;
2590 #[doc = r"Return the pointer to the register block"]
2591 #[inline(always)]
2592 pub const fn ptr() -> *const pwm0_ns::RegisterBlock {
2593 Self::PTR
2594 }
2595}
2596impl Deref for PWM2_NS {
2597 type Target = pwm0_ns::RegisterBlock;
2598 #[inline(always)]
2599 fn deref(&self) -> &Self::Target {
2600 unsafe { &*Self::PTR }
2601 }
2602}
2603impl core::fmt::Debug for PWM2_NS {
2604 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2605 f.debug_struct("PWM2_NS").finish()
2606 }
2607}
2608#[doc = "Pulse width modulation unit 4"]
2609pub use pwm0_ns as pwm2_ns;
2610#[doc = "Pulse width modulation unit 5"]
2611pub struct PWM2_S {
2612 _marker: PhantomData<*const ()>,
2613}
2614unsafe impl Send for PWM2_S {}
2615impl PWM2_S {
2616 #[doc = r"Pointer to the register block"]
2617 pub const PTR: *const pwm0_ns::RegisterBlock = 0x5002_3000 as *const _;
2618 #[doc = r"Return the pointer to the register block"]
2619 #[inline(always)]
2620 pub const fn ptr() -> *const pwm0_ns::RegisterBlock {
2621 Self::PTR
2622 }
2623}
2624impl Deref for PWM2_S {
2625 type Target = pwm0_ns::RegisterBlock;
2626 #[inline(always)]
2627 fn deref(&self) -> &Self::Target {
2628 unsafe { &*Self::PTR }
2629 }
2630}
2631impl core::fmt::Debug for PWM2_S {
2632 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2633 f.debug_struct("PWM2_S").finish()
2634 }
2635}
2636#[doc = "Pulse width modulation unit 5"]
2637pub use pwm0_ns as pwm2_s;
2638#[doc = "Pulse width modulation unit 6"]
2639pub struct PWM3_NS {
2640 _marker: PhantomData<*const ()>,
2641}
2642unsafe impl Send for PWM3_NS {}
2643impl PWM3_NS {
2644 #[doc = r"Pointer to the register block"]
2645 pub const PTR: *const pwm0_ns::RegisterBlock = 0x4002_4000 as *const _;
2646 #[doc = r"Return the pointer to the register block"]
2647 #[inline(always)]
2648 pub const fn ptr() -> *const pwm0_ns::RegisterBlock {
2649 Self::PTR
2650 }
2651}
2652impl Deref for PWM3_NS {
2653 type Target = pwm0_ns::RegisterBlock;
2654 #[inline(always)]
2655 fn deref(&self) -> &Self::Target {
2656 unsafe { &*Self::PTR }
2657 }
2658}
2659impl core::fmt::Debug for PWM3_NS {
2660 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2661 f.debug_struct("PWM3_NS").finish()
2662 }
2663}
2664#[doc = "Pulse width modulation unit 6"]
2665pub use pwm0_ns as pwm3_ns;
2666#[doc = "Pulse width modulation unit 7"]
2667pub struct PWM3_S {
2668 _marker: PhantomData<*const ()>,
2669}
2670unsafe impl Send for PWM3_S {}
2671impl PWM3_S {
2672 #[doc = r"Pointer to the register block"]
2673 pub const PTR: *const pwm0_ns::RegisterBlock = 0x5002_4000 as *const _;
2674 #[doc = r"Return the pointer to the register block"]
2675 #[inline(always)]
2676 pub const fn ptr() -> *const pwm0_ns::RegisterBlock {
2677 Self::PTR
2678 }
2679}
2680impl Deref for PWM3_S {
2681 type Target = pwm0_ns::RegisterBlock;
2682 #[inline(always)]
2683 fn deref(&self) -> &Self::Target {
2684 unsafe { &*Self::PTR }
2685 }
2686}
2687impl core::fmt::Debug for PWM3_S {
2688 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2689 f.debug_struct("PWM3_S").finish()
2690 }
2691}
2692#[doc = "Pulse width modulation unit 7"]
2693pub use pwm0_ns as pwm3_s;
2694#[doc = "Pulse Density Modulation (Digital Microphone) Interface 0"]
2695pub struct PDM_NS {
2696 _marker: PhantomData<*const ()>,
2697}
2698unsafe impl Send for PDM_NS {}
2699impl PDM_NS {
2700 #[doc = r"Pointer to the register block"]
2701 pub const PTR: *const pdm_ns::RegisterBlock = 0x4002_6000 as *const _;
2702 #[doc = r"Return the pointer to the register block"]
2703 #[inline(always)]
2704 pub const fn ptr() -> *const pdm_ns::RegisterBlock {
2705 Self::PTR
2706 }
2707}
2708impl Deref for PDM_NS {
2709 type Target = pdm_ns::RegisterBlock;
2710 #[inline(always)]
2711 fn deref(&self) -> &Self::Target {
2712 unsafe { &*Self::PTR }
2713 }
2714}
2715impl core::fmt::Debug for PDM_NS {
2716 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2717 f.debug_struct("PDM_NS").finish()
2718 }
2719}
2720#[doc = "Pulse Density Modulation (Digital Microphone) Interface 0"]
2721pub mod pdm_ns;
2722#[doc = "Pulse Density Modulation (Digital Microphone) Interface 1"]
2723pub struct PDM_S {
2724 _marker: PhantomData<*const ()>,
2725}
2726unsafe impl Send for PDM_S {}
2727impl PDM_S {
2728 #[doc = r"Pointer to the register block"]
2729 pub const PTR: *const pdm_ns::RegisterBlock = 0x5002_6000 as *const _;
2730 #[doc = r"Return the pointer to the register block"]
2731 #[inline(always)]
2732 pub const fn ptr() -> *const pdm_ns::RegisterBlock {
2733 Self::PTR
2734 }
2735}
2736impl Deref for PDM_S {
2737 type Target = pdm_ns::RegisterBlock;
2738 #[inline(always)]
2739 fn deref(&self) -> &Self::Target {
2740 unsafe { &*Self::PTR }
2741 }
2742}
2743impl core::fmt::Debug for PDM_S {
2744 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2745 f.debug_struct("PDM_S").finish()
2746 }
2747}
2748#[doc = "Pulse Density Modulation (Digital Microphone) Interface 1"]
2749pub use pdm_ns as pdm_s;
2750#[doc = "Inter-IC Sound 0"]
2751pub struct I2S_NS {
2752 _marker: PhantomData<*const ()>,
2753}
2754unsafe impl Send for I2S_NS {}
2755impl I2S_NS {
2756 #[doc = r"Pointer to the register block"]
2757 pub const PTR: *const i2s_ns::RegisterBlock = 0x4002_8000 as *const _;
2758 #[doc = r"Return the pointer to the register block"]
2759 #[inline(always)]
2760 pub const fn ptr() -> *const i2s_ns::RegisterBlock {
2761 Self::PTR
2762 }
2763}
2764impl Deref for I2S_NS {
2765 type Target = i2s_ns::RegisterBlock;
2766 #[inline(always)]
2767 fn deref(&self) -> &Self::Target {
2768 unsafe { &*Self::PTR }
2769 }
2770}
2771impl core::fmt::Debug for I2S_NS {
2772 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2773 f.debug_struct("I2S_NS").finish()
2774 }
2775}
2776#[doc = "Inter-IC Sound 0"]
2777pub mod i2s_ns;
2778#[doc = "Inter-IC Sound 1"]
2779pub struct I2S_S {
2780 _marker: PhantomData<*const ()>,
2781}
2782unsafe impl Send for I2S_S {}
2783impl I2S_S {
2784 #[doc = r"Pointer to the register block"]
2785 pub const PTR: *const i2s_ns::RegisterBlock = 0x5002_8000 as *const _;
2786 #[doc = r"Return the pointer to the register block"]
2787 #[inline(always)]
2788 pub const fn ptr() -> *const i2s_ns::RegisterBlock {
2789 Self::PTR
2790 }
2791}
2792impl Deref for I2S_S {
2793 type Target = i2s_ns::RegisterBlock;
2794 #[inline(always)]
2795 fn deref(&self) -> &Self::Target {
2796 unsafe { &*Self::PTR }
2797 }
2798}
2799impl core::fmt::Debug for I2S_S {
2800 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2801 f.debug_struct("I2S_S").finish()
2802 }
2803}
2804#[doc = "Inter-IC Sound 1"]
2805pub use i2s_ns as i2s_s;
2806#[doc = "Inter Processor Communication 0"]
2807pub struct IPC_NS {
2808 _marker: PhantomData<*const ()>,
2809}
2810unsafe impl Send for IPC_NS {}
2811impl IPC_NS {
2812 #[doc = r"Pointer to the register block"]
2813 pub const PTR: *const ipc_ns::RegisterBlock = 0x4002_a000 as *const _;
2814 #[doc = r"Return the pointer to the register block"]
2815 #[inline(always)]
2816 pub const fn ptr() -> *const ipc_ns::RegisterBlock {
2817 Self::PTR
2818 }
2819}
2820impl Deref for IPC_NS {
2821 type Target = ipc_ns::RegisterBlock;
2822 #[inline(always)]
2823 fn deref(&self) -> &Self::Target {
2824 unsafe { &*Self::PTR }
2825 }
2826}
2827impl core::fmt::Debug for IPC_NS {
2828 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2829 f.debug_struct("IPC_NS").finish()
2830 }
2831}
2832#[doc = "Inter Processor Communication 0"]
2833pub mod ipc_ns;
2834#[doc = "Inter Processor Communication 1"]
2835pub struct IPC_S {
2836 _marker: PhantomData<*const ()>,
2837}
2838unsafe impl Send for IPC_S {}
2839impl IPC_S {
2840 #[doc = r"Pointer to the register block"]
2841 pub const PTR: *const ipc_ns::RegisterBlock = 0x5002_a000 as *const _;
2842 #[doc = r"Return the pointer to the register block"]
2843 #[inline(always)]
2844 pub const fn ptr() -> *const ipc_ns::RegisterBlock {
2845 Self::PTR
2846 }
2847}
2848impl Deref for IPC_S {
2849 type Target = ipc_ns::RegisterBlock;
2850 #[inline(always)]
2851 fn deref(&self) -> &Self::Target {
2852 unsafe { &*Self::PTR }
2853 }
2854}
2855impl core::fmt::Debug for IPC_S {
2856 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2857 f.debug_struct("IPC_S").finish()
2858 }
2859}
2860#[doc = "Inter Processor Communication 1"]
2861pub use ipc_ns as ipc_s;
2862#[doc = "FPU 0"]
2863pub struct FPU_NS {
2864 _marker: PhantomData<*const ()>,
2865}
2866unsafe impl Send for FPU_NS {}
2867impl FPU_NS {
2868 #[doc = r"Pointer to the register block"]
2869 pub const PTR: *const fpu_ns::RegisterBlock = 0x4002_c000 as *const _;
2870 #[doc = r"Return the pointer to the register block"]
2871 #[inline(always)]
2872 pub const fn ptr() -> *const fpu_ns::RegisterBlock {
2873 Self::PTR
2874 }
2875}
2876impl Deref for FPU_NS {
2877 type Target = fpu_ns::RegisterBlock;
2878 #[inline(always)]
2879 fn deref(&self) -> &Self::Target {
2880 unsafe { &*Self::PTR }
2881 }
2882}
2883impl core::fmt::Debug for FPU_NS {
2884 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2885 f.debug_struct("FPU_NS").finish()
2886 }
2887}
2888#[doc = "FPU 0"]
2889pub mod fpu_ns;
2890#[doc = "FPU 1"]
2891pub struct FPU_S {
2892 _marker: PhantomData<*const ()>,
2893}
2894unsafe impl Send for FPU_S {}
2895impl FPU_S {
2896 #[doc = r"Pointer to the register block"]
2897 pub const PTR: *const fpu_ns::RegisterBlock = 0x5002_c000 as *const _;
2898 #[doc = r"Return the pointer to the register block"]
2899 #[inline(always)]
2900 pub const fn ptr() -> *const fpu_ns::RegisterBlock {
2901 Self::PTR
2902 }
2903}
2904impl Deref for FPU_S {
2905 type Target = fpu_ns::RegisterBlock;
2906 #[inline(always)]
2907 fn deref(&self) -> &Self::Target {
2908 unsafe { &*Self::PTR }
2909 }
2910}
2911impl core::fmt::Debug for FPU_S {
2912 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2913 f.debug_struct("FPU_S").finish()
2914 }
2915}
2916#[doc = "FPU 1"]
2917pub use fpu_ns as fpu_s;
2918#[doc = "GPIO Tasks and Events 1"]
2919pub struct GPIOTE1_NS {
2920 _marker: PhantomData<*const ()>,
2921}
2922unsafe impl Send for GPIOTE1_NS {}
2923impl GPIOTE1_NS {
2924 #[doc = r"Pointer to the register block"]
2925 pub const PTR: *const gpiote0_s::RegisterBlock = 0x4003_1000 as *const _;
2926 #[doc = r"Return the pointer to the register block"]
2927 #[inline(always)]
2928 pub const fn ptr() -> *const gpiote0_s::RegisterBlock {
2929 Self::PTR
2930 }
2931}
2932impl Deref for GPIOTE1_NS {
2933 type Target = gpiote0_s::RegisterBlock;
2934 #[inline(always)]
2935 fn deref(&self) -> &Self::Target {
2936 unsafe { &*Self::PTR }
2937 }
2938}
2939impl core::fmt::Debug for GPIOTE1_NS {
2940 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2941 f.debug_struct("GPIOTE1_NS").finish()
2942 }
2943}
2944#[doc = "GPIO Tasks and Events 1"]
2945pub use gpiote0_s as gpiote1_ns;
2946#[doc = "Key management unit 0"]
2947pub struct KMU_NS {
2948 _marker: PhantomData<*const ()>,
2949}
2950unsafe impl Send for KMU_NS {}
2951impl KMU_NS {
2952 #[doc = r"Pointer to the register block"]
2953 pub const PTR: *const kmu_ns::RegisterBlock = 0x4003_9000 as *const _;
2954 #[doc = r"Return the pointer to the register block"]
2955 #[inline(always)]
2956 pub const fn ptr() -> *const kmu_ns::RegisterBlock {
2957 Self::PTR
2958 }
2959}
2960impl Deref for KMU_NS {
2961 type Target = kmu_ns::RegisterBlock;
2962 #[inline(always)]
2963 fn deref(&self) -> &Self::Target {
2964 unsafe { &*Self::PTR }
2965 }
2966}
2967impl core::fmt::Debug for KMU_NS {
2968 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2969 f.debug_struct("KMU_NS").finish()
2970 }
2971}
2972#[doc = "Key management unit 0"]
2973pub mod kmu_ns;
2974#[doc = "Non-volatile memory controller 0"]
2975pub struct NVMC_NS {
2976 _marker: PhantomData<*const ()>,
2977}
2978unsafe impl Send for NVMC_NS {}
2979impl NVMC_NS {
2980 #[doc = r"Pointer to the register block"]
2981 pub const PTR: *const nvmc_ns::RegisterBlock = 0x4003_9000 as *const _;
2982 #[doc = r"Return the pointer to the register block"]
2983 #[inline(always)]
2984 pub const fn ptr() -> *const nvmc_ns::RegisterBlock {
2985 Self::PTR
2986 }
2987}
2988impl Deref for NVMC_NS {
2989 type Target = nvmc_ns::RegisterBlock;
2990 #[inline(always)]
2991 fn deref(&self) -> &Self::Target {
2992 unsafe { &*Self::PTR }
2993 }
2994}
2995impl core::fmt::Debug for NVMC_NS {
2996 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2997 f.debug_struct("NVMC_NS").finish()
2998 }
2999}
3000#[doc = "Non-volatile memory controller 0"]
3001pub mod nvmc_ns;
3002#[doc = "Key management unit 1"]
3003pub struct KMU_S {
3004 _marker: PhantomData<*const ()>,
3005}
3006unsafe impl Send for KMU_S {}
3007impl KMU_S {
3008 #[doc = r"Pointer to the register block"]
3009 pub const PTR: *const kmu_ns::RegisterBlock = 0x5003_9000 as *const _;
3010 #[doc = r"Return the pointer to the register block"]
3011 #[inline(always)]
3012 pub const fn ptr() -> *const kmu_ns::RegisterBlock {
3013 Self::PTR
3014 }
3015}
3016impl Deref for KMU_S {
3017 type Target = kmu_ns::RegisterBlock;
3018 #[inline(always)]
3019 fn deref(&self) -> &Self::Target {
3020 unsafe { &*Self::PTR }
3021 }
3022}
3023impl core::fmt::Debug for KMU_S {
3024 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3025 f.debug_struct("KMU_S").finish()
3026 }
3027}
3028#[doc = "Key management unit 1"]
3029pub use kmu_ns as kmu_s;
3030#[doc = "Non-volatile memory controller 1"]
3031pub struct NVMC_S {
3032 _marker: PhantomData<*const ()>,
3033}
3034unsafe impl Send for NVMC_S {}
3035impl NVMC_S {
3036 #[doc = r"Pointer to the register block"]
3037 pub const PTR: *const nvmc_ns::RegisterBlock = 0x5003_9000 as *const _;
3038 #[doc = r"Return the pointer to the register block"]
3039 #[inline(always)]
3040 pub const fn ptr() -> *const nvmc_ns::RegisterBlock {
3041 Self::PTR
3042 }
3043}
3044impl Deref for NVMC_S {
3045 type Target = nvmc_ns::RegisterBlock;
3046 #[inline(always)]
3047 fn deref(&self) -> &Self::Target {
3048 unsafe { &*Self::PTR }
3049 }
3050}
3051impl core::fmt::Debug for NVMC_S {
3052 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3053 f.debug_struct("NVMC_S").finish()
3054 }
3055}
3056#[doc = "Non-volatile memory controller 1"]
3057pub use nvmc_ns as nvmc_s;
3058#[doc = "Volatile Memory controller 0"]
3059pub struct VMC_NS {
3060 _marker: PhantomData<*const ()>,
3061}
3062unsafe impl Send for VMC_NS {}
3063impl VMC_NS {
3064 #[doc = r"Pointer to the register block"]
3065 pub const PTR: *const vmc_ns::RegisterBlock = 0x4003_a000 as *const _;
3066 #[doc = r"Return the pointer to the register block"]
3067 #[inline(always)]
3068 pub const fn ptr() -> *const vmc_ns::RegisterBlock {
3069 Self::PTR
3070 }
3071}
3072impl Deref for VMC_NS {
3073 type Target = vmc_ns::RegisterBlock;
3074 #[inline(always)]
3075 fn deref(&self) -> &Self::Target {
3076 unsafe { &*Self::PTR }
3077 }
3078}
3079impl core::fmt::Debug for VMC_NS {
3080 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3081 f.debug_struct("VMC_NS").finish()
3082 }
3083}
3084#[doc = "Volatile Memory controller 0"]
3085pub mod vmc_ns;
3086#[doc = "Volatile Memory controller 1"]
3087pub struct VMC_S {
3088 _marker: PhantomData<*const ()>,
3089}
3090unsafe impl Send for VMC_S {}
3091impl VMC_S {
3092 #[doc = r"Pointer to the register block"]
3093 pub const PTR: *const vmc_ns::RegisterBlock = 0x5003_a000 as *const _;
3094 #[doc = r"Return the pointer to the register block"]
3095 #[inline(always)]
3096 pub const fn ptr() -> *const vmc_ns::RegisterBlock {
3097 Self::PTR
3098 }
3099}
3100impl Deref for VMC_S {
3101 type Target = vmc_ns::RegisterBlock;
3102 #[inline(always)]
3103 fn deref(&self) -> &Self::Target {
3104 unsafe { &*Self::PTR }
3105 }
3106}
3107impl core::fmt::Debug for VMC_S {
3108 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3109 f.debug_struct("VMC_S").finish()
3110 }
3111}
3112#[doc = "Volatile Memory controller 1"]
3113pub use vmc_ns as vmc_s;
3114#[doc = "CRYPTOCELL HOST_RGF interface"]
3115pub struct CC_HOST_RGF_S {
3116 _marker: PhantomData<*const ()>,
3117}
3118unsafe impl Send for CC_HOST_RGF_S {}
3119impl CC_HOST_RGF_S {
3120 #[doc = r"Pointer to the register block"]
3121 pub const PTR: *const cc_host_rgf_s::RegisterBlock = 0x5084_0000 as *const _;
3122 #[doc = r"Return the pointer to the register block"]
3123 #[inline(always)]
3124 pub const fn ptr() -> *const cc_host_rgf_s::RegisterBlock {
3125 Self::PTR
3126 }
3127}
3128impl Deref for CC_HOST_RGF_S {
3129 type Target = cc_host_rgf_s::RegisterBlock;
3130 #[inline(always)]
3131 fn deref(&self) -> &Self::Target {
3132 unsafe { &*Self::PTR }
3133 }
3134}
3135impl core::fmt::Debug for CC_HOST_RGF_S {
3136 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3137 f.debug_struct("CC_HOST_RGF_S").finish()
3138 }
3139}
3140#[doc = "CRYPTOCELL HOST_RGF interface"]
3141pub mod cc_host_rgf_s;
3142#[doc = "ARM TrustZone CryptoCell register interface"]
3143pub struct CRYPTOCELL_S {
3144 _marker: PhantomData<*const ()>,
3145}
3146unsafe impl Send for CRYPTOCELL_S {}
3147impl CRYPTOCELL_S {
3148 #[doc = r"Pointer to the register block"]
3149 pub const PTR: *const cryptocell_s::RegisterBlock = 0x5084_0000 as *const _;
3150 #[doc = r"Return the pointer to the register block"]
3151 #[inline(always)]
3152 pub const fn ptr() -> *const cryptocell_s::RegisterBlock {
3153 Self::PTR
3154 }
3155}
3156impl Deref for CRYPTOCELL_S {
3157 type Target = cryptocell_s::RegisterBlock;
3158 #[inline(always)]
3159 fn deref(&self) -> &Self::Target {
3160 unsafe { &*Self::PTR }
3161 }
3162}
3163impl core::fmt::Debug for CRYPTOCELL_S {
3164 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3165 f.debug_struct("CRYPTOCELL_S").finish()
3166 }
3167}
3168#[doc = "ARM TrustZone CryptoCell register interface"]
3169pub mod cryptocell_s;
3170#[doc = "GPIO Port 0"]
3171pub struct P0_NS {
3172 _marker: PhantomData<*const ()>,
3173}
3174unsafe impl Send for P0_NS {}
3175impl P0_NS {
3176 #[doc = r"Pointer to the register block"]
3177 pub const PTR: *const p0_ns::RegisterBlock = 0x4084_2500 as *const _;
3178 #[doc = r"Return the pointer to the register block"]
3179 #[inline(always)]
3180 pub const fn ptr() -> *const p0_ns::RegisterBlock {
3181 Self::PTR
3182 }
3183}
3184impl Deref for P0_NS {
3185 type Target = p0_ns::RegisterBlock;
3186 #[inline(always)]
3187 fn deref(&self) -> &Self::Target {
3188 unsafe { &*Self::PTR }
3189 }
3190}
3191impl core::fmt::Debug for P0_NS {
3192 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3193 f.debug_struct("P0_NS").finish()
3194 }
3195}
3196#[doc = "GPIO Port 0"]
3197pub mod p0_ns;
3198#[doc = "GPIO Port 1"]
3199pub struct P0_S {
3200 _marker: PhantomData<*const ()>,
3201}
3202unsafe impl Send for P0_S {}
3203impl P0_S {
3204 #[doc = r"Pointer to the register block"]
3205 pub const PTR: *const p0_ns::RegisterBlock = 0x5084_2500 as *const _;
3206 #[doc = r"Return the pointer to the register block"]
3207 #[inline(always)]
3208 pub const fn ptr() -> *const p0_ns::RegisterBlock {
3209 Self::PTR
3210 }
3211}
3212impl Deref for P0_S {
3213 type Target = p0_ns::RegisterBlock;
3214 #[inline(always)]
3215 fn deref(&self) -> &Self::Target {
3216 unsafe { &*Self::PTR }
3217 }
3218}
3219impl core::fmt::Debug for P0_S {
3220 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3221 f.debug_struct("P0_S").finish()
3222 }
3223}
3224#[doc = "GPIO Port 1"]
3225pub use p0_ns as p0_s;
3226#[no_mangle]
3227static mut DEVICE_PERIPHERALS: bool = false;
3228#[doc = r"All the peripherals"]
3229#[allow(non_snake_case)]
3230pub struct Peripherals {
3231 #[doc = "FICR_S"]
3232 pub FICR_S: FICR_S,
3233 #[doc = "UICR_S"]
3234 pub UICR_S: UICR_S,
3235 #[doc = "TAD_S"]
3236 pub TAD_S: TAD_S,
3237 #[doc = "SPU_S"]
3238 pub SPU_S: SPU_S,
3239 #[doc = "REGULATORS_NS"]
3240 pub REGULATORS_NS: REGULATORS_NS,
3241 #[doc = "REGULATORS_S"]
3242 pub REGULATORS_S: REGULATORS_S,
3243 #[doc = "CLOCK_NS"]
3244 pub CLOCK_NS: CLOCK_NS,
3245 #[doc = "POWER_NS"]
3246 pub POWER_NS: POWER_NS,
3247 #[doc = "CLOCK_S"]
3248 pub CLOCK_S: CLOCK_S,
3249 #[doc = "POWER_S"]
3250 pub POWER_S: POWER_S,
3251 #[doc = "CTRL_AP_PERI_S"]
3252 pub CTRL_AP_PERI_S: CTRL_AP_PERI_S,
3253 #[doc = "SPIM0_NS"]
3254 pub SPIM0_NS: SPIM0_NS,
3255 #[doc = "SPIS0_NS"]
3256 pub SPIS0_NS: SPIS0_NS,
3257 #[doc = "TWIM0_NS"]
3258 pub TWIM0_NS: TWIM0_NS,
3259 #[doc = "TWIS0_NS"]
3260 pub TWIS0_NS: TWIS0_NS,
3261 #[doc = "UARTE0_NS"]
3262 pub UARTE0_NS: UARTE0_NS,
3263 #[doc = "SPIM0_S"]
3264 pub SPIM0_S: SPIM0_S,
3265 #[doc = "SPIS0_S"]
3266 pub SPIS0_S: SPIS0_S,
3267 #[doc = "TWIM0_S"]
3268 pub TWIM0_S: TWIM0_S,
3269 #[doc = "TWIS0_S"]
3270 pub TWIS0_S: TWIS0_S,
3271 #[doc = "UARTE0_S"]
3272 pub UARTE0_S: UARTE0_S,
3273 #[doc = "SPIM1_NS"]
3274 pub SPIM1_NS: SPIM1_NS,
3275 #[doc = "SPIS1_NS"]
3276 pub SPIS1_NS: SPIS1_NS,
3277 #[doc = "TWIM1_NS"]
3278 pub TWIM1_NS: TWIM1_NS,
3279 #[doc = "TWIS1_NS"]
3280 pub TWIS1_NS: TWIS1_NS,
3281 #[doc = "UARTE1_NS"]
3282 pub UARTE1_NS: UARTE1_NS,
3283 #[doc = "SPIM1_S"]
3284 pub SPIM1_S: SPIM1_S,
3285 #[doc = "SPIS1_S"]
3286 pub SPIS1_S: SPIS1_S,
3287 #[doc = "TWIM1_S"]
3288 pub TWIM1_S: TWIM1_S,
3289 #[doc = "TWIS1_S"]
3290 pub TWIS1_S: TWIS1_S,
3291 #[doc = "UARTE1_S"]
3292 pub UARTE1_S: UARTE1_S,
3293 #[doc = "SPIM2_NS"]
3294 pub SPIM2_NS: SPIM2_NS,
3295 #[doc = "SPIS2_NS"]
3296 pub SPIS2_NS: SPIS2_NS,
3297 #[doc = "TWIM2_NS"]
3298 pub TWIM2_NS: TWIM2_NS,
3299 #[doc = "TWIS2_NS"]
3300 pub TWIS2_NS: TWIS2_NS,
3301 #[doc = "UARTE2_NS"]
3302 pub UARTE2_NS: UARTE2_NS,
3303 #[doc = "SPIM2_S"]
3304 pub SPIM2_S: SPIM2_S,
3305 #[doc = "SPIS2_S"]
3306 pub SPIS2_S: SPIS2_S,
3307 #[doc = "TWIM2_S"]
3308 pub TWIM2_S: TWIM2_S,
3309 #[doc = "TWIS2_S"]
3310 pub TWIS2_S: TWIS2_S,
3311 #[doc = "UARTE2_S"]
3312 pub UARTE2_S: UARTE2_S,
3313 #[doc = "SPIM3_NS"]
3314 pub SPIM3_NS: SPIM3_NS,
3315 #[doc = "SPIS3_NS"]
3316 pub SPIS3_NS: SPIS3_NS,
3317 #[doc = "TWIM3_NS"]
3318 pub TWIM3_NS: TWIM3_NS,
3319 #[doc = "TWIS3_NS"]
3320 pub TWIS3_NS: TWIS3_NS,
3321 #[doc = "UARTE3_NS"]
3322 pub UARTE3_NS: UARTE3_NS,
3323 #[doc = "SPIM3_S"]
3324 pub SPIM3_S: SPIM3_S,
3325 #[doc = "SPIS3_S"]
3326 pub SPIS3_S: SPIS3_S,
3327 #[doc = "TWIM3_S"]
3328 pub TWIM3_S: TWIM3_S,
3329 #[doc = "TWIS3_S"]
3330 pub TWIS3_S: TWIS3_S,
3331 #[doc = "UARTE3_S"]
3332 pub UARTE3_S: UARTE3_S,
3333 #[doc = "GPIOTE0_S"]
3334 pub GPIOTE0_S: GPIOTE0_S,
3335 #[doc = "SAADC_NS"]
3336 pub SAADC_NS: SAADC_NS,
3337 #[doc = "SAADC_S"]
3338 pub SAADC_S: SAADC_S,
3339 #[doc = "TIMER0_NS"]
3340 pub TIMER0_NS: TIMER0_NS,
3341 #[doc = "TIMER0_S"]
3342 pub TIMER0_S: TIMER0_S,
3343 #[doc = "TIMER1_NS"]
3344 pub TIMER1_NS: TIMER1_NS,
3345 #[doc = "TIMER1_S"]
3346 pub TIMER1_S: TIMER1_S,
3347 #[doc = "TIMER2_NS"]
3348 pub TIMER2_NS: TIMER2_NS,
3349 #[doc = "TIMER2_S"]
3350 pub TIMER2_S: TIMER2_S,
3351 #[doc = "RTC0_NS"]
3352 pub RTC0_NS: RTC0_NS,
3353 #[doc = "RTC0_S"]
3354 pub RTC0_S: RTC0_S,
3355 #[doc = "RTC1_NS"]
3356 pub RTC1_NS: RTC1_NS,
3357 #[doc = "RTC1_S"]
3358 pub RTC1_S: RTC1_S,
3359 #[doc = "DPPIC_NS"]
3360 pub DPPIC_NS: DPPIC_NS,
3361 #[doc = "DPPIC_S"]
3362 pub DPPIC_S: DPPIC_S,
3363 #[doc = "WDT_NS"]
3364 pub WDT_NS: WDT_NS,
3365 #[doc = "WDT_S"]
3366 pub WDT_S: WDT_S,
3367 #[doc = "EGU0_NS"]
3368 pub EGU0_NS: EGU0_NS,
3369 #[doc = "EGU0_S"]
3370 pub EGU0_S: EGU0_S,
3371 #[doc = "EGU1_NS"]
3372 pub EGU1_NS: EGU1_NS,
3373 #[doc = "EGU1_S"]
3374 pub EGU1_S: EGU1_S,
3375 #[doc = "EGU2_NS"]
3376 pub EGU2_NS: EGU2_NS,
3377 #[doc = "EGU2_S"]
3378 pub EGU2_S: EGU2_S,
3379 #[doc = "EGU3_NS"]
3380 pub EGU3_NS: EGU3_NS,
3381 #[doc = "EGU3_S"]
3382 pub EGU3_S: EGU3_S,
3383 #[doc = "EGU4_NS"]
3384 pub EGU4_NS: EGU4_NS,
3385 #[doc = "EGU4_S"]
3386 pub EGU4_S: EGU4_S,
3387 #[doc = "EGU5_NS"]
3388 pub EGU5_NS: EGU5_NS,
3389 #[doc = "EGU5_S"]
3390 pub EGU5_S: EGU5_S,
3391 #[doc = "PWM0_NS"]
3392 pub PWM0_NS: PWM0_NS,
3393 #[doc = "PWM0_S"]
3394 pub PWM0_S: PWM0_S,
3395 #[doc = "PWM1_NS"]
3396 pub PWM1_NS: PWM1_NS,
3397 #[doc = "PWM1_S"]
3398 pub PWM1_S: PWM1_S,
3399 #[doc = "PWM2_NS"]
3400 pub PWM2_NS: PWM2_NS,
3401 #[doc = "PWM2_S"]
3402 pub PWM2_S: PWM2_S,
3403 #[doc = "PWM3_NS"]
3404 pub PWM3_NS: PWM3_NS,
3405 #[doc = "PWM3_S"]
3406 pub PWM3_S: PWM3_S,
3407 #[doc = "PDM_NS"]
3408 pub PDM_NS: PDM_NS,
3409 #[doc = "PDM_S"]
3410 pub PDM_S: PDM_S,
3411 #[doc = "I2S_NS"]
3412 pub I2S_NS: I2S_NS,
3413 #[doc = "I2S_S"]
3414 pub I2S_S: I2S_S,
3415 #[doc = "IPC_NS"]
3416 pub IPC_NS: IPC_NS,
3417 #[doc = "IPC_S"]
3418 pub IPC_S: IPC_S,
3419 #[doc = "FPU_NS"]
3420 pub FPU_NS: FPU_NS,
3421 #[doc = "FPU_S"]
3422 pub FPU_S: FPU_S,
3423 #[doc = "GPIOTE1_NS"]
3424 pub GPIOTE1_NS: GPIOTE1_NS,
3425 #[doc = "KMU_NS"]
3426 pub KMU_NS: KMU_NS,
3427 #[doc = "NVMC_NS"]
3428 pub NVMC_NS: NVMC_NS,
3429 #[doc = "KMU_S"]
3430 pub KMU_S: KMU_S,
3431 #[doc = "NVMC_S"]
3432 pub NVMC_S: NVMC_S,
3433 #[doc = "VMC_NS"]
3434 pub VMC_NS: VMC_NS,
3435 #[doc = "VMC_S"]
3436 pub VMC_S: VMC_S,
3437 #[doc = "CC_HOST_RGF_S"]
3438 pub CC_HOST_RGF_S: CC_HOST_RGF_S,
3439 #[doc = "CRYPTOCELL_S"]
3440 pub CRYPTOCELL_S: CRYPTOCELL_S,
3441 #[doc = "P0_NS"]
3442 pub P0_NS: P0_NS,
3443 #[doc = "P0_S"]
3444 pub P0_S: P0_S,
3445}
3446impl Peripherals {
3447 #[doc = r"Returns all the peripherals *once*"]
3448 #[inline]
3449 pub fn take() -> Option<Self> {
3450 cortex_m::interrupt::free(|_| {
3451 if unsafe { DEVICE_PERIPHERALS } {
3452 None
3453 } else {
3454 Some(unsafe { Peripherals::steal() })
3455 }
3456 })
3457 }
3458 #[doc = r"Unchecked version of `Peripherals::take`"]
3459 #[inline]
3460 pub unsafe fn steal() -> Self {
3461 DEVICE_PERIPHERALS = true;
3462 Peripherals {
3463 FICR_S: FICR_S {
3464 _marker: PhantomData,
3465 },
3466 UICR_S: UICR_S {
3467 _marker: PhantomData,
3468 },
3469 TAD_S: TAD_S {
3470 _marker: PhantomData,
3471 },
3472 SPU_S: SPU_S {
3473 _marker: PhantomData,
3474 },
3475 REGULATORS_NS: REGULATORS_NS {
3476 _marker: PhantomData,
3477 },
3478 REGULATORS_S: REGULATORS_S {
3479 _marker: PhantomData,
3480 },
3481 CLOCK_NS: CLOCK_NS {
3482 _marker: PhantomData,
3483 },
3484 POWER_NS: POWER_NS {
3485 _marker: PhantomData,
3486 },
3487 CLOCK_S: CLOCK_S {
3488 _marker: PhantomData,
3489 },
3490 POWER_S: POWER_S {
3491 _marker: PhantomData,
3492 },
3493 CTRL_AP_PERI_S: CTRL_AP_PERI_S {
3494 _marker: PhantomData,
3495 },
3496 SPIM0_NS: SPIM0_NS {
3497 _marker: PhantomData,
3498 },
3499 SPIS0_NS: SPIS0_NS {
3500 _marker: PhantomData,
3501 },
3502 TWIM0_NS: TWIM0_NS {
3503 _marker: PhantomData,
3504 },
3505 TWIS0_NS: TWIS0_NS {
3506 _marker: PhantomData,
3507 },
3508 UARTE0_NS: UARTE0_NS {
3509 _marker: PhantomData,
3510 },
3511 SPIM0_S: SPIM0_S {
3512 _marker: PhantomData,
3513 },
3514 SPIS0_S: SPIS0_S {
3515 _marker: PhantomData,
3516 },
3517 TWIM0_S: TWIM0_S {
3518 _marker: PhantomData,
3519 },
3520 TWIS0_S: TWIS0_S {
3521 _marker: PhantomData,
3522 },
3523 UARTE0_S: UARTE0_S {
3524 _marker: PhantomData,
3525 },
3526 SPIM1_NS: SPIM1_NS {
3527 _marker: PhantomData,
3528 },
3529 SPIS1_NS: SPIS1_NS {
3530 _marker: PhantomData,
3531 },
3532 TWIM1_NS: TWIM1_NS {
3533 _marker: PhantomData,
3534 },
3535 TWIS1_NS: TWIS1_NS {
3536 _marker: PhantomData,
3537 },
3538 UARTE1_NS: UARTE1_NS {
3539 _marker: PhantomData,
3540 },
3541 SPIM1_S: SPIM1_S {
3542 _marker: PhantomData,
3543 },
3544 SPIS1_S: SPIS1_S {
3545 _marker: PhantomData,
3546 },
3547 TWIM1_S: TWIM1_S {
3548 _marker: PhantomData,
3549 },
3550 TWIS1_S: TWIS1_S {
3551 _marker: PhantomData,
3552 },
3553 UARTE1_S: UARTE1_S {
3554 _marker: PhantomData,
3555 },
3556 SPIM2_NS: SPIM2_NS {
3557 _marker: PhantomData,
3558 },
3559 SPIS2_NS: SPIS2_NS {
3560 _marker: PhantomData,
3561 },
3562 TWIM2_NS: TWIM2_NS {
3563 _marker: PhantomData,
3564 },
3565 TWIS2_NS: TWIS2_NS {
3566 _marker: PhantomData,
3567 },
3568 UARTE2_NS: UARTE2_NS {
3569 _marker: PhantomData,
3570 },
3571 SPIM2_S: SPIM2_S {
3572 _marker: PhantomData,
3573 },
3574 SPIS2_S: SPIS2_S {
3575 _marker: PhantomData,
3576 },
3577 TWIM2_S: TWIM2_S {
3578 _marker: PhantomData,
3579 },
3580 TWIS2_S: TWIS2_S {
3581 _marker: PhantomData,
3582 },
3583 UARTE2_S: UARTE2_S {
3584 _marker: PhantomData,
3585 },
3586 SPIM3_NS: SPIM3_NS {
3587 _marker: PhantomData,
3588 },
3589 SPIS3_NS: SPIS3_NS {
3590 _marker: PhantomData,
3591 },
3592 TWIM3_NS: TWIM3_NS {
3593 _marker: PhantomData,
3594 },
3595 TWIS3_NS: TWIS3_NS {
3596 _marker: PhantomData,
3597 },
3598 UARTE3_NS: UARTE3_NS {
3599 _marker: PhantomData,
3600 },
3601 SPIM3_S: SPIM3_S {
3602 _marker: PhantomData,
3603 },
3604 SPIS3_S: SPIS3_S {
3605 _marker: PhantomData,
3606 },
3607 TWIM3_S: TWIM3_S {
3608 _marker: PhantomData,
3609 },
3610 TWIS3_S: TWIS3_S {
3611 _marker: PhantomData,
3612 },
3613 UARTE3_S: UARTE3_S {
3614 _marker: PhantomData,
3615 },
3616 GPIOTE0_S: GPIOTE0_S {
3617 _marker: PhantomData,
3618 },
3619 SAADC_NS: SAADC_NS {
3620 _marker: PhantomData,
3621 },
3622 SAADC_S: SAADC_S {
3623 _marker: PhantomData,
3624 },
3625 TIMER0_NS: TIMER0_NS {
3626 _marker: PhantomData,
3627 },
3628 TIMER0_S: TIMER0_S {
3629 _marker: PhantomData,
3630 },
3631 TIMER1_NS: TIMER1_NS {
3632 _marker: PhantomData,
3633 },
3634 TIMER1_S: TIMER1_S {
3635 _marker: PhantomData,
3636 },
3637 TIMER2_NS: TIMER2_NS {
3638 _marker: PhantomData,
3639 },
3640 TIMER2_S: TIMER2_S {
3641 _marker: PhantomData,
3642 },
3643 RTC0_NS: RTC0_NS {
3644 _marker: PhantomData,
3645 },
3646 RTC0_S: RTC0_S {
3647 _marker: PhantomData,
3648 },
3649 RTC1_NS: RTC1_NS {
3650 _marker: PhantomData,
3651 },
3652 RTC1_S: RTC1_S {
3653 _marker: PhantomData,
3654 },
3655 DPPIC_NS: DPPIC_NS {
3656 _marker: PhantomData,
3657 },
3658 DPPIC_S: DPPIC_S {
3659 _marker: PhantomData,
3660 },
3661 WDT_NS: WDT_NS {
3662 _marker: PhantomData,
3663 },
3664 WDT_S: WDT_S {
3665 _marker: PhantomData,
3666 },
3667 EGU0_NS: EGU0_NS {
3668 _marker: PhantomData,
3669 },
3670 EGU0_S: EGU0_S {
3671 _marker: PhantomData,
3672 },
3673 EGU1_NS: EGU1_NS {
3674 _marker: PhantomData,
3675 },
3676 EGU1_S: EGU1_S {
3677 _marker: PhantomData,
3678 },
3679 EGU2_NS: EGU2_NS {
3680 _marker: PhantomData,
3681 },
3682 EGU2_S: EGU2_S {
3683 _marker: PhantomData,
3684 },
3685 EGU3_NS: EGU3_NS {
3686 _marker: PhantomData,
3687 },
3688 EGU3_S: EGU3_S {
3689 _marker: PhantomData,
3690 },
3691 EGU4_NS: EGU4_NS {
3692 _marker: PhantomData,
3693 },
3694 EGU4_S: EGU4_S {
3695 _marker: PhantomData,
3696 },
3697 EGU5_NS: EGU5_NS {
3698 _marker: PhantomData,
3699 },
3700 EGU5_S: EGU5_S {
3701 _marker: PhantomData,
3702 },
3703 PWM0_NS: PWM0_NS {
3704 _marker: PhantomData,
3705 },
3706 PWM0_S: PWM0_S {
3707 _marker: PhantomData,
3708 },
3709 PWM1_NS: PWM1_NS {
3710 _marker: PhantomData,
3711 },
3712 PWM1_S: PWM1_S {
3713 _marker: PhantomData,
3714 },
3715 PWM2_NS: PWM2_NS {
3716 _marker: PhantomData,
3717 },
3718 PWM2_S: PWM2_S {
3719 _marker: PhantomData,
3720 },
3721 PWM3_NS: PWM3_NS {
3722 _marker: PhantomData,
3723 },
3724 PWM3_S: PWM3_S {
3725 _marker: PhantomData,
3726 },
3727 PDM_NS: PDM_NS {
3728 _marker: PhantomData,
3729 },
3730 PDM_S: PDM_S {
3731 _marker: PhantomData,
3732 },
3733 I2S_NS: I2S_NS {
3734 _marker: PhantomData,
3735 },
3736 I2S_S: I2S_S {
3737 _marker: PhantomData,
3738 },
3739 IPC_NS: IPC_NS {
3740 _marker: PhantomData,
3741 },
3742 IPC_S: IPC_S {
3743 _marker: PhantomData,
3744 },
3745 FPU_NS: FPU_NS {
3746 _marker: PhantomData,
3747 },
3748 FPU_S: FPU_S {
3749 _marker: PhantomData,
3750 },
3751 GPIOTE1_NS: GPIOTE1_NS {
3752 _marker: PhantomData,
3753 },
3754 KMU_NS: KMU_NS {
3755 _marker: PhantomData,
3756 },
3757 NVMC_NS: NVMC_NS {
3758 _marker: PhantomData,
3759 },
3760 KMU_S: KMU_S {
3761 _marker: PhantomData,
3762 },
3763 NVMC_S: NVMC_S {
3764 _marker: PhantomData,
3765 },
3766 VMC_NS: VMC_NS {
3767 _marker: PhantomData,
3768 },
3769 VMC_S: VMC_S {
3770 _marker: PhantomData,
3771 },
3772 CC_HOST_RGF_S: CC_HOST_RGF_S {
3773 _marker: PhantomData,
3774 },
3775 CRYPTOCELL_S: CRYPTOCELL_S {
3776 _marker: PhantomData,
3777 },
3778 P0_NS: P0_NS {
3779 _marker: PhantomData,
3780 },
3781 P0_S: P0_S {
3782 _marker: PhantomData,
3783 },
3784 }
3785 }
3786}