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