1#![doc = "Peripheral access API for NRF5340_NETWORK microcontrollers (generated using svd2rust v0.25.1 ( ))\n\nYou can find an overview of the generated API [here].\n\nAPI features to be included in the [next]
2svd2rust release can be generated by cloning the svd2rust [repository], checking out the above commit, and running `cargo doc --open`.\n\n[here]: https://docs.rs/svd2rust/0.25.1/svd2rust/#peripheral-api\n[next]: https://github.com/rust-embedded/svd2rust/blob/master/CHANGELOG.md#unreleased\n[repository]: https://github.com/rust-embedded/svd2rust"]
3#![deny(const_err)]
4#![deny(dead_code)]
5#![deny(improper_ctypes)]
6#![deny(missing_docs)]
7#![deny(no_mangle_generic_items)]
8#![deny(non_shorthand_field_patterns)]
9#![deny(overflowing_literals)]
10#![deny(path_statements)]
11#![deny(patterns_in_fns_without_body)]
12#![deny(private_in_public)]
13#![deny(unconditional_recursion)]
14#![deny(unused_allocation)]
15#![deny(unused_comparisons)]
16#![deny(unused_parens)]
17#![deny(while_true)]
18#![allow(non_camel_case_types)]
19#![allow(non_snake_case)]
20#![no_std]
21use core::marker::PhantomData;
22use core::ops::Deref;
23#[doc = r"Number available in the NVIC for configuring priority"]
24pub const NVIC_PRIO_BITS: u8 = 3;
25#[cfg(feature = "rt")]
26pub use self::Interrupt as interrupt;
27pub use cortex_m::peripheral::Peripherals as CorePeripherals;
28pub use cortex_m::peripheral::{CBP, CPUID, DCB, DWT, FPB, ITM, MPU, NVIC, SCB, SYST, TPIU};
29#[cfg(feature = "rt")]
30pub use cortex_m_rt::interrupt;
31#[allow(unused_imports)]
32use generic::*;
33#[doc = r"Common register and bit access and modify traits"]
34pub mod generic;
35#[cfg(feature = "rt")]
36extern "C" {
37 fn CLOCK_POWER();
38 fn RADIO();
39 fn RNG();
40 fn GPIOTE();
41 fn WDT();
42 fn TIMER0();
43 fn ECB();
44 fn AAR_CCM();
45 fn TEMP();
46 fn RTC0();
47 fn IPC();
48 fn SERIAL0();
49 fn EGU0();
50 fn RTC1();
51 fn TIMER1();
52 fn TIMER2();
53 fn SWI0();
54 fn SWI1();
55 fn SWI2();
56 fn SWI3();
57}
58#[doc(hidden)]
59pub union Vector {
60 _handler: unsafe extern "C" fn(),
61 _reserved: u32,
62}
63#[cfg(feature = "rt")]
64#[doc(hidden)]
65#[link_section = ".vector_table.interrupts"]
66#[no_mangle]
67pub static __INTERRUPTS: [Vector; 30] = [
68 Vector { _reserved: 0 },
69 Vector { _reserved: 0 },
70 Vector { _reserved: 0 },
71 Vector { _reserved: 0 },
72 Vector { _reserved: 0 },
73 Vector {
74 _handler: CLOCK_POWER,
75 },
76 Vector { _reserved: 0 },
77 Vector { _reserved: 0 },
78 Vector { _handler: RADIO },
79 Vector { _handler: RNG },
80 Vector { _handler: GPIOTE },
81 Vector { _handler: WDT },
82 Vector { _handler: TIMER0 },
83 Vector { _handler: ECB },
84 Vector { _handler: AAR_CCM },
85 Vector { _reserved: 0 },
86 Vector { _handler: TEMP },
87 Vector { _handler: RTC0 },
88 Vector { _handler: IPC },
89 Vector { _handler: SERIAL0 },
90 Vector { _handler: EGU0 },
91 Vector { _reserved: 0 },
92 Vector { _handler: RTC1 },
93 Vector { _reserved: 0 },
94 Vector { _handler: TIMER1 },
95 Vector { _handler: TIMER2 },
96 Vector { _handler: SWI0 },
97 Vector { _handler: SWI1 },
98 Vector { _handler: SWI2 },
99 Vector { _handler: SWI3 },
100];
101#[doc = r"Enumeration of all the interrupts."]
102#[derive(Copy, Clone, Debug, PartialEq, Eq)]
103#[repr(u16)]
104pub enum Interrupt {
105 #[doc = "5 - CLOCK_POWER"]
106 CLOCK_POWER = 5,
107 #[doc = "8 - RADIO"]
108 RADIO = 8,
109 #[doc = "9 - RNG"]
110 RNG = 9,
111 #[doc = "10 - GPIOTE"]
112 GPIOTE = 10,
113 #[doc = "11 - WDT"]
114 WDT = 11,
115 #[doc = "12 - TIMER0"]
116 TIMER0 = 12,
117 #[doc = "13 - ECB"]
118 ECB = 13,
119 #[doc = "14 - AAR_CCM"]
120 AAR_CCM = 14,
121 #[doc = "16 - TEMP"]
122 TEMP = 16,
123 #[doc = "17 - RTC0"]
124 RTC0 = 17,
125 #[doc = "18 - IPC"]
126 IPC = 18,
127 #[doc = "19 - SERIAL0"]
128 SERIAL0 = 19,
129 #[doc = "20 - EGU0"]
130 EGU0 = 20,
131 #[doc = "22 - RTC1"]
132 RTC1 = 22,
133 #[doc = "24 - TIMER1"]
134 TIMER1 = 24,
135 #[doc = "25 - TIMER2"]
136 TIMER2 = 25,
137 #[doc = "26 - SWI0"]
138 SWI0 = 26,
139 #[doc = "27 - SWI1"]
140 SWI1 = 27,
141 #[doc = "28 - SWI2"]
142 SWI2 = 28,
143 #[doc = "29 - SWI3"]
144 SWI3 = 29,
145}
146unsafe impl cortex_m::interrupt::InterruptNumber for Interrupt {
147 #[inline(always)]
148 fn number(self) -> u16 {
149 self as u16
150 }
151}
152#[doc = "Factory Information Configuration Registers"]
153pub struct FICR_NS {
154 _marker: PhantomData<*const ()>,
155}
156unsafe impl Send for FICR_NS {}
157impl FICR_NS {
158 #[doc = r"Pointer to the register block"]
159 pub const PTR: *const ficr_ns::RegisterBlock = 0x01ff_0000 as *const _;
160 #[doc = r"Return the pointer to the register block"]
161 #[inline(always)]
162 pub const fn ptr() -> *const ficr_ns::RegisterBlock {
163 Self::PTR
164 }
165}
166impl Deref for FICR_NS {
167 type Target = ficr_ns::RegisterBlock;
168 #[inline(always)]
169 fn deref(&self) -> &Self::Target {
170 unsafe { &*Self::PTR }
171 }
172}
173impl core::fmt::Debug for FICR_NS {
174 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
175 f.debug_struct("FICR_NS").finish()
176 }
177}
178#[doc = "Factory Information Configuration Registers"]
179pub mod ficr_ns;
180#[doc = "User Information Configuration Registers"]
181pub struct UICR_NS {
182 _marker: PhantomData<*const ()>,
183}
184unsafe impl Send for UICR_NS {}
185impl UICR_NS {
186 #[doc = r"Pointer to the register block"]
187 pub const PTR: *const uicr_ns::RegisterBlock = 0x01ff_8000 as *const _;
188 #[doc = r"Return the pointer to the register block"]
189 #[inline(always)]
190 pub const fn ptr() -> *const uicr_ns::RegisterBlock {
191 Self::PTR
192 }
193}
194impl Deref for UICR_NS {
195 type Target = uicr_ns::RegisterBlock;
196 #[inline(always)]
197 fn deref(&self) -> &Self::Target {
198 unsafe { &*Self::PTR }
199 }
200}
201impl core::fmt::Debug for UICR_NS {
202 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
203 f.debug_struct("UICR_NS").finish()
204 }
205}
206#[doc = "User Information Configuration Registers"]
207pub mod uicr_ns;
208#[doc = "Cross-Trigger Interface control. NOTE: this is not a separate peripheral, but describes CM33 functionality."]
209pub struct CTI_NS {
210 _marker: PhantomData<*const ()>,
211}
212unsafe impl Send for CTI_NS {}
213impl CTI_NS {
214 #[doc = r"Pointer to the register block"]
215 pub const PTR: *const cti_ns::RegisterBlock = 0xe004_2000 as *const _;
216 #[doc = r"Return the pointer to the register block"]
217 #[inline(always)]
218 pub const fn ptr() -> *const cti_ns::RegisterBlock {
219 Self::PTR
220 }
221}
222impl Deref for CTI_NS {
223 type Target = cti_ns::RegisterBlock;
224 #[inline(always)]
225 fn deref(&self) -> &Self::Target {
226 unsafe { &*Self::PTR }
227 }
228}
229impl core::fmt::Debug for CTI_NS {
230 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
231 f.debug_struct("CTI_NS").finish()
232 }
233}
234#[doc = "Cross-Trigger Interface control. NOTE: this is not a separate peripheral, but describes CM33 functionality."]
235pub mod cti_ns;
236#[doc = "Domain configuration management"]
237pub struct DCNF_NS {
238 _marker: PhantomData<*const ()>,
239}
240unsafe impl Send for DCNF_NS {}
241impl DCNF_NS {
242 #[doc = r"Pointer to the register block"]
243 pub const PTR: *const dcnf_ns::RegisterBlock = 0x4100_0000 as *const _;
244 #[doc = r"Return the pointer to the register block"]
245 #[inline(always)]
246 pub const fn ptr() -> *const dcnf_ns::RegisterBlock {
247 Self::PTR
248 }
249}
250impl Deref for DCNF_NS {
251 type Target = dcnf_ns::RegisterBlock;
252 #[inline(always)]
253 fn deref(&self) -> &Self::Target {
254 unsafe { &*Self::PTR }
255 }
256}
257impl core::fmt::Debug for DCNF_NS {
258 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
259 f.debug_struct("DCNF_NS").finish()
260 }
261}
262#[doc = "Domain configuration management"]
263pub mod dcnf_ns;
264#[doc = "Voltage request control"]
265pub struct VREQCTRL_NS {
266 _marker: PhantomData<*const ()>,
267}
268unsafe impl Send for VREQCTRL_NS {}
269impl VREQCTRL_NS {
270 #[doc = r"Pointer to the register block"]
271 pub const PTR: *const vreqctrl_ns::RegisterBlock = 0x4100_4000 as *const _;
272 #[doc = r"Return the pointer to the register block"]
273 #[inline(always)]
274 pub const fn ptr() -> *const vreqctrl_ns::RegisterBlock {
275 Self::PTR
276 }
277}
278impl Deref for VREQCTRL_NS {
279 type Target = vreqctrl_ns::RegisterBlock;
280 #[inline(always)]
281 fn deref(&self) -> &Self::Target {
282 unsafe { &*Self::PTR }
283 }
284}
285impl core::fmt::Debug for VREQCTRL_NS {
286 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
287 f.debug_struct("VREQCTRL_NS").finish()
288 }
289}
290#[doc = "Voltage request control"]
291pub mod vreqctrl_ns;
292#[doc = "Clock management"]
293pub struct CLOCK_NS {
294 _marker: PhantomData<*const ()>,
295}
296unsafe impl Send for CLOCK_NS {}
297impl CLOCK_NS {
298 #[doc = r"Pointer to the register block"]
299 pub const PTR: *const clock_ns::RegisterBlock = 0x4100_5000 as *const _;
300 #[doc = r"Return the pointer to the register block"]
301 #[inline(always)]
302 pub const fn ptr() -> *const clock_ns::RegisterBlock {
303 Self::PTR
304 }
305}
306impl Deref for CLOCK_NS {
307 type Target = clock_ns::RegisterBlock;
308 #[inline(always)]
309 fn deref(&self) -> &Self::Target {
310 unsafe { &*Self::PTR }
311 }
312}
313impl core::fmt::Debug for CLOCK_NS {
314 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
315 f.debug_struct("CLOCK_NS").finish()
316 }
317}
318#[doc = "Clock management"]
319pub mod clock_ns;
320#[doc = "Power control"]
321pub struct POWER_NS {
322 _marker: PhantomData<*const ()>,
323}
324unsafe impl Send for POWER_NS {}
325impl POWER_NS {
326 #[doc = r"Pointer to the register block"]
327 pub const PTR: *const power_ns::RegisterBlock = 0x4100_5000 as *const _;
328 #[doc = r"Return the pointer to the register block"]
329 #[inline(always)]
330 pub const fn ptr() -> *const power_ns::RegisterBlock {
331 Self::PTR
332 }
333}
334impl Deref for POWER_NS {
335 type Target = power_ns::RegisterBlock;
336 #[inline(always)]
337 fn deref(&self) -> &Self::Target {
338 unsafe { &*Self::PTR }
339 }
340}
341impl core::fmt::Debug for POWER_NS {
342 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
343 f.debug_struct("POWER_NS").finish()
344 }
345}
346#[doc = "Power control"]
347pub mod power_ns;
348#[doc = "Reset control"]
349pub struct RESET_NS {
350 _marker: PhantomData<*const ()>,
351}
352unsafe impl Send for RESET_NS {}
353impl RESET_NS {
354 #[doc = r"Pointer to the register block"]
355 pub const PTR: *const reset_ns::RegisterBlock = 0x4100_5000 as *const _;
356 #[doc = r"Return the pointer to the register block"]
357 #[inline(always)]
358 pub const fn ptr() -> *const reset_ns::RegisterBlock {
359 Self::PTR
360 }
361}
362impl Deref for RESET_NS {
363 type Target = reset_ns::RegisterBlock;
364 #[inline(always)]
365 fn deref(&self) -> &Self::Target {
366 unsafe { &*Self::PTR }
367 }
368}
369impl core::fmt::Debug for RESET_NS {
370 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
371 f.debug_struct("RESET_NS").finish()
372 }
373}
374#[doc = "Reset control"]
375pub mod reset_ns;
376#[doc = "Control access port"]
377pub struct CTRLAP_NS {
378 _marker: PhantomData<*const ()>,
379}
380unsafe impl Send for CTRLAP_NS {}
381impl CTRLAP_NS {
382 #[doc = r"Pointer to the register block"]
383 pub const PTR: *const ctrlap_ns::RegisterBlock = 0x4100_6000 as *const _;
384 #[doc = r"Return the pointer to the register block"]
385 #[inline(always)]
386 pub const fn ptr() -> *const ctrlap_ns::RegisterBlock {
387 Self::PTR
388 }
389}
390impl Deref for CTRLAP_NS {
391 type Target = ctrlap_ns::RegisterBlock;
392 #[inline(always)]
393 fn deref(&self) -> &Self::Target {
394 unsafe { &*Self::PTR }
395 }
396}
397impl core::fmt::Debug for CTRLAP_NS {
398 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
399 f.debug_struct("CTRLAP_NS").finish()
400 }
401}
402#[doc = "Control access port"]
403pub mod ctrlap_ns;
404#[doc = "2.4 GHz radio"]
405pub struct RADIO_NS {
406 _marker: PhantomData<*const ()>,
407}
408unsafe impl Send for RADIO_NS {}
409impl RADIO_NS {
410 #[doc = r"Pointer to the register block"]
411 pub const PTR: *const radio_ns::RegisterBlock = 0x4100_8000 as *const _;
412 #[doc = r"Return the pointer to the register block"]
413 #[inline(always)]
414 pub const fn ptr() -> *const radio_ns::RegisterBlock {
415 Self::PTR
416 }
417}
418impl Deref for RADIO_NS {
419 type Target = radio_ns::RegisterBlock;
420 #[inline(always)]
421 fn deref(&self) -> &Self::Target {
422 unsafe { &*Self::PTR }
423 }
424}
425impl core::fmt::Debug for RADIO_NS {
426 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
427 f.debug_struct("RADIO_NS").finish()
428 }
429}
430#[doc = "2.4 GHz radio"]
431pub mod radio_ns;
432#[doc = "Random Number Generator"]
433pub struct RNG_NS {
434 _marker: PhantomData<*const ()>,
435}
436unsafe impl Send for RNG_NS {}
437impl RNG_NS {
438 #[doc = r"Pointer to the register block"]
439 pub const PTR: *const rng_ns::RegisterBlock = 0x4100_9000 as *const _;
440 #[doc = r"Return the pointer to the register block"]
441 #[inline(always)]
442 pub const fn ptr() -> *const rng_ns::RegisterBlock {
443 Self::PTR
444 }
445}
446impl Deref for RNG_NS {
447 type Target = rng_ns::RegisterBlock;
448 #[inline(always)]
449 fn deref(&self) -> &Self::Target {
450 unsafe { &*Self::PTR }
451 }
452}
453impl core::fmt::Debug for RNG_NS {
454 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
455 f.debug_struct("RNG_NS").finish()
456 }
457}
458#[doc = "Random Number Generator"]
459pub mod rng_ns;
460#[doc = "GPIO Tasks and Events"]
461pub struct GPIOTE_NS {
462 _marker: PhantomData<*const ()>,
463}
464unsafe impl Send for GPIOTE_NS {}
465impl GPIOTE_NS {
466 #[doc = r"Pointer to the register block"]
467 pub const PTR: *const gpiote_ns::RegisterBlock = 0x4100_a000 as *const _;
468 #[doc = r"Return the pointer to the register block"]
469 #[inline(always)]
470 pub const fn ptr() -> *const gpiote_ns::RegisterBlock {
471 Self::PTR
472 }
473}
474impl Deref for GPIOTE_NS {
475 type Target = gpiote_ns::RegisterBlock;
476 #[inline(always)]
477 fn deref(&self) -> &Self::Target {
478 unsafe { &*Self::PTR }
479 }
480}
481impl core::fmt::Debug for GPIOTE_NS {
482 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
483 f.debug_struct("GPIOTE_NS").finish()
484 }
485}
486#[doc = "GPIO Tasks and Events"]
487pub mod gpiote_ns;
488#[doc = "Watchdog Timer"]
489pub struct WDT_NS {
490 _marker: PhantomData<*const ()>,
491}
492unsafe impl Send for WDT_NS {}
493impl WDT_NS {
494 #[doc = r"Pointer to the register block"]
495 pub const PTR: *const wdt_ns::RegisterBlock = 0x4100_b000 as *const _;
496 #[doc = r"Return the pointer to the register block"]
497 #[inline(always)]
498 pub const fn ptr() -> *const wdt_ns::RegisterBlock {
499 Self::PTR
500 }
501}
502impl Deref for WDT_NS {
503 type Target = wdt_ns::RegisterBlock;
504 #[inline(always)]
505 fn deref(&self) -> &Self::Target {
506 unsafe { &*Self::PTR }
507 }
508}
509impl core::fmt::Debug for WDT_NS {
510 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
511 f.debug_struct("WDT_NS").finish()
512 }
513}
514#[doc = "Watchdog Timer"]
515pub mod wdt_ns;
516#[doc = "Timer/Counter 0"]
517pub struct TIMER0_NS {
518 _marker: PhantomData<*const ()>,
519}
520unsafe impl Send for TIMER0_NS {}
521impl TIMER0_NS {
522 #[doc = r"Pointer to the register block"]
523 pub const PTR: *const timer0_ns::RegisterBlock = 0x4100_c000 as *const _;
524 #[doc = r"Return the pointer to the register block"]
525 #[inline(always)]
526 pub const fn ptr() -> *const timer0_ns::RegisterBlock {
527 Self::PTR
528 }
529}
530impl Deref for TIMER0_NS {
531 type Target = timer0_ns::RegisterBlock;
532 #[inline(always)]
533 fn deref(&self) -> &Self::Target {
534 unsafe { &*Self::PTR }
535 }
536}
537impl core::fmt::Debug for TIMER0_NS {
538 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
539 f.debug_struct("TIMER0_NS").finish()
540 }
541}
542#[doc = "Timer/Counter 0"]
543pub mod timer0_ns;
544#[doc = "AES ECB Mode Encryption"]
545pub struct ECB_NS {
546 _marker: PhantomData<*const ()>,
547}
548unsafe impl Send for ECB_NS {}
549impl ECB_NS {
550 #[doc = r"Pointer to the register block"]
551 pub const PTR: *const ecb_ns::RegisterBlock = 0x4100_d000 as *const _;
552 #[doc = r"Return the pointer to the register block"]
553 #[inline(always)]
554 pub const fn ptr() -> *const ecb_ns::RegisterBlock {
555 Self::PTR
556 }
557}
558impl Deref for ECB_NS {
559 type Target = ecb_ns::RegisterBlock;
560 #[inline(always)]
561 fn deref(&self) -> &Self::Target {
562 unsafe { &*Self::PTR }
563 }
564}
565impl core::fmt::Debug for ECB_NS {
566 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
567 f.debug_struct("ECB_NS").finish()
568 }
569}
570#[doc = "AES ECB Mode Encryption"]
571pub mod ecb_ns;
572#[doc = "Accelerated Address Resolver"]
573pub struct AAR_NS {
574 _marker: PhantomData<*const ()>,
575}
576unsafe impl Send for AAR_NS {}
577impl AAR_NS {
578 #[doc = r"Pointer to the register block"]
579 pub const PTR: *const aar_ns::RegisterBlock = 0x4100_e000 as *const _;
580 #[doc = r"Return the pointer to the register block"]
581 #[inline(always)]
582 pub const fn ptr() -> *const aar_ns::RegisterBlock {
583 Self::PTR
584 }
585}
586impl Deref for AAR_NS {
587 type Target = aar_ns::RegisterBlock;
588 #[inline(always)]
589 fn deref(&self) -> &Self::Target {
590 unsafe { &*Self::PTR }
591 }
592}
593impl core::fmt::Debug for AAR_NS {
594 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
595 f.debug_struct("AAR_NS").finish()
596 }
597}
598#[doc = "Accelerated Address Resolver"]
599pub mod aar_ns;
600#[doc = "AES CCM mode encryption"]
601pub struct CCM_NS {
602 _marker: PhantomData<*const ()>,
603}
604unsafe impl Send for CCM_NS {}
605impl CCM_NS {
606 #[doc = r"Pointer to the register block"]
607 pub const PTR: *const ccm_ns::RegisterBlock = 0x4100_e000 as *const _;
608 #[doc = r"Return the pointer to the register block"]
609 #[inline(always)]
610 pub const fn ptr() -> *const ccm_ns::RegisterBlock {
611 Self::PTR
612 }
613}
614impl Deref for CCM_NS {
615 type Target = ccm_ns::RegisterBlock;
616 #[inline(always)]
617 fn deref(&self) -> &Self::Target {
618 unsafe { &*Self::PTR }
619 }
620}
621impl core::fmt::Debug for CCM_NS {
622 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
623 f.debug_struct("CCM_NS").finish()
624 }
625}
626#[doc = "AES CCM mode encryption"]
627pub mod ccm_ns;
628#[doc = "Distributed programmable peripheral interconnect controller"]
629pub struct DPPIC_NS {
630 _marker: PhantomData<*const ()>,
631}
632unsafe impl Send for DPPIC_NS {}
633impl DPPIC_NS {
634 #[doc = r"Pointer to the register block"]
635 pub const PTR: *const dppic_ns::RegisterBlock = 0x4100_f000 as *const _;
636 #[doc = r"Return the pointer to the register block"]
637 #[inline(always)]
638 pub const fn ptr() -> *const dppic_ns::RegisterBlock {
639 Self::PTR
640 }
641}
642impl Deref for DPPIC_NS {
643 type Target = dppic_ns::RegisterBlock;
644 #[inline(always)]
645 fn deref(&self) -> &Self::Target {
646 unsafe { &*Self::PTR }
647 }
648}
649impl core::fmt::Debug for DPPIC_NS {
650 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
651 f.debug_struct("DPPIC_NS").finish()
652 }
653}
654#[doc = "Distributed programmable peripheral interconnect controller"]
655pub mod dppic_ns;
656#[doc = "Temperature Sensor"]
657pub struct TEMP_NS {
658 _marker: PhantomData<*const ()>,
659}
660unsafe impl Send for TEMP_NS {}
661impl TEMP_NS {
662 #[doc = r"Pointer to the register block"]
663 pub const PTR: *const temp_ns::RegisterBlock = 0x4101_0000 as *const _;
664 #[doc = r"Return the pointer to the register block"]
665 #[inline(always)]
666 pub const fn ptr() -> *const temp_ns::RegisterBlock {
667 Self::PTR
668 }
669}
670impl Deref for TEMP_NS {
671 type Target = temp_ns::RegisterBlock;
672 #[inline(always)]
673 fn deref(&self) -> &Self::Target {
674 unsafe { &*Self::PTR }
675 }
676}
677impl core::fmt::Debug for TEMP_NS {
678 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
679 f.debug_struct("TEMP_NS").finish()
680 }
681}
682#[doc = "Temperature Sensor"]
683pub mod temp_ns;
684#[doc = "Real-time counter 0"]
685pub struct RTC0_NS {
686 _marker: PhantomData<*const ()>,
687}
688unsafe impl Send for RTC0_NS {}
689impl RTC0_NS {
690 #[doc = r"Pointer to the register block"]
691 pub const PTR: *const rtc0_ns::RegisterBlock = 0x4101_1000 as *const _;
692 #[doc = r"Return the pointer to the register block"]
693 #[inline(always)]
694 pub const fn ptr() -> *const rtc0_ns::RegisterBlock {
695 Self::PTR
696 }
697}
698impl Deref for RTC0_NS {
699 type Target = rtc0_ns::RegisterBlock;
700 #[inline(always)]
701 fn deref(&self) -> &Self::Target {
702 unsafe { &*Self::PTR }
703 }
704}
705impl core::fmt::Debug for RTC0_NS {
706 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
707 f.debug_struct("RTC0_NS").finish()
708 }
709}
710#[doc = "Real-time counter 0"]
711pub mod rtc0_ns;
712#[doc = "Interprocessor communication"]
713pub struct IPC_NS {
714 _marker: PhantomData<*const ()>,
715}
716unsafe impl Send for IPC_NS {}
717impl IPC_NS {
718 #[doc = r"Pointer to the register block"]
719 pub const PTR: *const ipc_ns::RegisterBlock = 0x4101_2000 as *const _;
720 #[doc = r"Return the pointer to the register block"]
721 #[inline(always)]
722 pub const fn ptr() -> *const ipc_ns::RegisterBlock {
723 Self::PTR
724 }
725}
726impl Deref for IPC_NS {
727 type Target = ipc_ns::RegisterBlock;
728 #[inline(always)]
729 fn deref(&self) -> &Self::Target {
730 unsafe { &*Self::PTR }
731 }
732}
733impl core::fmt::Debug for IPC_NS {
734 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
735 f.debug_struct("IPC_NS").finish()
736 }
737}
738#[doc = "Interprocessor communication"]
739pub mod ipc_ns;
740#[doc = "Serial Peripheral Interface Master with EasyDMA"]
741pub struct SPIM0_NS {
742 _marker: PhantomData<*const ()>,
743}
744unsafe impl Send for SPIM0_NS {}
745impl SPIM0_NS {
746 #[doc = r"Pointer to the register block"]
747 pub const PTR: *const spim0_ns::RegisterBlock = 0x4101_3000 as *const _;
748 #[doc = r"Return the pointer to the register block"]
749 #[inline(always)]
750 pub const fn ptr() -> *const spim0_ns::RegisterBlock {
751 Self::PTR
752 }
753}
754impl Deref for SPIM0_NS {
755 type Target = spim0_ns::RegisterBlock;
756 #[inline(always)]
757 fn deref(&self) -> &Self::Target {
758 unsafe { &*Self::PTR }
759 }
760}
761impl core::fmt::Debug for SPIM0_NS {
762 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
763 f.debug_struct("SPIM0_NS").finish()
764 }
765}
766#[doc = "Serial Peripheral Interface Master with EasyDMA"]
767pub mod spim0_ns;
768#[doc = "SPI Slave"]
769pub struct SPIS0_NS {
770 _marker: PhantomData<*const ()>,
771}
772unsafe impl Send for SPIS0_NS {}
773impl SPIS0_NS {
774 #[doc = r"Pointer to the register block"]
775 pub const PTR: *const spis0_ns::RegisterBlock = 0x4101_3000 as *const _;
776 #[doc = r"Return the pointer to the register block"]
777 #[inline(always)]
778 pub const fn ptr() -> *const spis0_ns::RegisterBlock {
779 Self::PTR
780 }
781}
782impl Deref for SPIS0_NS {
783 type Target = spis0_ns::RegisterBlock;
784 #[inline(always)]
785 fn deref(&self) -> &Self::Target {
786 unsafe { &*Self::PTR }
787 }
788}
789impl core::fmt::Debug for SPIS0_NS {
790 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
791 f.debug_struct("SPIS0_NS").finish()
792 }
793}
794#[doc = "SPI Slave"]
795pub mod spis0_ns;
796#[doc = "I2C compatible Two-Wire Master Interface with EasyDMA"]
797pub struct TWIM0_NS {
798 _marker: PhantomData<*const ()>,
799}
800unsafe impl Send for TWIM0_NS {}
801impl TWIM0_NS {
802 #[doc = r"Pointer to the register block"]
803 pub const PTR: *const twim0_ns::RegisterBlock = 0x4101_3000 as *const _;
804 #[doc = r"Return the pointer to the register block"]
805 #[inline(always)]
806 pub const fn ptr() -> *const twim0_ns::RegisterBlock {
807 Self::PTR
808 }
809}
810impl Deref for TWIM0_NS {
811 type Target = twim0_ns::RegisterBlock;
812 #[inline(always)]
813 fn deref(&self) -> &Self::Target {
814 unsafe { &*Self::PTR }
815 }
816}
817impl core::fmt::Debug for TWIM0_NS {
818 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
819 f.debug_struct("TWIM0_NS").finish()
820 }
821}
822#[doc = "I2C compatible Two-Wire Master Interface with EasyDMA"]
823pub mod twim0_ns;
824#[doc = "I2C compatible Two-Wire Slave Interface with EasyDMA"]
825pub struct TWIS0_NS {
826 _marker: PhantomData<*const ()>,
827}
828unsafe impl Send for TWIS0_NS {}
829impl TWIS0_NS {
830 #[doc = r"Pointer to the register block"]
831 pub const PTR: *const twis0_ns::RegisterBlock = 0x4101_3000 as *const _;
832 #[doc = r"Return the pointer to the register block"]
833 #[inline(always)]
834 pub const fn ptr() -> *const twis0_ns::RegisterBlock {
835 Self::PTR
836 }
837}
838impl Deref for TWIS0_NS {
839 type Target = twis0_ns::RegisterBlock;
840 #[inline(always)]
841 fn deref(&self) -> &Self::Target {
842 unsafe { &*Self::PTR }
843 }
844}
845impl core::fmt::Debug for TWIS0_NS {
846 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
847 f.debug_struct("TWIS0_NS").finish()
848 }
849}
850#[doc = "I2C compatible Two-Wire Slave Interface with EasyDMA"]
851pub mod twis0_ns;
852#[doc = "UART with EasyDMA"]
853pub struct UARTE0_NS {
854 _marker: PhantomData<*const ()>,
855}
856unsafe impl Send for UARTE0_NS {}
857impl UARTE0_NS {
858 #[doc = r"Pointer to the register block"]
859 pub const PTR: *const uarte0_ns::RegisterBlock = 0x4101_3000 as *const _;
860 #[doc = r"Return the pointer to the register block"]
861 #[inline(always)]
862 pub const fn ptr() -> *const uarte0_ns::RegisterBlock {
863 Self::PTR
864 }
865}
866impl Deref for UARTE0_NS {
867 type Target = uarte0_ns::RegisterBlock;
868 #[inline(always)]
869 fn deref(&self) -> &Self::Target {
870 unsafe { &*Self::PTR }
871 }
872}
873impl core::fmt::Debug for UARTE0_NS {
874 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
875 f.debug_struct("UARTE0_NS").finish()
876 }
877}
878#[doc = "UART with EasyDMA"]
879pub mod uarte0_ns;
880#[doc = "Event generator unit"]
881pub struct EGU0_NS {
882 _marker: PhantomData<*const ()>,
883}
884unsafe impl Send for EGU0_NS {}
885impl EGU0_NS {
886 #[doc = r"Pointer to the register block"]
887 pub const PTR: *const egu0_ns::RegisterBlock = 0x4101_4000 as *const _;
888 #[doc = r"Return the pointer to the register block"]
889 #[inline(always)]
890 pub const fn ptr() -> *const egu0_ns::RegisterBlock {
891 Self::PTR
892 }
893}
894impl Deref for EGU0_NS {
895 type Target = egu0_ns::RegisterBlock;
896 #[inline(always)]
897 fn deref(&self) -> &Self::Target {
898 unsafe { &*Self::PTR }
899 }
900}
901impl core::fmt::Debug for EGU0_NS {
902 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
903 f.debug_struct("EGU0_NS").finish()
904 }
905}
906#[doc = "Event generator unit"]
907pub mod egu0_ns;
908#[doc = "Real-time counter 1"]
909pub struct RTC1_NS {
910 _marker: PhantomData<*const ()>,
911}
912unsafe impl Send for RTC1_NS {}
913impl RTC1_NS {
914 #[doc = r"Pointer to the register block"]
915 pub const PTR: *const rtc0_ns::RegisterBlock = 0x4101_6000 as *const _;
916 #[doc = r"Return the pointer to the register block"]
917 #[inline(always)]
918 pub const fn ptr() -> *const rtc0_ns::RegisterBlock {
919 Self::PTR
920 }
921}
922impl Deref for RTC1_NS {
923 type Target = rtc0_ns::RegisterBlock;
924 #[inline(always)]
925 fn deref(&self) -> &Self::Target {
926 unsafe { &*Self::PTR }
927 }
928}
929impl core::fmt::Debug for RTC1_NS {
930 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
931 f.debug_struct("RTC1_NS").finish()
932 }
933}
934#[doc = "Real-time counter 1"]
935pub use rtc0_ns as rtc1_ns;
936#[doc = "Timer/Counter 1"]
937pub struct TIMER1_NS {
938 _marker: PhantomData<*const ()>,
939}
940unsafe impl Send for TIMER1_NS {}
941impl TIMER1_NS {
942 #[doc = r"Pointer to the register block"]
943 pub const PTR: *const timer0_ns::RegisterBlock = 0x4101_8000 as *const _;
944 #[doc = r"Return the pointer to the register block"]
945 #[inline(always)]
946 pub const fn ptr() -> *const timer0_ns::RegisterBlock {
947 Self::PTR
948 }
949}
950impl Deref for TIMER1_NS {
951 type Target = timer0_ns::RegisterBlock;
952 #[inline(always)]
953 fn deref(&self) -> &Self::Target {
954 unsafe { &*Self::PTR }
955 }
956}
957impl core::fmt::Debug for TIMER1_NS {
958 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
959 f.debug_struct("TIMER1_NS").finish()
960 }
961}
962#[doc = "Timer/Counter 1"]
963pub use timer0_ns as timer1_ns;
964#[doc = "Timer/Counter 2"]
965pub struct TIMER2_NS {
966 _marker: PhantomData<*const ()>,
967}
968unsafe impl Send for TIMER2_NS {}
969impl TIMER2_NS {
970 #[doc = r"Pointer to the register block"]
971 pub const PTR: *const timer0_ns::RegisterBlock = 0x4101_9000 as *const _;
972 #[doc = r"Return the pointer to the register block"]
973 #[inline(always)]
974 pub const fn ptr() -> *const timer0_ns::RegisterBlock {
975 Self::PTR
976 }
977}
978impl Deref for TIMER2_NS {
979 type Target = timer0_ns::RegisterBlock;
980 #[inline(always)]
981 fn deref(&self) -> &Self::Target {
982 unsafe { &*Self::PTR }
983 }
984}
985impl core::fmt::Debug for TIMER2_NS {
986 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
987 f.debug_struct("TIMER2_NS").finish()
988 }
989}
990#[doc = "Timer/Counter 2"]
991pub use timer0_ns as timer2_ns;
992#[doc = "Software interrupt 0"]
993pub struct SWI0_NS {
994 _marker: PhantomData<*const ()>,
995}
996unsafe impl Send for SWI0_NS {}
997impl SWI0_NS {
998 #[doc = r"Pointer to the register block"]
999 pub const PTR: *const swi0_ns::RegisterBlock = 0x4101_a000 as *const _;
1000 #[doc = r"Return the pointer to the register block"]
1001 #[inline(always)]
1002 pub const fn ptr() -> *const swi0_ns::RegisterBlock {
1003 Self::PTR
1004 }
1005}
1006impl Deref for SWI0_NS {
1007 type Target = swi0_ns::RegisterBlock;
1008 #[inline(always)]
1009 fn deref(&self) -> &Self::Target {
1010 unsafe { &*Self::PTR }
1011 }
1012}
1013impl core::fmt::Debug for SWI0_NS {
1014 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1015 f.debug_struct("SWI0_NS").finish()
1016 }
1017}
1018#[doc = "Software interrupt 0"]
1019pub mod swi0_ns;
1020#[doc = "Software interrupt 1"]
1021pub struct SWI1_NS {
1022 _marker: PhantomData<*const ()>,
1023}
1024unsafe impl Send for SWI1_NS {}
1025impl SWI1_NS {
1026 #[doc = r"Pointer to the register block"]
1027 pub const PTR: *const swi0_ns::RegisterBlock = 0x4101_b000 as *const _;
1028 #[doc = r"Return the pointer to the register block"]
1029 #[inline(always)]
1030 pub const fn ptr() -> *const swi0_ns::RegisterBlock {
1031 Self::PTR
1032 }
1033}
1034impl Deref for SWI1_NS {
1035 type Target = swi0_ns::RegisterBlock;
1036 #[inline(always)]
1037 fn deref(&self) -> &Self::Target {
1038 unsafe { &*Self::PTR }
1039 }
1040}
1041impl core::fmt::Debug for SWI1_NS {
1042 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1043 f.debug_struct("SWI1_NS").finish()
1044 }
1045}
1046#[doc = "Software interrupt 1"]
1047pub use swi0_ns as swi1_ns;
1048#[doc = "Software interrupt 2"]
1049pub struct SWI2_NS {
1050 _marker: PhantomData<*const ()>,
1051}
1052unsafe impl Send for SWI2_NS {}
1053impl SWI2_NS {
1054 #[doc = r"Pointer to the register block"]
1055 pub const PTR: *const swi0_ns::RegisterBlock = 0x4101_c000 as *const _;
1056 #[doc = r"Return the pointer to the register block"]
1057 #[inline(always)]
1058 pub const fn ptr() -> *const swi0_ns::RegisterBlock {
1059 Self::PTR
1060 }
1061}
1062impl Deref for SWI2_NS {
1063 type Target = swi0_ns::RegisterBlock;
1064 #[inline(always)]
1065 fn deref(&self) -> &Self::Target {
1066 unsafe { &*Self::PTR }
1067 }
1068}
1069impl core::fmt::Debug for SWI2_NS {
1070 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1071 f.debug_struct("SWI2_NS").finish()
1072 }
1073}
1074#[doc = "Software interrupt 2"]
1075pub use swi0_ns as swi2_ns;
1076#[doc = "Software interrupt 3"]
1077pub struct SWI3_NS {
1078 _marker: PhantomData<*const ()>,
1079}
1080unsafe impl Send for SWI3_NS {}
1081impl SWI3_NS {
1082 #[doc = r"Pointer to the register block"]
1083 pub const PTR: *const swi0_ns::RegisterBlock = 0x4101_d000 as *const _;
1084 #[doc = r"Return the pointer to the register block"]
1085 #[inline(always)]
1086 pub const fn ptr() -> *const swi0_ns::RegisterBlock {
1087 Self::PTR
1088 }
1089}
1090impl Deref for SWI3_NS {
1091 type Target = swi0_ns::RegisterBlock;
1092 #[inline(always)]
1093 fn deref(&self) -> &Self::Target {
1094 unsafe { &*Self::PTR }
1095 }
1096}
1097impl core::fmt::Debug for SWI3_NS {
1098 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1099 f.debug_struct("SWI3_NS").finish()
1100 }
1101}
1102#[doc = "Software interrupt 3"]
1103pub use swi0_ns as swi3_ns;
1104#[doc = "MUTEX 0"]
1105pub struct APPMUTEX_NS {
1106 _marker: PhantomData<*const ()>,
1107}
1108unsafe impl Send for APPMUTEX_NS {}
1109impl APPMUTEX_NS {
1110 #[doc = r"Pointer to the register block"]
1111 pub const PTR: *const appmutex_ns::RegisterBlock = 0x4003_0000 as *const _;
1112 #[doc = r"Return the pointer to the register block"]
1113 #[inline(always)]
1114 pub const fn ptr() -> *const appmutex_ns::RegisterBlock {
1115 Self::PTR
1116 }
1117}
1118impl Deref for APPMUTEX_NS {
1119 type Target = appmutex_ns::RegisterBlock;
1120 #[inline(always)]
1121 fn deref(&self) -> &Self::Target {
1122 unsafe { &*Self::PTR }
1123 }
1124}
1125impl core::fmt::Debug for APPMUTEX_NS {
1126 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1127 f.debug_struct("APPMUTEX_NS").finish()
1128 }
1129}
1130#[doc = "MUTEX 0"]
1131pub mod appmutex_ns;
1132#[doc = "MUTEX 1"]
1133pub struct APPMUTEX_S {
1134 _marker: PhantomData<*const ()>,
1135}
1136unsafe impl Send for APPMUTEX_S {}
1137impl APPMUTEX_S {
1138 #[doc = r"Pointer to the register block"]
1139 pub const PTR: *const appmutex_ns::RegisterBlock = 0x5003_0000 as *const _;
1140 #[doc = r"Return the pointer to the register block"]
1141 #[inline(always)]
1142 pub const fn ptr() -> *const appmutex_ns::RegisterBlock {
1143 Self::PTR
1144 }
1145}
1146impl Deref for APPMUTEX_S {
1147 type Target = appmutex_ns::RegisterBlock;
1148 #[inline(always)]
1149 fn deref(&self) -> &Self::Target {
1150 unsafe { &*Self::PTR }
1151 }
1152}
1153impl core::fmt::Debug for APPMUTEX_S {
1154 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1155 f.debug_struct("APPMUTEX_S").finish()
1156 }
1157}
1158#[doc = "MUTEX 1"]
1159pub use appmutex_ns as appmutex_s;
1160#[doc = "Access control lists"]
1161pub struct ACL_NS {
1162 _marker: PhantomData<*const ()>,
1163}
1164unsafe impl Send for ACL_NS {}
1165impl ACL_NS {
1166 #[doc = r"Pointer to the register block"]
1167 pub const PTR: *const acl_ns::RegisterBlock = 0x4108_0000 as *const _;
1168 #[doc = r"Return the pointer to the register block"]
1169 #[inline(always)]
1170 pub const fn ptr() -> *const acl_ns::RegisterBlock {
1171 Self::PTR
1172 }
1173}
1174impl Deref for ACL_NS {
1175 type Target = acl_ns::RegisterBlock;
1176 #[inline(always)]
1177 fn deref(&self) -> &Self::Target {
1178 unsafe { &*Self::PTR }
1179 }
1180}
1181impl core::fmt::Debug for ACL_NS {
1182 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1183 f.debug_struct("ACL_NS").finish()
1184 }
1185}
1186#[doc = "Access control lists"]
1187pub mod acl_ns;
1188#[doc = "Non-volatile memory controller"]
1189pub struct NVMC_NS {
1190 _marker: PhantomData<*const ()>,
1191}
1192unsafe impl Send for NVMC_NS {}
1193impl NVMC_NS {
1194 #[doc = r"Pointer to the register block"]
1195 pub const PTR: *const nvmc_ns::RegisterBlock = 0x4108_0000 as *const _;
1196 #[doc = r"Return the pointer to the register block"]
1197 #[inline(always)]
1198 pub const fn ptr() -> *const nvmc_ns::RegisterBlock {
1199 Self::PTR
1200 }
1201}
1202impl Deref for NVMC_NS {
1203 type Target = nvmc_ns::RegisterBlock;
1204 #[inline(always)]
1205 fn deref(&self) -> &Self::Target {
1206 unsafe { &*Self::PTR }
1207 }
1208}
1209impl core::fmt::Debug for NVMC_NS {
1210 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1211 f.debug_struct("NVMC_NS").finish()
1212 }
1213}
1214#[doc = "Non-volatile memory controller"]
1215pub mod nvmc_ns;
1216#[doc = "Volatile Memory controller"]
1217pub struct VMC_NS {
1218 _marker: PhantomData<*const ()>,
1219}
1220unsafe impl Send for VMC_NS {}
1221impl VMC_NS {
1222 #[doc = r"Pointer to the register block"]
1223 pub const PTR: *const vmc_ns::RegisterBlock = 0x4108_1000 as *const _;
1224 #[doc = r"Return the pointer to the register block"]
1225 #[inline(always)]
1226 pub const fn ptr() -> *const vmc_ns::RegisterBlock {
1227 Self::PTR
1228 }
1229}
1230impl Deref for VMC_NS {
1231 type Target = vmc_ns::RegisterBlock;
1232 #[inline(always)]
1233 fn deref(&self) -> &Self::Target {
1234 unsafe { &*Self::PTR }
1235 }
1236}
1237impl core::fmt::Debug for VMC_NS {
1238 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1239 f.debug_struct("VMC_NS").finish()
1240 }
1241}
1242#[doc = "Volatile Memory controller"]
1243pub mod vmc_ns;
1244#[doc = "GPIO Port 0"]
1245pub struct P0_NS {
1246 _marker: PhantomData<*const ()>,
1247}
1248unsafe impl Send for P0_NS {}
1249impl P0_NS {
1250 #[doc = r"Pointer to the register block"]
1251 pub const PTR: *const p0_ns::RegisterBlock = 0x418c_0500 as *const _;
1252 #[doc = r"Return the pointer to the register block"]
1253 #[inline(always)]
1254 pub const fn ptr() -> *const p0_ns::RegisterBlock {
1255 Self::PTR
1256 }
1257}
1258impl Deref for P0_NS {
1259 type Target = p0_ns::RegisterBlock;
1260 #[inline(always)]
1261 fn deref(&self) -> &Self::Target {
1262 unsafe { &*Self::PTR }
1263 }
1264}
1265impl core::fmt::Debug for P0_NS {
1266 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1267 f.debug_struct("P0_NS").finish()
1268 }
1269}
1270#[doc = "GPIO Port 0"]
1271pub mod p0_ns;
1272#[doc = "GPIO Port 1"]
1273pub struct P1_NS {
1274 _marker: PhantomData<*const ()>,
1275}
1276unsafe impl Send for P1_NS {}
1277impl P1_NS {
1278 #[doc = r"Pointer to the register block"]
1279 pub const PTR: *const p0_ns::RegisterBlock = 0x418c_0800 as *const _;
1280 #[doc = r"Return the pointer to the register block"]
1281 #[inline(always)]
1282 pub const fn ptr() -> *const p0_ns::RegisterBlock {
1283 Self::PTR
1284 }
1285}
1286impl Deref for P1_NS {
1287 type Target = p0_ns::RegisterBlock;
1288 #[inline(always)]
1289 fn deref(&self) -> &Self::Target {
1290 unsafe { &*Self::PTR }
1291 }
1292}
1293impl core::fmt::Debug for P1_NS {
1294 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1295 f.debug_struct("P1_NS").finish()
1296 }
1297}
1298#[doc = "GPIO Port 1"]
1299pub use p0_ns as p1_ns;
1300#[no_mangle]
1301static mut DEVICE_PERIPHERALS: bool = false;
1302#[doc = r"All the peripherals"]
1303#[allow(non_snake_case)]
1304pub struct Peripherals {
1305 #[doc = "FICR_NS"]
1306 pub FICR_NS: FICR_NS,
1307 #[doc = "UICR_NS"]
1308 pub UICR_NS: UICR_NS,
1309 #[doc = "CTI_NS"]
1310 pub CTI_NS: CTI_NS,
1311 #[doc = "DCNF_NS"]
1312 pub DCNF_NS: DCNF_NS,
1313 #[doc = "VREQCTRL_NS"]
1314 pub VREQCTRL_NS: VREQCTRL_NS,
1315 #[doc = "CLOCK_NS"]
1316 pub CLOCK_NS: CLOCK_NS,
1317 #[doc = "POWER_NS"]
1318 pub POWER_NS: POWER_NS,
1319 #[doc = "RESET_NS"]
1320 pub RESET_NS: RESET_NS,
1321 #[doc = "CTRLAP_NS"]
1322 pub CTRLAP_NS: CTRLAP_NS,
1323 #[doc = "RADIO_NS"]
1324 pub RADIO_NS: RADIO_NS,
1325 #[doc = "RNG_NS"]
1326 pub RNG_NS: RNG_NS,
1327 #[doc = "GPIOTE_NS"]
1328 pub GPIOTE_NS: GPIOTE_NS,
1329 #[doc = "WDT_NS"]
1330 pub WDT_NS: WDT_NS,
1331 #[doc = "TIMER0_NS"]
1332 pub TIMER0_NS: TIMER0_NS,
1333 #[doc = "ECB_NS"]
1334 pub ECB_NS: ECB_NS,
1335 #[doc = "AAR_NS"]
1336 pub AAR_NS: AAR_NS,
1337 #[doc = "CCM_NS"]
1338 pub CCM_NS: CCM_NS,
1339 #[doc = "DPPIC_NS"]
1340 pub DPPIC_NS: DPPIC_NS,
1341 #[doc = "TEMP_NS"]
1342 pub TEMP_NS: TEMP_NS,
1343 #[doc = "RTC0_NS"]
1344 pub RTC0_NS: RTC0_NS,
1345 #[doc = "IPC_NS"]
1346 pub IPC_NS: IPC_NS,
1347 #[doc = "SPIM0_NS"]
1348 pub SPIM0_NS: SPIM0_NS,
1349 #[doc = "SPIS0_NS"]
1350 pub SPIS0_NS: SPIS0_NS,
1351 #[doc = "TWIM0_NS"]
1352 pub TWIM0_NS: TWIM0_NS,
1353 #[doc = "TWIS0_NS"]
1354 pub TWIS0_NS: TWIS0_NS,
1355 #[doc = "UARTE0_NS"]
1356 pub UARTE0_NS: UARTE0_NS,
1357 #[doc = "EGU0_NS"]
1358 pub EGU0_NS: EGU0_NS,
1359 #[doc = "RTC1_NS"]
1360 pub RTC1_NS: RTC1_NS,
1361 #[doc = "TIMER1_NS"]
1362 pub TIMER1_NS: TIMER1_NS,
1363 #[doc = "TIMER2_NS"]
1364 pub TIMER2_NS: TIMER2_NS,
1365 #[doc = "SWI0_NS"]
1366 pub SWI0_NS: SWI0_NS,
1367 #[doc = "SWI1_NS"]
1368 pub SWI1_NS: SWI1_NS,
1369 #[doc = "SWI2_NS"]
1370 pub SWI2_NS: SWI2_NS,
1371 #[doc = "SWI3_NS"]
1372 pub SWI3_NS: SWI3_NS,
1373 #[doc = "APPMUTEX_NS"]
1374 pub APPMUTEX_NS: APPMUTEX_NS,
1375 #[doc = "APPMUTEX_S"]
1376 pub APPMUTEX_S: APPMUTEX_S,
1377 #[doc = "ACL_NS"]
1378 pub ACL_NS: ACL_NS,
1379 #[doc = "NVMC_NS"]
1380 pub NVMC_NS: NVMC_NS,
1381 #[doc = "VMC_NS"]
1382 pub VMC_NS: VMC_NS,
1383 #[doc = "P0_NS"]
1384 pub P0_NS: P0_NS,
1385 #[doc = "P1_NS"]
1386 pub P1_NS: P1_NS,
1387}
1388impl Peripherals {
1389 #[doc = r"Returns all the peripherals *once*"]
1390 #[inline]
1391 pub fn take() -> Option<Self> {
1392 cortex_m::interrupt::free(|_| {
1393 if unsafe { DEVICE_PERIPHERALS } {
1394 None
1395 } else {
1396 Some(unsafe { Peripherals::steal() })
1397 }
1398 })
1399 }
1400 #[doc = r"Unchecked version of `Peripherals::take`"]
1401 #[inline]
1402 pub unsafe fn steal() -> Self {
1403 DEVICE_PERIPHERALS = true;
1404 Peripherals {
1405 FICR_NS: FICR_NS {
1406 _marker: PhantomData,
1407 },
1408 UICR_NS: UICR_NS {
1409 _marker: PhantomData,
1410 },
1411 CTI_NS: CTI_NS {
1412 _marker: PhantomData,
1413 },
1414 DCNF_NS: DCNF_NS {
1415 _marker: PhantomData,
1416 },
1417 VREQCTRL_NS: VREQCTRL_NS {
1418 _marker: PhantomData,
1419 },
1420 CLOCK_NS: CLOCK_NS {
1421 _marker: PhantomData,
1422 },
1423 POWER_NS: POWER_NS {
1424 _marker: PhantomData,
1425 },
1426 RESET_NS: RESET_NS {
1427 _marker: PhantomData,
1428 },
1429 CTRLAP_NS: CTRLAP_NS {
1430 _marker: PhantomData,
1431 },
1432 RADIO_NS: RADIO_NS {
1433 _marker: PhantomData,
1434 },
1435 RNG_NS: RNG_NS {
1436 _marker: PhantomData,
1437 },
1438 GPIOTE_NS: GPIOTE_NS {
1439 _marker: PhantomData,
1440 },
1441 WDT_NS: WDT_NS {
1442 _marker: PhantomData,
1443 },
1444 TIMER0_NS: TIMER0_NS {
1445 _marker: PhantomData,
1446 },
1447 ECB_NS: ECB_NS {
1448 _marker: PhantomData,
1449 },
1450 AAR_NS: AAR_NS {
1451 _marker: PhantomData,
1452 },
1453 CCM_NS: CCM_NS {
1454 _marker: PhantomData,
1455 },
1456 DPPIC_NS: DPPIC_NS {
1457 _marker: PhantomData,
1458 },
1459 TEMP_NS: TEMP_NS {
1460 _marker: PhantomData,
1461 },
1462 RTC0_NS: RTC0_NS {
1463 _marker: PhantomData,
1464 },
1465 IPC_NS: IPC_NS {
1466 _marker: PhantomData,
1467 },
1468 SPIM0_NS: SPIM0_NS {
1469 _marker: PhantomData,
1470 },
1471 SPIS0_NS: SPIS0_NS {
1472 _marker: PhantomData,
1473 },
1474 TWIM0_NS: TWIM0_NS {
1475 _marker: PhantomData,
1476 },
1477 TWIS0_NS: TWIS0_NS {
1478 _marker: PhantomData,
1479 },
1480 UARTE0_NS: UARTE0_NS {
1481 _marker: PhantomData,
1482 },
1483 EGU0_NS: EGU0_NS {
1484 _marker: PhantomData,
1485 },
1486 RTC1_NS: RTC1_NS {
1487 _marker: PhantomData,
1488 },
1489 TIMER1_NS: TIMER1_NS {
1490 _marker: PhantomData,
1491 },
1492 TIMER2_NS: TIMER2_NS {
1493 _marker: PhantomData,
1494 },
1495 SWI0_NS: SWI0_NS {
1496 _marker: PhantomData,
1497 },
1498 SWI1_NS: SWI1_NS {
1499 _marker: PhantomData,
1500 },
1501 SWI2_NS: SWI2_NS {
1502 _marker: PhantomData,
1503 },
1504 SWI3_NS: SWI3_NS {
1505 _marker: PhantomData,
1506 },
1507 APPMUTEX_NS: APPMUTEX_NS {
1508 _marker: PhantomData,
1509 },
1510 APPMUTEX_S: APPMUTEX_S {
1511 _marker: PhantomData,
1512 },
1513 ACL_NS: ACL_NS {
1514 _marker: PhantomData,
1515 },
1516 NVMC_NS: NVMC_NS {
1517 _marker: PhantomData,
1518 },
1519 VMC_NS: VMC_NS {
1520 _marker: PhantomData,
1521 },
1522 P0_NS: P0_NS {
1523 _marker: PhantomData,
1524 },
1525 P1_NS: P1_NS {
1526 _marker: PhantomData,
1527 },
1528 }
1529 }
1530}