1#![doc = "Peripheral access API for NRF52 microcontrollers (generated using svd2rust v0.13.1)\n\nYou can find an overview of the API [here].\n\n[here]: https://docs.rs/svd2rust/0.13.1/svd2rust/#peripheral-api"]
4#![deny(missing_docs)]
5#![allow(non_camel_case_types)]
6#![no_std]
7extern crate bare_metal;
8extern crate cortex_m;
9#[cfg(feature = "rt")]
10extern crate cortex_m_rt;
11extern crate vcell;
12use core::marker::PhantomData;
13use core::ops::Deref;
14#[doc = r" Number available in the NVIC for configuring priority"]
15pub const NVIC_PRIO_BITS: u8 = 3;
16#[cfg(feature = "rt")]
17extern "C" {
18 fn POWER_CLOCK();
19 fn RADIO();
20 fn UARTE0_UART0();
21 fn SPIM0_SPIS0_TWIM0_TWIS0_SPI0_TWI0();
22 fn SPIM1_SPIS1_TWIM1_TWIS1_SPI1_TWI1();
23 fn NFCT();
24 fn GPIOTE();
25 fn SAADC();
26 fn TIMER0();
27 fn TIMER1();
28 fn TIMER2();
29 fn RTC0();
30 fn TEMP();
31 fn RNG();
32 fn ECB();
33 fn CCM_AAR();
34 fn WDT();
35 fn RTC1();
36 fn QDEC();
37 fn COMP_LPCOMP();
38 fn SWI0_EGU0();
39 fn SWI1_EGU1();
40 fn SWI2_EGU2();
41 fn SWI3_EGU3();
42 fn SWI4_EGU4();
43 fn SWI5_EGU5();
44 fn TIMER3();
45 fn TIMER4();
46 fn PWM0();
47 fn PDM();
48 fn MWU();
49 fn PWM1();
50 fn PWM2();
51 fn SPIM2_SPIS2_SPI2();
52 fn RTC2();
53 fn I2S();
54 fn FPU();
55}
56#[doc(hidden)]
57pub union Vector {
58 _handler: unsafe extern "C" fn(),
59 _reserved: u32,
60}
61#[cfg(feature = "rt")]
62#[doc(hidden)]
63#[link_section = ".vector_table.interrupts"]
64#[no_mangle]
65pub static __INTERRUPTS: [Vector; 39] = [
66 Vector {
67 _handler: POWER_CLOCK,
68 },
69 Vector { _handler: RADIO },
70 Vector {
71 _handler: UARTE0_UART0,
72 },
73 Vector {
74 _handler: SPIM0_SPIS0_TWIM0_TWIS0_SPI0_TWI0,
75 },
76 Vector {
77 _handler: SPIM1_SPIS1_TWIM1_TWIS1_SPI1_TWI1,
78 },
79 Vector { _handler: NFCT },
80 Vector { _handler: GPIOTE },
81 Vector { _handler: SAADC },
82 Vector { _handler: TIMER0 },
83 Vector { _handler: TIMER1 },
84 Vector { _handler: TIMER2 },
85 Vector { _handler: RTC0 },
86 Vector { _handler: TEMP },
87 Vector { _handler: RNG },
88 Vector { _handler: ECB },
89 Vector { _handler: CCM_AAR },
90 Vector { _handler: WDT },
91 Vector { _handler: RTC1 },
92 Vector { _handler: QDEC },
93 Vector {
94 _handler: COMP_LPCOMP,
95 },
96 Vector {
97 _handler: SWI0_EGU0,
98 },
99 Vector {
100 _handler: SWI1_EGU1,
101 },
102 Vector {
103 _handler: SWI2_EGU2,
104 },
105 Vector {
106 _handler: SWI3_EGU3,
107 },
108 Vector {
109 _handler: SWI4_EGU4,
110 },
111 Vector {
112 _handler: SWI5_EGU5,
113 },
114 Vector { _handler: TIMER3 },
115 Vector { _handler: TIMER4 },
116 Vector { _handler: PWM0 },
117 Vector { _handler: PDM },
118 Vector { _reserved: 0 },
119 Vector { _reserved: 0 },
120 Vector { _handler: MWU },
121 Vector { _handler: PWM1 },
122 Vector { _handler: PWM2 },
123 Vector {
124 _handler: SPIM2_SPIS2_SPI2,
125 },
126 Vector { _handler: RTC2 },
127 Vector { _handler: I2S },
128 Vector { _handler: FPU },
129];
130#[doc = r" Macro to override a device specific interrupt handler"]
131#[doc = r""]
132#[doc = r" # Syntax"]
133#[doc = r""]
134#[doc = r" ``` ignore"]
135#[doc = r" interrupt!("]
136#[doc = r" // Name of the interrupt"]
137#[doc = r" $Name:ident,"]
138#[doc = r""]
139#[doc = r" // Path to the interrupt handler (a function)"]
140#[doc = r" $handler:path,"]
141#[doc = r""]
142#[doc = r" // Optional, state preserved across invocations of the handler"]
143#[doc = r" state: $State:ty = $initial_state:expr,"]
144#[doc = r" );"]
145#[doc = r" ```"]
146#[doc = r""]
147#[doc = r" Where `$Name` must match the name of one of the variants of the `Interrupt`"]
148#[doc = r" enum."]
149#[doc = r""]
150#[doc = r" The handler must have signature `fn()` is no state was associated to it;"]
151#[doc = r" otherwise its signature must be `fn(&mut $State)`."]
152#[cfg(feature = "rt")]
153#[macro_export]
154macro_rules! interrupt {
155 ( $ Name : ident , $ handler : path , state : $ State : ty = $ initial_state : expr ) => {
156 #[allow(unsafe_code)]
157 #[deny(private_no_mangle_fns)]
158 #[no_mangle]
159 pub unsafe extern "C" fn $Name() {
160 static mut STATE: $State = $initial_state;
161 let _ = $crate::Interrupt::$Name;
162 let f: fn(&mut $State) = $handler;
163 f(&mut STATE)
164 }
165 };
166 ( $ Name : ident , $ handler : path ) => {
167 #[allow(unsafe_code)]
168 #[deny(private_no_mangle_fns)]
169 #[no_mangle]
170 pub unsafe extern "C" fn $Name() {
171 let _ = $crate::Interrupt::$Name;
172 let f: fn() = $handler;
173 f()
174 }
175 };
176}
177#[doc = r" Enumeration of all the interrupts"]
178pub enum Interrupt {
179 #[doc = "0 - POWER_CLOCK"]
180 POWER_CLOCK,
181 #[doc = "1 - RADIO"]
182 RADIO,
183 #[doc = "2 - UARTE0_UART0"]
184 UARTE0_UART0,
185 #[doc = "3 - SPIM0_SPIS0_TWIM0_TWIS0_SPI0_TWI0"]
186 SPIM0_SPIS0_TWIM0_TWIS0_SPI0_TWI0,
187 #[doc = "4 - SPIM1_SPIS1_TWIM1_TWIS1_SPI1_TWI1"]
188 SPIM1_SPIS1_TWIM1_TWIS1_SPI1_TWI1,
189 #[doc = "5 - NFCT"]
190 NFCT,
191 #[doc = "6 - GPIOTE"]
192 GPIOTE,
193 #[doc = "7 - SAADC"]
194 SAADC,
195 #[doc = "8 - TIMER0"]
196 TIMER0,
197 #[doc = "9 - TIMER1"]
198 TIMER1,
199 #[doc = "10 - TIMER2"]
200 TIMER2,
201 #[doc = "11 - RTC0"]
202 RTC0,
203 #[doc = "12 - TEMP"]
204 TEMP,
205 #[doc = "13 - RNG"]
206 RNG,
207 #[doc = "14 - ECB"]
208 ECB,
209 #[doc = "15 - CCM_AAR"]
210 CCM_AAR,
211 #[doc = "16 - WDT"]
212 WDT,
213 #[doc = "17 - RTC1"]
214 RTC1,
215 #[doc = "18 - QDEC"]
216 QDEC,
217 #[doc = "19 - COMP_LPCOMP"]
218 COMP_LPCOMP,
219 #[doc = "20 - SWI0_EGU0"]
220 SWI0_EGU0,
221 #[doc = "21 - SWI1_EGU1"]
222 SWI1_EGU1,
223 #[doc = "22 - SWI2_EGU2"]
224 SWI2_EGU2,
225 #[doc = "23 - SWI3_EGU3"]
226 SWI3_EGU3,
227 #[doc = "24 - SWI4_EGU4"]
228 SWI4_EGU4,
229 #[doc = "25 - SWI5_EGU5"]
230 SWI5_EGU5,
231 #[doc = "26 - TIMER3"]
232 TIMER3,
233 #[doc = "27 - TIMER4"]
234 TIMER4,
235 #[doc = "28 - PWM0"]
236 PWM0,
237 #[doc = "29 - PDM"]
238 PDM,
239 #[doc = "32 - MWU"]
240 MWU,
241 #[doc = "33 - PWM1"]
242 PWM1,
243 #[doc = "34 - PWM2"]
244 PWM2,
245 #[doc = "35 - SPIM2_SPIS2_SPI2"]
246 SPIM2_SPIS2_SPI2,
247 #[doc = "36 - RTC2"]
248 RTC2,
249 #[doc = "37 - I2S"]
250 I2S,
251 #[doc = "38 - FPU"]
252 FPU,
253}
254unsafe impl ::bare_metal::Nr for Interrupt {
255 #[inline]
256 fn nr(&self) -> u8 {
257 match *self {
258 Interrupt::POWER_CLOCK => 0,
259 Interrupt::RADIO => 1,
260 Interrupt::UARTE0_UART0 => 2,
261 Interrupt::SPIM0_SPIS0_TWIM0_TWIS0_SPI0_TWI0 => 3,
262 Interrupt::SPIM1_SPIS1_TWIM1_TWIS1_SPI1_TWI1 => 4,
263 Interrupt::NFCT => 5,
264 Interrupt::GPIOTE => 6,
265 Interrupt::SAADC => 7,
266 Interrupt::TIMER0 => 8,
267 Interrupt::TIMER1 => 9,
268 Interrupt::TIMER2 => 10,
269 Interrupt::RTC0 => 11,
270 Interrupt::TEMP => 12,
271 Interrupt::RNG => 13,
272 Interrupt::ECB => 14,
273 Interrupt::CCM_AAR => 15,
274 Interrupt::WDT => 16,
275 Interrupt::RTC1 => 17,
276 Interrupt::QDEC => 18,
277 Interrupt::COMP_LPCOMP => 19,
278 Interrupt::SWI0_EGU0 => 20,
279 Interrupt::SWI1_EGU1 => 21,
280 Interrupt::SWI2_EGU2 => 22,
281 Interrupt::SWI3_EGU3 => 23,
282 Interrupt::SWI4_EGU4 => 24,
283 Interrupt::SWI5_EGU5 => 25,
284 Interrupt::TIMER3 => 26,
285 Interrupt::TIMER4 => 27,
286 Interrupt::PWM0 => 28,
287 Interrupt::PDM => 29,
288 Interrupt::MWU => 32,
289 Interrupt::PWM1 => 33,
290 Interrupt::PWM2 => 34,
291 Interrupt::SPIM2_SPIS2_SPI2 => 35,
292 Interrupt::RTC2 => 36,
293 Interrupt::I2S => 37,
294 Interrupt::FPU => 38,
295 }
296 }
297}
298#[doc(hidden)]
299pub mod interrupt;
300pub use cortex_m::peripheral::Peripherals as CorePeripherals;
301pub use cortex_m::peripheral::{CBP, CPUID, DCB, DWT, FPB, FPU, ITM, MPU, NVIC, SCB, SYST, TPIU};
302#[doc = "Factory Information Configuration Registers"]
303pub struct FICR {
304 _marker: PhantomData<*const ()>,
305}
306unsafe impl Send for FICR {}
307impl FICR {
308 #[doc = r" Returns a pointer to the register block"]
309 pub fn ptr() -> *const ficr::RegisterBlock {
310 268435456 as *const _
311 }
312}
313impl Deref for FICR {
314 type Target = ficr::RegisterBlock;
315 fn deref(&self) -> &ficr::RegisterBlock {
316 unsafe { &*FICR::ptr() }
317 }
318}
319#[doc = "Factory Information Configuration Registers"]
320pub mod ficr;
321#[doc = "User Information Configuration Registers"]
322pub struct UICR {
323 _marker: PhantomData<*const ()>,
324}
325unsafe impl Send for UICR {}
326impl UICR {
327 #[doc = r" Returns a pointer to the register block"]
328 pub fn ptr() -> *const uicr::RegisterBlock {
329 268439552 as *const _
330 }
331}
332impl Deref for UICR {
333 type Target = uicr::RegisterBlock;
334 fn deref(&self) -> &uicr::RegisterBlock {
335 unsafe { &*UICR::ptr() }
336 }
337}
338#[doc = "User Information Configuration Registers"]
339pub mod uicr;
340#[doc = "Block Protect"]
341pub struct BPROT {
342 _marker: PhantomData<*const ()>,
343}
344unsafe impl Send for BPROT {}
345impl BPROT {
346 #[doc = r" Returns a pointer to the register block"]
347 pub fn ptr() -> *const bprot::RegisterBlock {
348 1073741824 as *const _
349 }
350}
351impl Deref for BPROT {
352 type Target = bprot::RegisterBlock;
353 fn deref(&self) -> &bprot::RegisterBlock {
354 unsafe { &*BPROT::ptr() }
355 }
356}
357#[doc = "Block Protect"]
358pub mod bprot;
359#[doc = "Power control"]
360pub struct POWER {
361 _marker: PhantomData<*const ()>,
362}
363unsafe impl Send for POWER {}
364impl POWER {
365 #[doc = r" Returns a pointer to the register block"]
366 pub fn ptr() -> *const power::RegisterBlock {
367 1073741824 as *const _
368 }
369}
370impl Deref for POWER {
371 type Target = power::RegisterBlock;
372 fn deref(&self) -> &power::RegisterBlock {
373 unsafe { &*POWER::ptr() }
374 }
375}
376#[doc = "Power control"]
377pub mod power;
378#[doc = "Clock control"]
379pub struct CLOCK {
380 _marker: PhantomData<*const ()>,
381}
382unsafe impl Send for CLOCK {}
383impl CLOCK {
384 #[doc = r" Returns a pointer to the register block"]
385 pub fn ptr() -> *const clock::RegisterBlock {
386 1073741824 as *const _
387 }
388}
389impl Deref for CLOCK {
390 type Target = clock::RegisterBlock;
391 fn deref(&self) -> &clock::RegisterBlock {
392 unsafe { &*CLOCK::ptr() }
393 }
394}
395#[doc = "Clock control"]
396pub mod clock;
397#[doc = "2.4 GHz Radio"]
398pub struct RADIO {
399 _marker: PhantomData<*const ()>,
400}
401unsafe impl Send for RADIO {}
402impl RADIO {
403 #[doc = r" Returns a pointer to the register block"]
404 pub fn ptr() -> *const radio::RegisterBlock {
405 1073745920 as *const _
406 }
407}
408impl Deref for RADIO {
409 type Target = radio::RegisterBlock;
410 fn deref(&self) -> &radio::RegisterBlock {
411 unsafe { &*RADIO::ptr() }
412 }
413}
414#[doc = "2.4 GHz Radio"]
415pub mod radio;
416#[doc = "UART with EasyDMA"]
417pub struct UARTE0 {
418 _marker: PhantomData<*const ()>,
419}
420unsafe impl Send for UARTE0 {}
421impl UARTE0 {
422 #[doc = r" Returns a pointer to the register block"]
423 pub fn ptr() -> *const uarte0::RegisterBlock {
424 1073750016 as *const _
425 }
426}
427impl Deref for UARTE0 {
428 type Target = uarte0::RegisterBlock;
429 fn deref(&self) -> &uarte0::RegisterBlock {
430 unsafe { &*UARTE0::ptr() }
431 }
432}
433#[doc = "UART with EasyDMA"]
434pub mod uarte0;
435#[doc = "Universal Asynchronous Receiver/Transmitter"]
436pub struct UART0 {
437 _marker: PhantomData<*const ()>,
438}
439unsafe impl Send for UART0 {}
440impl UART0 {
441 #[doc = r" Returns a pointer to the register block"]
442 pub fn ptr() -> *const uart0::RegisterBlock {
443 1073750016 as *const _
444 }
445}
446impl Deref for UART0 {
447 type Target = uart0::RegisterBlock;
448 fn deref(&self) -> &uart0::RegisterBlock {
449 unsafe { &*UART0::ptr() }
450 }
451}
452#[doc = "Universal Asynchronous Receiver/Transmitter"]
453pub mod uart0;
454#[doc = "Serial Peripheral Interface Master with EasyDMA 0"]
455pub struct SPIM0 {
456 _marker: PhantomData<*const ()>,
457}
458unsafe impl Send for SPIM0 {}
459impl SPIM0 {
460 #[doc = r" Returns a pointer to the register block"]
461 pub fn ptr() -> *const spim0::RegisterBlock {
462 1073754112 as *const _
463 }
464}
465impl Deref for SPIM0 {
466 type Target = spim0::RegisterBlock;
467 fn deref(&self) -> &spim0::RegisterBlock {
468 unsafe { &*SPIM0::ptr() }
469 }
470}
471#[doc = "Serial Peripheral Interface Master with EasyDMA 0"]
472pub mod spim0;
473#[doc = "SPI Slave 0"]
474pub struct SPIS0 {
475 _marker: PhantomData<*const ()>,
476}
477unsafe impl Send for SPIS0 {}
478impl SPIS0 {
479 #[doc = r" Returns a pointer to the register block"]
480 pub fn ptr() -> *const spis0::RegisterBlock {
481 1073754112 as *const _
482 }
483}
484impl Deref for SPIS0 {
485 type Target = spis0::RegisterBlock;
486 fn deref(&self) -> &spis0::RegisterBlock {
487 unsafe { &*SPIS0::ptr() }
488 }
489}
490#[doc = "SPI Slave 0"]
491pub mod spis0;
492#[doc = "I2C compatible Two-Wire Master Interface with EasyDMA 0"]
493pub struct TWIM0 {
494 _marker: PhantomData<*const ()>,
495}
496unsafe impl Send for TWIM0 {}
497impl TWIM0 {
498 #[doc = r" Returns a pointer to the register block"]
499 pub fn ptr() -> *const twim0::RegisterBlock {
500 1073754112 as *const _
501 }
502}
503impl Deref for TWIM0 {
504 type Target = twim0::RegisterBlock;
505 fn deref(&self) -> &twim0::RegisterBlock {
506 unsafe { &*TWIM0::ptr() }
507 }
508}
509#[doc = "I2C compatible Two-Wire Master Interface with EasyDMA 0"]
510pub mod twim0;
511#[doc = "I2C compatible Two-Wire Slave Interface with EasyDMA 0"]
512pub struct TWIS0 {
513 _marker: PhantomData<*const ()>,
514}
515unsafe impl Send for TWIS0 {}
516impl TWIS0 {
517 #[doc = r" Returns a pointer to the register block"]
518 pub fn ptr() -> *const twis0::RegisterBlock {
519 1073754112 as *const _
520 }
521}
522impl Deref for TWIS0 {
523 type Target = twis0::RegisterBlock;
524 fn deref(&self) -> &twis0::RegisterBlock {
525 unsafe { &*TWIS0::ptr() }
526 }
527}
528#[doc = "I2C compatible Two-Wire Slave Interface with EasyDMA 0"]
529pub mod twis0;
530#[doc = "Serial Peripheral Interface 0"]
531pub struct SPI0 {
532 _marker: PhantomData<*const ()>,
533}
534unsafe impl Send for SPI0 {}
535impl SPI0 {
536 #[doc = r" Returns a pointer to the register block"]
537 pub fn ptr() -> *const spi0::RegisterBlock {
538 1073754112 as *const _
539 }
540}
541impl Deref for SPI0 {
542 type Target = spi0::RegisterBlock;
543 fn deref(&self) -> &spi0::RegisterBlock {
544 unsafe { &*SPI0::ptr() }
545 }
546}
547#[doc = "Serial Peripheral Interface 0"]
548pub mod spi0;
549#[doc = "I2C compatible Two-Wire Interface 0"]
550pub struct TWI0 {
551 _marker: PhantomData<*const ()>,
552}
553unsafe impl Send for TWI0 {}
554impl TWI0 {
555 #[doc = r" Returns a pointer to the register block"]
556 pub fn ptr() -> *const twi0::RegisterBlock {
557 1073754112 as *const _
558 }
559}
560impl Deref for TWI0 {
561 type Target = twi0::RegisterBlock;
562 fn deref(&self) -> &twi0::RegisterBlock {
563 unsafe { &*TWI0::ptr() }
564 }
565}
566#[doc = "I2C compatible Two-Wire Interface 0"]
567pub mod twi0;
568#[doc = "Serial Peripheral Interface Master with EasyDMA 1"]
569pub struct SPIM1 {
570 _marker: PhantomData<*const ()>,
571}
572unsafe impl Send for SPIM1 {}
573impl SPIM1 {
574 #[doc = r" Returns a pointer to the register block"]
575 pub fn ptr() -> *const spim0::RegisterBlock {
576 1073758208 as *const _
577 }
578}
579impl Deref for SPIM1 {
580 type Target = spim0::RegisterBlock;
581 fn deref(&self) -> &spim0::RegisterBlock {
582 unsafe { &*SPIM1::ptr() }
583 }
584}
585#[doc = "SPI Slave 1"]
586pub struct SPIS1 {
587 _marker: PhantomData<*const ()>,
588}
589unsafe impl Send for SPIS1 {}
590impl SPIS1 {
591 #[doc = r" Returns a pointer to the register block"]
592 pub fn ptr() -> *const spis0::RegisterBlock {
593 1073758208 as *const _
594 }
595}
596impl Deref for SPIS1 {
597 type Target = spis0::RegisterBlock;
598 fn deref(&self) -> &spis0::RegisterBlock {
599 unsafe { &*SPIS1::ptr() }
600 }
601}
602#[doc = "I2C compatible Two-Wire Master Interface with EasyDMA 1"]
603pub struct TWIM1 {
604 _marker: PhantomData<*const ()>,
605}
606unsafe impl Send for TWIM1 {}
607impl TWIM1 {
608 #[doc = r" Returns a pointer to the register block"]
609 pub fn ptr() -> *const twim0::RegisterBlock {
610 1073758208 as *const _
611 }
612}
613impl Deref for TWIM1 {
614 type Target = twim0::RegisterBlock;
615 fn deref(&self) -> &twim0::RegisterBlock {
616 unsafe { &*TWIM1::ptr() }
617 }
618}
619#[doc = "I2C compatible Two-Wire Slave Interface with EasyDMA 1"]
620pub struct TWIS1 {
621 _marker: PhantomData<*const ()>,
622}
623unsafe impl Send for TWIS1 {}
624impl TWIS1 {
625 #[doc = r" Returns a pointer to the register block"]
626 pub fn ptr() -> *const twis0::RegisterBlock {
627 1073758208 as *const _
628 }
629}
630impl Deref for TWIS1 {
631 type Target = twis0::RegisterBlock;
632 fn deref(&self) -> &twis0::RegisterBlock {
633 unsafe { &*TWIS1::ptr() }
634 }
635}
636#[doc = "Serial Peripheral Interface 1"]
637pub struct SPI1 {
638 _marker: PhantomData<*const ()>,
639}
640unsafe impl Send for SPI1 {}
641impl SPI1 {
642 #[doc = r" Returns a pointer to the register block"]
643 pub fn ptr() -> *const spi0::RegisterBlock {
644 1073758208 as *const _
645 }
646}
647impl Deref for SPI1 {
648 type Target = spi0::RegisterBlock;
649 fn deref(&self) -> &spi0::RegisterBlock {
650 unsafe { &*SPI1::ptr() }
651 }
652}
653#[doc = "I2C compatible Two-Wire Interface 1"]
654pub struct TWI1 {
655 _marker: PhantomData<*const ()>,
656}
657unsafe impl Send for TWI1 {}
658impl TWI1 {
659 #[doc = r" Returns a pointer to the register block"]
660 pub fn ptr() -> *const twi0::RegisterBlock {
661 1073758208 as *const _
662 }
663}
664impl Deref for TWI1 {
665 type Target = twi0::RegisterBlock;
666 fn deref(&self) -> &twi0::RegisterBlock {
667 unsafe { &*TWI1::ptr() }
668 }
669}
670#[doc = "NFC-A compatible radio"]
671pub struct NFCT {
672 _marker: PhantomData<*const ()>,
673}
674unsafe impl Send for NFCT {}
675impl NFCT {
676 #[doc = r" Returns a pointer to the register block"]
677 pub fn ptr() -> *const nfct::RegisterBlock {
678 1073762304 as *const _
679 }
680}
681impl Deref for NFCT {
682 type Target = nfct::RegisterBlock;
683 fn deref(&self) -> &nfct::RegisterBlock {
684 unsafe { &*NFCT::ptr() }
685 }
686}
687#[doc = "NFC-A compatible radio"]
688pub mod nfct;
689#[doc = "GPIO Tasks and Events"]
690pub struct GPIOTE {
691 _marker: PhantomData<*const ()>,
692}
693unsafe impl Send for GPIOTE {}
694impl GPIOTE {
695 #[doc = r" Returns a pointer to the register block"]
696 pub fn ptr() -> *const gpiote::RegisterBlock {
697 1073766400 as *const _
698 }
699}
700impl Deref for GPIOTE {
701 type Target = gpiote::RegisterBlock;
702 fn deref(&self) -> &gpiote::RegisterBlock {
703 unsafe { &*GPIOTE::ptr() }
704 }
705}
706#[doc = "GPIO Tasks and Events"]
707pub mod gpiote;
708#[doc = "Analog to Digital Converter"]
709pub struct SAADC {
710 _marker: PhantomData<*const ()>,
711}
712unsafe impl Send for SAADC {}
713impl SAADC {
714 #[doc = r" Returns a pointer to the register block"]
715 pub fn ptr() -> *const saadc::RegisterBlock {
716 1073770496 as *const _
717 }
718}
719impl Deref for SAADC {
720 type Target = saadc::RegisterBlock;
721 fn deref(&self) -> &saadc::RegisterBlock {
722 unsafe { &*SAADC::ptr() }
723 }
724}
725#[doc = "Analog to Digital Converter"]
726pub mod saadc;
727#[doc = "Timer/Counter 0"]
728pub struct TIMER0 {
729 _marker: PhantomData<*const ()>,
730}
731unsafe impl Send for TIMER0 {}
732impl TIMER0 {
733 #[doc = r" Returns a pointer to the register block"]
734 pub fn ptr() -> *const timer0::RegisterBlock {
735 1073774592 as *const _
736 }
737}
738impl Deref for TIMER0 {
739 type Target = timer0::RegisterBlock;
740 fn deref(&self) -> &timer0::RegisterBlock {
741 unsafe { &*TIMER0::ptr() }
742 }
743}
744#[doc = "Timer/Counter 0"]
745pub mod timer0;
746#[doc = "Timer/Counter 1"]
747pub struct TIMER1 {
748 _marker: PhantomData<*const ()>,
749}
750unsafe impl Send for TIMER1 {}
751impl TIMER1 {
752 #[doc = r" Returns a pointer to the register block"]
753 pub fn ptr() -> *const timer0::RegisterBlock {
754 1073778688 as *const _
755 }
756}
757impl Deref for TIMER1 {
758 type Target = timer0::RegisterBlock;
759 fn deref(&self) -> &timer0::RegisterBlock {
760 unsafe { &*TIMER1::ptr() }
761 }
762}
763#[doc = "Timer/Counter 2"]
764pub struct TIMER2 {
765 _marker: PhantomData<*const ()>,
766}
767unsafe impl Send for TIMER2 {}
768impl TIMER2 {
769 #[doc = r" Returns a pointer to the register block"]
770 pub fn ptr() -> *const timer0::RegisterBlock {
771 1073782784 as *const _
772 }
773}
774impl Deref for TIMER2 {
775 type Target = timer0::RegisterBlock;
776 fn deref(&self) -> &timer0::RegisterBlock {
777 unsafe { &*TIMER2::ptr() }
778 }
779}
780#[doc = "Real time counter 0"]
781pub struct RTC0 {
782 _marker: PhantomData<*const ()>,
783}
784unsafe impl Send for RTC0 {}
785impl RTC0 {
786 #[doc = r" Returns a pointer to the register block"]
787 pub fn ptr() -> *const rtc0::RegisterBlock {
788 1073786880 as *const _
789 }
790}
791impl Deref for RTC0 {
792 type Target = rtc0::RegisterBlock;
793 fn deref(&self) -> &rtc0::RegisterBlock {
794 unsafe { &*RTC0::ptr() }
795 }
796}
797#[doc = "Real time counter 0"]
798pub mod rtc0;
799#[doc = "Temperature Sensor"]
800pub struct TEMP {
801 _marker: PhantomData<*const ()>,
802}
803unsafe impl Send for TEMP {}
804impl TEMP {
805 #[doc = r" Returns a pointer to the register block"]
806 pub fn ptr() -> *const temp::RegisterBlock {
807 1073790976 as *const _
808 }
809}
810impl Deref for TEMP {
811 type Target = temp::RegisterBlock;
812 fn deref(&self) -> &temp::RegisterBlock {
813 unsafe { &*TEMP::ptr() }
814 }
815}
816#[doc = "Temperature Sensor"]
817pub mod temp;
818#[doc = "Random Number Generator"]
819pub struct RNG {
820 _marker: PhantomData<*const ()>,
821}
822unsafe impl Send for RNG {}
823impl RNG {
824 #[doc = r" Returns a pointer to the register block"]
825 pub fn ptr() -> *const rng::RegisterBlock {
826 1073795072 as *const _
827 }
828}
829impl Deref for RNG {
830 type Target = rng::RegisterBlock;
831 fn deref(&self) -> &rng::RegisterBlock {
832 unsafe { &*RNG::ptr() }
833 }
834}
835#[doc = "Random Number Generator"]
836pub mod rng;
837#[doc = "AES ECB Mode Encryption"]
838pub struct ECB {
839 _marker: PhantomData<*const ()>,
840}
841unsafe impl Send for ECB {}
842impl ECB {
843 #[doc = r" Returns a pointer to the register block"]
844 pub fn ptr() -> *const ecb::RegisterBlock {
845 1073799168 as *const _
846 }
847}
848impl Deref for ECB {
849 type Target = ecb::RegisterBlock;
850 fn deref(&self) -> &ecb::RegisterBlock {
851 unsafe { &*ECB::ptr() }
852 }
853}
854#[doc = "AES ECB Mode Encryption"]
855pub mod ecb;
856#[doc = "AES CCM Mode Encryption"]
857pub struct CCM {
858 _marker: PhantomData<*const ()>,
859}
860unsafe impl Send for CCM {}
861impl CCM {
862 #[doc = r" Returns a pointer to the register block"]
863 pub fn ptr() -> *const ccm::RegisterBlock {
864 1073803264 as *const _
865 }
866}
867impl Deref for CCM {
868 type Target = ccm::RegisterBlock;
869 fn deref(&self) -> &ccm::RegisterBlock {
870 unsafe { &*CCM::ptr() }
871 }
872}
873#[doc = "AES CCM Mode Encryption"]
874pub mod ccm;
875#[doc = "Accelerated Address Resolver"]
876pub struct AAR {
877 _marker: PhantomData<*const ()>,
878}
879unsafe impl Send for AAR {}
880impl AAR {
881 #[doc = r" Returns a pointer to the register block"]
882 pub fn ptr() -> *const aar::RegisterBlock {
883 1073803264 as *const _
884 }
885}
886impl Deref for AAR {
887 type Target = aar::RegisterBlock;
888 fn deref(&self) -> &aar::RegisterBlock {
889 unsafe { &*AAR::ptr() }
890 }
891}
892#[doc = "Accelerated Address Resolver"]
893pub mod aar;
894#[doc = "Watchdog Timer"]
895pub struct WDT {
896 _marker: PhantomData<*const ()>,
897}
898unsafe impl Send for WDT {}
899impl WDT {
900 #[doc = r" Returns a pointer to the register block"]
901 pub fn ptr() -> *const wdt::RegisterBlock {
902 1073807360 as *const _
903 }
904}
905impl Deref for WDT {
906 type Target = wdt::RegisterBlock;
907 fn deref(&self) -> &wdt::RegisterBlock {
908 unsafe { &*WDT::ptr() }
909 }
910}
911#[doc = "Watchdog Timer"]
912pub mod wdt;
913#[doc = "Real time counter 1"]
914pub struct RTC1 {
915 _marker: PhantomData<*const ()>,
916}
917unsafe impl Send for RTC1 {}
918impl RTC1 {
919 #[doc = r" Returns a pointer to the register block"]
920 pub fn ptr() -> *const rtc0::RegisterBlock {
921 1073811456 as *const _
922 }
923}
924impl Deref for RTC1 {
925 type Target = rtc0::RegisterBlock;
926 fn deref(&self) -> &rtc0::RegisterBlock {
927 unsafe { &*RTC1::ptr() }
928 }
929}
930#[doc = "Quadrature Decoder"]
931pub struct QDEC {
932 _marker: PhantomData<*const ()>,
933}
934unsafe impl Send for QDEC {}
935impl QDEC {
936 #[doc = r" Returns a pointer to the register block"]
937 pub fn ptr() -> *const qdec::RegisterBlock {
938 1073815552 as *const _
939 }
940}
941impl Deref for QDEC {
942 type Target = qdec::RegisterBlock;
943 fn deref(&self) -> &qdec::RegisterBlock {
944 unsafe { &*QDEC::ptr() }
945 }
946}
947#[doc = "Quadrature Decoder"]
948pub mod qdec;
949#[doc = "Comparator"]
950pub struct COMP {
951 _marker: PhantomData<*const ()>,
952}
953unsafe impl Send for COMP {}
954impl COMP {
955 #[doc = r" Returns a pointer to the register block"]
956 pub fn ptr() -> *const comp::RegisterBlock {
957 1073819648 as *const _
958 }
959}
960impl Deref for COMP {
961 type Target = comp::RegisterBlock;
962 fn deref(&self) -> &comp::RegisterBlock {
963 unsafe { &*COMP::ptr() }
964 }
965}
966#[doc = "Comparator"]
967pub mod comp;
968#[doc = "Low Power Comparator"]
969pub struct LPCOMP {
970 _marker: PhantomData<*const ()>,
971}
972unsafe impl Send for LPCOMP {}
973impl LPCOMP {
974 #[doc = r" Returns a pointer to the register block"]
975 pub fn ptr() -> *const lpcomp::RegisterBlock {
976 1073819648 as *const _
977 }
978}
979impl Deref for LPCOMP {
980 type Target = lpcomp::RegisterBlock;
981 fn deref(&self) -> &lpcomp::RegisterBlock {
982 unsafe { &*LPCOMP::ptr() }
983 }
984}
985#[doc = "Low Power Comparator"]
986pub mod lpcomp;
987#[doc = "Software interrupt 0"]
988pub struct SWI0 {
989 _marker: PhantomData<*const ()>,
990}
991unsafe impl Send for SWI0 {}
992impl SWI0 {
993 #[doc = r" Returns a pointer to the register block"]
994 pub fn ptr() -> *const swi0::RegisterBlock {
995 1073823744 as *const _
996 }
997}
998impl Deref for SWI0 {
999 type Target = swi0::RegisterBlock;
1000 fn deref(&self) -> &swi0::RegisterBlock {
1001 unsafe { &*SWI0::ptr() }
1002 }
1003}
1004#[doc = "Software interrupt 0"]
1005pub mod swi0;
1006#[doc = "Event Generator Unit 0"]
1007pub struct EGU0 {
1008 _marker: PhantomData<*const ()>,
1009}
1010unsafe impl Send for EGU0 {}
1011impl EGU0 {
1012 #[doc = r" Returns a pointer to the register block"]
1013 pub fn ptr() -> *const egu0::RegisterBlock {
1014 1073823744 as *const _
1015 }
1016}
1017impl Deref for EGU0 {
1018 type Target = egu0::RegisterBlock;
1019 fn deref(&self) -> &egu0::RegisterBlock {
1020 unsafe { &*EGU0::ptr() }
1021 }
1022}
1023#[doc = "Event Generator Unit 0"]
1024pub mod egu0;
1025#[doc = "Software interrupt 1"]
1026pub struct SWI1 {
1027 _marker: PhantomData<*const ()>,
1028}
1029unsafe impl Send for SWI1 {}
1030impl SWI1 {
1031 #[doc = r" Returns a pointer to the register block"]
1032 pub fn ptr() -> *const swi0::RegisterBlock {
1033 1073827840 as *const _
1034 }
1035}
1036impl Deref for SWI1 {
1037 type Target = swi0::RegisterBlock;
1038 fn deref(&self) -> &swi0::RegisterBlock {
1039 unsafe { &*SWI1::ptr() }
1040 }
1041}
1042#[doc = "Event Generator Unit 1"]
1043pub struct EGU1 {
1044 _marker: PhantomData<*const ()>,
1045}
1046unsafe impl Send for EGU1 {}
1047impl EGU1 {
1048 #[doc = r" Returns a pointer to the register block"]
1049 pub fn ptr() -> *const egu0::RegisterBlock {
1050 1073827840 as *const _
1051 }
1052}
1053impl Deref for EGU1 {
1054 type Target = egu0::RegisterBlock;
1055 fn deref(&self) -> &egu0::RegisterBlock {
1056 unsafe { &*EGU1::ptr() }
1057 }
1058}
1059#[doc = "Software interrupt 2"]
1060pub struct SWI2 {
1061 _marker: PhantomData<*const ()>,
1062}
1063unsafe impl Send for SWI2 {}
1064impl SWI2 {
1065 #[doc = r" Returns a pointer to the register block"]
1066 pub fn ptr() -> *const swi0::RegisterBlock {
1067 1073831936 as *const _
1068 }
1069}
1070impl Deref for SWI2 {
1071 type Target = swi0::RegisterBlock;
1072 fn deref(&self) -> &swi0::RegisterBlock {
1073 unsafe { &*SWI2::ptr() }
1074 }
1075}
1076#[doc = "Event Generator Unit 2"]
1077pub struct EGU2 {
1078 _marker: PhantomData<*const ()>,
1079}
1080unsafe impl Send for EGU2 {}
1081impl EGU2 {
1082 #[doc = r" Returns a pointer to the register block"]
1083 pub fn ptr() -> *const egu0::RegisterBlock {
1084 1073831936 as *const _
1085 }
1086}
1087impl Deref for EGU2 {
1088 type Target = egu0::RegisterBlock;
1089 fn deref(&self) -> &egu0::RegisterBlock {
1090 unsafe { &*EGU2::ptr() }
1091 }
1092}
1093#[doc = "Software interrupt 3"]
1094pub struct SWI3 {
1095 _marker: PhantomData<*const ()>,
1096}
1097unsafe impl Send for SWI3 {}
1098impl SWI3 {
1099 #[doc = r" Returns a pointer to the register block"]
1100 pub fn ptr() -> *const swi0::RegisterBlock {
1101 1073836032 as *const _
1102 }
1103}
1104impl Deref for SWI3 {
1105 type Target = swi0::RegisterBlock;
1106 fn deref(&self) -> &swi0::RegisterBlock {
1107 unsafe { &*SWI3::ptr() }
1108 }
1109}
1110#[doc = "Event Generator Unit 3"]
1111pub struct EGU3 {
1112 _marker: PhantomData<*const ()>,
1113}
1114unsafe impl Send for EGU3 {}
1115impl EGU3 {
1116 #[doc = r" Returns a pointer to the register block"]
1117 pub fn ptr() -> *const egu0::RegisterBlock {
1118 1073836032 as *const _
1119 }
1120}
1121impl Deref for EGU3 {
1122 type Target = egu0::RegisterBlock;
1123 fn deref(&self) -> &egu0::RegisterBlock {
1124 unsafe { &*EGU3::ptr() }
1125 }
1126}
1127#[doc = "Software interrupt 4"]
1128pub struct SWI4 {
1129 _marker: PhantomData<*const ()>,
1130}
1131unsafe impl Send for SWI4 {}
1132impl SWI4 {
1133 #[doc = r" Returns a pointer to the register block"]
1134 pub fn ptr() -> *const swi0::RegisterBlock {
1135 1073840128 as *const _
1136 }
1137}
1138impl Deref for SWI4 {
1139 type Target = swi0::RegisterBlock;
1140 fn deref(&self) -> &swi0::RegisterBlock {
1141 unsafe { &*SWI4::ptr() }
1142 }
1143}
1144#[doc = "Event Generator Unit 4"]
1145pub struct EGU4 {
1146 _marker: PhantomData<*const ()>,
1147}
1148unsafe impl Send for EGU4 {}
1149impl EGU4 {
1150 #[doc = r" Returns a pointer to the register block"]
1151 pub fn ptr() -> *const egu0::RegisterBlock {
1152 1073840128 as *const _
1153 }
1154}
1155impl Deref for EGU4 {
1156 type Target = egu0::RegisterBlock;
1157 fn deref(&self) -> &egu0::RegisterBlock {
1158 unsafe { &*EGU4::ptr() }
1159 }
1160}
1161#[doc = "Software interrupt 5"]
1162pub struct SWI5 {
1163 _marker: PhantomData<*const ()>,
1164}
1165unsafe impl Send for SWI5 {}
1166impl SWI5 {
1167 #[doc = r" Returns a pointer to the register block"]
1168 pub fn ptr() -> *const swi0::RegisterBlock {
1169 1073844224 as *const _
1170 }
1171}
1172impl Deref for SWI5 {
1173 type Target = swi0::RegisterBlock;
1174 fn deref(&self) -> &swi0::RegisterBlock {
1175 unsafe { &*SWI5::ptr() }
1176 }
1177}
1178#[doc = "Event Generator Unit 5"]
1179pub struct EGU5 {
1180 _marker: PhantomData<*const ()>,
1181}
1182unsafe impl Send for EGU5 {}
1183impl EGU5 {
1184 #[doc = r" Returns a pointer to the register block"]
1185 pub fn ptr() -> *const egu0::RegisterBlock {
1186 1073844224 as *const _
1187 }
1188}
1189impl Deref for EGU5 {
1190 type Target = egu0::RegisterBlock;
1191 fn deref(&self) -> &egu0::RegisterBlock {
1192 unsafe { &*EGU5::ptr() }
1193 }
1194}
1195#[doc = "Timer/Counter 3"]
1196pub struct TIMER3 {
1197 _marker: PhantomData<*const ()>,
1198}
1199unsafe impl Send for TIMER3 {}
1200impl TIMER3 {
1201 #[doc = r" Returns a pointer to the register block"]
1202 pub fn ptr() -> *const timer0::RegisterBlock {
1203 1073848320 as *const _
1204 }
1205}
1206impl Deref for TIMER3 {
1207 type Target = timer0::RegisterBlock;
1208 fn deref(&self) -> &timer0::RegisterBlock {
1209 unsafe { &*TIMER3::ptr() }
1210 }
1211}
1212#[doc = "Timer/Counter 4"]
1213pub struct TIMER4 {
1214 _marker: PhantomData<*const ()>,
1215}
1216unsafe impl Send for TIMER4 {}
1217impl TIMER4 {
1218 #[doc = r" Returns a pointer to the register block"]
1219 pub fn ptr() -> *const timer0::RegisterBlock {
1220 1073852416 as *const _
1221 }
1222}
1223impl Deref for TIMER4 {
1224 type Target = timer0::RegisterBlock;
1225 fn deref(&self) -> &timer0::RegisterBlock {
1226 unsafe { &*TIMER4::ptr() }
1227 }
1228}
1229#[doc = "Pulse Width Modulation Unit 0"]
1230pub struct PWM0 {
1231 _marker: PhantomData<*const ()>,
1232}
1233unsafe impl Send for PWM0 {}
1234impl PWM0 {
1235 #[doc = r" Returns a pointer to the register block"]
1236 pub fn ptr() -> *const pwm0::RegisterBlock {
1237 1073856512 as *const _
1238 }
1239}
1240impl Deref for PWM0 {
1241 type Target = pwm0::RegisterBlock;
1242 fn deref(&self) -> &pwm0::RegisterBlock {
1243 unsafe { &*PWM0::ptr() }
1244 }
1245}
1246#[doc = "Pulse Width Modulation Unit 0"]
1247pub mod pwm0;
1248#[doc = "Pulse Density Modulation (Digital Microphone) Interface"]
1249pub struct PDM {
1250 _marker: PhantomData<*const ()>,
1251}
1252unsafe impl Send for PDM {}
1253impl PDM {
1254 #[doc = r" Returns a pointer to the register block"]
1255 pub fn ptr() -> *const pdm::RegisterBlock {
1256 1073860608 as *const _
1257 }
1258}
1259impl Deref for PDM {
1260 type Target = pdm::RegisterBlock;
1261 fn deref(&self) -> &pdm::RegisterBlock {
1262 unsafe { &*PDM::ptr() }
1263 }
1264}
1265#[doc = "Pulse Density Modulation (Digital Microphone) Interface"]
1266pub mod pdm;
1267#[doc = "Non Volatile Memory Controller"]
1268pub struct NVMC {
1269 _marker: PhantomData<*const ()>,
1270}
1271unsafe impl Send for NVMC {}
1272impl NVMC {
1273 #[doc = r" Returns a pointer to the register block"]
1274 pub fn ptr() -> *const nvmc::RegisterBlock {
1275 1073864704 as *const _
1276 }
1277}
1278impl Deref for NVMC {
1279 type Target = nvmc::RegisterBlock;
1280 fn deref(&self) -> &nvmc::RegisterBlock {
1281 unsafe { &*NVMC::ptr() }
1282 }
1283}
1284#[doc = "Non Volatile Memory Controller"]
1285pub mod nvmc;
1286#[doc = "Programmable Peripheral Interconnect"]
1287pub struct PPI {
1288 _marker: PhantomData<*const ()>,
1289}
1290unsafe impl Send for PPI {}
1291impl PPI {
1292 #[doc = r" Returns a pointer to the register block"]
1293 pub fn ptr() -> *const ppi::RegisterBlock {
1294 1073868800 as *const _
1295 }
1296}
1297impl Deref for PPI {
1298 type Target = ppi::RegisterBlock;
1299 fn deref(&self) -> &ppi::RegisterBlock {
1300 unsafe { &*PPI::ptr() }
1301 }
1302}
1303#[doc = "Programmable Peripheral Interconnect"]
1304pub mod ppi;
1305#[doc = "Memory Watch Unit"]
1306pub struct MWU {
1307 _marker: PhantomData<*const ()>,
1308}
1309unsafe impl Send for MWU {}
1310impl MWU {
1311 #[doc = r" Returns a pointer to the register block"]
1312 pub fn ptr() -> *const mwu::RegisterBlock {
1313 1073872896 as *const _
1314 }
1315}
1316impl Deref for MWU {
1317 type Target = mwu::RegisterBlock;
1318 fn deref(&self) -> &mwu::RegisterBlock {
1319 unsafe { &*MWU::ptr() }
1320 }
1321}
1322#[doc = "Memory Watch Unit"]
1323pub mod mwu;
1324#[doc = "Pulse Width Modulation Unit 1"]
1325pub struct PWM1 {
1326 _marker: PhantomData<*const ()>,
1327}
1328unsafe impl Send for PWM1 {}
1329impl PWM1 {
1330 #[doc = r" Returns a pointer to the register block"]
1331 pub fn ptr() -> *const pwm0::RegisterBlock {
1332 1073876992 as *const _
1333 }
1334}
1335impl Deref for PWM1 {
1336 type Target = pwm0::RegisterBlock;
1337 fn deref(&self) -> &pwm0::RegisterBlock {
1338 unsafe { &*PWM1::ptr() }
1339 }
1340}
1341#[doc = "Pulse Width Modulation Unit 2"]
1342pub struct PWM2 {
1343 _marker: PhantomData<*const ()>,
1344}
1345unsafe impl Send for PWM2 {}
1346impl PWM2 {
1347 #[doc = r" Returns a pointer to the register block"]
1348 pub fn ptr() -> *const pwm0::RegisterBlock {
1349 1073881088 as *const _
1350 }
1351}
1352impl Deref for PWM2 {
1353 type Target = pwm0::RegisterBlock;
1354 fn deref(&self) -> &pwm0::RegisterBlock {
1355 unsafe { &*PWM2::ptr() }
1356 }
1357}
1358#[doc = "Serial Peripheral Interface Master with EasyDMA 2"]
1359pub struct SPIM2 {
1360 _marker: PhantomData<*const ()>,
1361}
1362unsafe impl Send for SPIM2 {}
1363impl SPIM2 {
1364 #[doc = r" Returns a pointer to the register block"]
1365 pub fn ptr() -> *const spim0::RegisterBlock {
1366 1073885184 as *const _
1367 }
1368}
1369impl Deref for SPIM2 {
1370 type Target = spim0::RegisterBlock;
1371 fn deref(&self) -> &spim0::RegisterBlock {
1372 unsafe { &*SPIM2::ptr() }
1373 }
1374}
1375#[doc = "SPI Slave 2"]
1376pub struct SPIS2 {
1377 _marker: PhantomData<*const ()>,
1378}
1379unsafe impl Send for SPIS2 {}
1380impl SPIS2 {
1381 #[doc = r" Returns a pointer to the register block"]
1382 pub fn ptr() -> *const spis0::RegisterBlock {
1383 1073885184 as *const _
1384 }
1385}
1386impl Deref for SPIS2 {
1387 type Target = spis0::RegisterBlock;
1388 fn deref(&self) -> &spis0::RegisterBlock {
1389 unsafe { &*SPIS2::ptr() }
1390 }
1391}
1392#[doc = "Serial Peripheral Interface 2"]
1393pub struct SPI2 {
1394 _marker: PhantomData<*const ()>,
1395}
1396unsafe impl Send for SPI2 {}
1397impl SPI2 {
1398 #[doc = r" Returns a pointer to the register block"]
1399 pub fn ptr() -> *const spi0::RegisterBlock {
1400 1073885184 as *const _
1401 }
1402}
1403impl Deref for SPI2 {
1404 type Target = spi0::RegisterBlock;
1405 fn deref(&self) -> &spi0::RegisterBlock {
1406 unsafe { &*SPI2::ptr() }
1407 }
1408}
1409#[doc = "Real time counter 2"]
1410pub struct RTC2 {
1411 _marker: PhantomData<*const ()>,
1412}
1413unsafe impl Send for RTC2 {}
1414impl RTC2 {
1415 #[doc = r" Returns a pointer to the register block"]
1416 pub fn ptr() -> *const rtc0::RegisterBlock {
1417 1073889280 as *const _
1418 }
1419}
1420impl Deref for RTC2 {
1421 type Target = rtc0::RegisterBlock;
1422 fn deref(&self) -> &rtc0::RegisterBlock {
1423 unsafe { &*RTC2::ptr() }
1424 }
1425}
1426#[doc = "Inter-IC Sound"]
1427pub struct I2S {
1428 _marker: PhantomData<*const ()>,
1429}
1430unsafe impl Send for I2S {}
1431impl I2S {
1432 #[doc = r" Returns a pointer to the register block"]
1433 pub fn ptr() -> *const i2s::RegisterBlock {
1434 1073893376 as *const _
1435 }
1436}
1437impl Deref for I2S {
1438 type Target = i2s::RegisterBlock;
1439 fn deref(&self) -> &i2s::RegisterBlock {
1440 unsafe { &*I2S::ptr() }
1441 }
1442}
1443#[doc = "Inter-IC Sound"]
1444pub mod i2s;
1445#[doc = "GPIO Port 1"]
1446pub struct P0 {
1447 _marker: PhantomData<*const ()>,
1448}
1449unsafe impl Send for P0 {}
1450impl P0 {
1451 #[doc = r" Returns a pointer to the register block"]
1452 pub fn ptr() -> *const p0::RegisterBlock {
1453 1342177280 as *const _
1454 }
1455}
1456impl Deref for P0 {
1457 type Target = p0::RegisterBlock;
1458 fn deref(&self) -> &p0::RegisterBlock {
1459 unsafe { &*P0::ptr() }
1460 }
1461}
1462#[doc = "GPIO Port 1"]
1463pub mod p0;
1464#[allow(private_no_mangle_statics)]
1465#[no_mangle]
1466static mut DEVICE_PERIPHERALS: bool = false;
1467#[doc = r" All the peripherals"]
1468#[allow(non_snake_case)]
1469pub struct Peripherals {
1470 #[doc = "FICR"]
1471 pub FICR: FICR,
1472 #[doc = "UICR"]
1473 pub UICR: UICR,
1474 #[doc = "BPROT"]
1475 pub BPROT: BPROT,
1476 #[doc = "POWER"]
1477 pub POWER: POWER,
1478 #[doc = "CLOCK"]
1479 pub CLOCK: CLOCK,
1480 #[doc = "RADIO"]
1481 pub RADIO: RADIO,
1482 #[doc = "UARTE0"]
1483 pub UARTE0: UARTE0,
1484 #[doc = "UART0"]
1485 pub UART0: UART0,
1486 #[doc = "SPIM0"]
1487 pub SPIM0: SPIM0,
1488 #[doc = "SPIS0"]
1489 pub SPIS0: SPIS0,
1490 #[doc = "TWIM0"]
1491 pub TWIM0: TWIM0,
1492 #[doc = "TWIS0"]
1493 pub TWIS0: TWIS0,
1494 #[doc = "SPI0"]
1495 pub SPI0: SPI0,
1496 #[doc = "TWI0"]
1497 pub TWI0: TWI0,
1498 #[doc = "SPIM1"]
1499 pub SPIM1: SPIM1,
1500 #[doc = "SPIS1"]
1501 pub SPIS1: SPIS1,
1502 #[doc = "TWIM1"]
1503 pub TWIM1: TWIM1,
1504 #[doc = "TWIS1"]
1505 pub TWIS1: TWIS1,
1506 #[doc = "SPI1"]
1507 pub SPI1: SPI1,
1508 #[doc = "TWI1"]
1509 pub TWI1: TWI1,
1510 #[doc = "NFCT"]
1511 pub NFCT: NFCT,
1512 #[doc = "GPIOTE"]
1513 pub GPIOTE: GPIOTE,
1514 #[doc = "SAADC"]
1515 pub SAADC: SAADC,
1516 #[doc = "TIMER0"]
1517 pub TIMER0: TIMER0,
1518 #[doc = "TIMER1"]
1519 pub TIMER1: TIMER1,
1520 #[doc = "TIMER2"]
1521 pub TIMER2: TIMER2,
1522 #[doc = "RTC0"]
1523 pub RTC0: RTC0,
1524 #[doc = "TEMP"]
1525 pub TEMP: TEMP,
1526 #[doc = "RNG"]
1527 pub RNG: RNG,
1528 #[doc = "ECB"]
1529 pub ECB: ECB,
1530 #[doc = "CCM"]
1531 pub CCM: CCM,
1532 #[doc = "AAR"]
1533 pub AAR: AAR,
1534 #[doc = "WDT"]
1535 pub WDT: WDT,
1536 #[doc = "RTC1"]
1537 pub RTC1: RTC1,
1538 #[doc = "QDEC"]
1539 pub QDEC: QDEC,
1540 #[doc = "COMP"]
1541 pub COMP: COMP,
1542 #[doc = "LPCOMP"]
1543 pub LPCOMP: LPCOMP,
1544 #[doc = "SWI0"]
1545 pub SWI0: SWI0,
1546 #[doc = "EGU0"]
1547 pub EGU0: EGU0,
1548 #[doc = "SWI1"]
1549 pub SWI1: SWI1,
1550 #[doc = "EGU1"]
1551 pub EGU1: EGU1,
1552 #[doc = "SWI2"]
1553 pub SWI2: SWI2,
1554 #[doc = "EGU2"]
1555 pub EGU2: EGU2,
1556 #[doc = "SWI3"]
1557 pub SWI3: SWI3,
1558 #[doc = "EGU3"]
1559 pub EGU3: EGU3,
1560 #[doc = "SWI4"]
1561 pub SWI4: SWI4,
1562 #[doc = "EGU4"]
1563 pub EGU4: EGU4,
1564 #[doc = "SWI5"]
1565 pub SWI5: SWI5,
1566 #[doc = "EGU5"]
1567 pub EGU5: EGU5,
1568 #[doc = "TIMER3"]
1569 pub TIMER3: TIMER3,
1570 #[doc = "TIMER4"]
1571 pub TIMER4: TIMER4,
1572 #[doc = "PWM0"]
1573 pub PWM0: PWM0,
1574 #[doc = "PDM"]
1575 pub PDM: PDM,
1576 #[doc = "NVMC"]
1577 pub NVMC: NVMC,
1578 #[doc = "PPI"]
1579 pub PPI: PPI,
1580 #[doc = "MWU"]
1581 pub MWU: MWU,
1582 #[doc = "PWM1"]
1583 pub PWM1: PWM1,
1584 #[doc = "PWM2"]
1585 pub PWM2: PWM2,
1586 #[doc = "SPIM2"]
1587 pub SPIM2: SPIM2,
1588 #[doc = "SPIS2"]
1589 pub SPIS2: SPIS2,
1590 #[doc = "SPI2"]
1591 pub SPI2: SPI2,
1592 #[doc = "RTC2"]
1593 pub RTC2: RTC2,
1594 #[doc = "I2S"]
1595 pub I2S: I2S,
1596 #[doc = "P0"]
1597 pub P0: P0,
1598}
1599impl Peripherals {
1600 #[doc = r" Returns all the peripherals *once*"]
1601 #[inline]
1602 pub fn take() -> Option<Self> {
1603 cortex_m::interrupt::free(|_| {
1604 if unsafe { DEVICE_PERIPHERALS } {
1605 None
1606 } else {
1607 Some(unsafe { Peripherals::steal() })
1608 }
1609 })
1610 }
1611 #[doc = r" Unchecked version of `Peripherals::take`"]
1612 pub unsafe fn steal() -> Self {
1613 debug_assert!(!DEVICE_PERIPHERALS);
1614 DEVICE_PERIPHERALS = true;
1615 Peripherals {
1616 FICR: FICR {
1617 _marker: PhantomData,
1618 },
1619 UICR: UICR {
1620 _marker: PhantomData,
1621 },
1622 BPROT: BPROT {
1623 _marker: PhantomData,
1624 },
1625 POWER: POWER {
1626 _marker: PhantomData,
1627 },
1628 CLOCK: CLOCK {
1629 _marker: PhantomData,
1630 },
1631 RADIO: RADIO {
1632 _marker: PhantomData,
1633 },
1634 UARTE0: UARTE0 {
1635 _marker: PhantomData,
1636 },
1637 UART0: UART0 {
1638 _marker: PhantomData,
1639 },
1640 SPIM0: SPIM0 {
1641 _marker: PhantomData,
1642 },
1643 SPIS0: SPIS0 {
1644 _marker: PhantomData,
1645 },
1646 TWIM0: TWIM0 {
1647 _marker: PhantomData,
1648 },
1649 TWIS0: TWIS0 {
1650 _marker: PhantomData,
1651 },
1652 SPI0: SPI0 {
1653 _marker: PhantomData,
1654 },
1655 TWI0: TWI0 {
1656 _marker: PhantomData,
1657 },
1658 SPIM1: SPIM1 {
1659 _marker: PhantomData,
1660 },
1661 SPIS1: SPIS1 {
1662 _marker: PhantomData,
1663 },
1664 TWIM1: TWIM1 {
1665 _marker: PhantomData,
1666 },
1667 TWIS1: TWIS1 {
1668 _marker: PhantomData,
1669 },
1670 SPI1: SPI1 {
1671 _marker: PhantomData,
1672 },
1673 TWI1: TWI1 {
1674 _marker: PhantomData,
1675 },
1676 NFCT: NFCT {
1677 _marker: PhantomData,
1678 },
1679 GPIOTE: GPIOTE {
1680 _marker: PhantomData,
1681 },
1682 SAADC: SAADC {
1683 _marker: PhantomData,
1684 },
1685 TIMER0: TIMER0 {
1686 _marker: PhantomData,
1687 },
1688 TIMER1: TIMER1 {
1689 _marker: PhantomData,
1690 },
1691 TIMER2: TIMER2 {
1692 _marker: PhantomData,
1693 },
1694 RTC0: RTC0 {
1695 _marker: PhantomData,
1696 },
1697 TEMP: TEMP {
1698 _marker: PhantomData,
1699 },
1700 RNG: RNG {
1701 _marker: PhantomData,
1702 },
1703 ECB: ECB {
1704 _marker: PhantomData,
1705 },
1706 CCM: CCM {
1707 _marker: PhantomData,
1708 },
1709 AAR: AAR {
1710 _marker: PhantomData,
1711 },
1712 WDT: WDT {
1713 _marker: PhantomData,
1714 },
1715 RTC1: RTC1 {
1716 _marker: PhantomData,
1717 },
1718 QDEC: QDEC {
1719 _marker: PhantomData,
1720 },
1721 COMP: COMP {
1722 _marker: PhantomData,
1723 },
1724 LPCOMP: LPCOMP {
1725 _marker: PhantomData,
1726 },
1727 SWI0: SWI0 {
1728 _marker: PhantomData,
1729 },
1730 EGU0: EGU0 {
1731 _marker: PhantomData,
1732 },
1733 SWI1: SWI1 {
1734 _marker: PhantomData,
1735 },
1736 EGU1: EGU1 {
1737 _marker: PhantomData,
1738 },
1739 SWI2: SWI2 {
1740 _marker: PhantomData,
1741 },
1742 EGU2: EGU2 {
1743 _marker: PhantomData,
1744 },
1745 SWI3: SWI3 {
1746 _marker: PhantomData,
1747 },
1748 EGU3: EGU3 {
1749 _marker: PhantomData,
1750 },
1751 SWI4: SWI4 {
1752 _marker: PhantomData,
1753 },
1754 EGU4: EGU4 {
1755 _marker: PhantomData,
1756 },
1757 SWI5: SWI5 {
1758 _marker: PhantomData,
1759 },
1760 EGU5: EGU5 {
1761 _marker: PhantomData,
1762 },
1763 TIMER3: TIMER3 {
1764 _marker: PhantomData,
1765 },
1766 TIMER4: TIMER4 {
1767 _marker: PhantomData,
1768 },
1769 PWM0: PWM0 {
1770 _marker: PhantomData,
1771 },
1772 PDM: PDM {
1773 _marker: PhantomData,
1774 },
1775 NVMC: NVMC {
1776 _marker: PhantomData,
1777 },
1778 PPI: PPI {
1779 _marker: PhantomData,
1780 },
1781 MWU: MWU {
1782 _marker: PhantomData,
1783 },
1784 PWM1: PWM1 {
1785 _marker: PhantomData,
1786 },
1787 PWM2: PWM2 {
1788 _marker: PhantomData,
1789 },
1790 SPIM2: SPIM2 {
1791 _marker: PhantomData,
1792 },
1793 SPIS2: SPIS2 {
1794 _marker: PhantomData,
1795 },
1796 SPI2: SPI2 {
1797 _marker: PhantomData,
1798 },
1799 RTC2: RTC2 {
1800 _marker: PhantomData,
1801 },
1802 I2S: I2S {
1803 _marker: PhantomData,
1804 },
1805 P0: P0 {
1806 _marker: PhantomData,
1807 },
1808 }
1809 }
1810}