1#![doc = "Peripheral access API for NRF52 microcontrollers (generated using svd2rust v0.25.1 ( ))\n\nYou can find an overview of the generated API [here].\n\nAPI features to be included in the [next]
2svd2rust release can be generated by cloning the svd2rust [repository], checking out the above commit, and running `cargo doc --open`.\n\n[here]: https://docs.rs/svd2rust/0.25.1/svd2rust/#peripheral-api\n[next]: https://github.com/rust-embedded/svd2rust/blob/master/CHANGELOG.md#unreleased\n[repository]: https://github.com/rust-embedded/svd2rust"]
3#![deny(const_err)]
4#![deny(dead_code)]
5#![deny(improper_ctypes)]
6#![deny(missing_docs)]
7#![deny(no_mangle_generic_items)]
8#![deny(non_shorthand_field_patterns)]
9#![deny(overflowing_literals)]
10#![deny(path_statements)]
11#![deny(patterns_in_fns_without_body)]
12#![deny(private_in_public)]
13#![deny(unconditional_recursion)]
14#![deny(unused_allocation)]
15#![deny(unused_comparisons)]
16#![deny(unused_parens)]
17#![deny(while_true)]
18#![allow(non_camel_case_types)]
19#![allow(non_snake_case)]
20#![no_std]
21use core::marker::PhantomData;
22use core::ops::Deref;
23#[doc = r"Number available in the NVIC for configuring priority"]
24pub const NVIC_PRIO_BITS: u8 = 3;
25#[cfg(feature = "rt")]
26pub use self::Interrupt as interrupt;
27pub use cortex_m::peripheral::Peripherals as CorePeripherals;
28pub use cortex_m::peripheral::{CBP, CPUID, DCB, DWT, FPB, FPU, ITM, MPU, NVIC, SCB, SYST, TPIU};
29#[cfg(feature = "rt")]
30pub use cortex_m_rt::interrupt;
31#[allow(unused_imports)]
32use generic::*;
33#[doc = r"Common register and bit access and modify traits"]
34pub mod generic;
35#[cfg(feature = "rt")]
36extern "C" {
37 fn POWER_CLOCK();
38 fn RADIO();
39 fn UARTE0_UART0();
40 fn SPIM0_SPIS0_TWIM0_TWIS0_SPI0_TWI0();
41 fn SPIM1_SPIS1_TWIM1_TWIS1_SPI1_TWI1();
42 fn NFCT();
43 fn GPIOTE();
44 fn SAADC();
45 fn TIMER0();
46 fn TIMER1();
47 fn TIMER2();
48 fn RTC0();
49 fn TEMP();
50 fn RNG();
51 fn ECB();
52 fn CCM_AAR();
53 fn WDT();
54 fn RTC1();
55 fn QDEC();
56 fn COMP_LPCOMP();
57 fn SWI0_EGU0();
58 fn SWI1_EGU1();
59 fn SWI2_EGU2();
60 fn SWI3_EGU3();
61 fn SWI4_EGU4();
62 fn SWI5_EGU5();
63 fn TIMER3();
64 fn TIMER4();
65 fn PWM0();
66 fn PDM();
67 fn MWU();
68 fn PWM1();
69 fn PWM2();
70 fn SPIM2_SPIS2_SPI2();
71 fn RTC2();
72 fn I2S();
73 fn FPU();
74}
75#[doc(hidden)]
76pub union Vector {
77 _handler: unsafe extern "C" fn(),
78 _reserved: u32,
79}
80#[cfg(feature = "rt")]
81#[doc(hidden)]
82#[link_section = ".vector_table.interrupts"]
83#[no_mangle]
84pub static __INTERRUPTS: [Vector; 39] = [
85 Vector {
86 _handler: POWER_CLOCK,
87 },
88 Vector { _handler: RADIO },
89 Vector {
90 _handler: UARTE0_UART0,
91 },
92 Vector {
93 _handler: SPIM0_SPIS0_TWIM0_TWIS0_SPI0_TWI0,
94 },
95 Vector {
96 _handler: SPIM1_SPIS1_TWIM1_TWIS1_SPI1_TWI1,
97 },
98 Vector { _handler: NFCT },
99 Vector { _handler: GPIOTE },
100 Vector { _handler: SAADC },
101 Vector { _handler: TIMER0 },
102 Vector { _handler: TIMER1 },
103 Vector { _handler: TIMER2 },
104 Vector { _handler: RTC0 },
105 Vector { _handler: TEMP },
106 Vector { _handler: RNG },
107 Vector { _handler: ECB },
108 Vector { _handler: CCM_AAR },
109 Vector { _handler: WDT },
110 Vector { _handler: RTC1 },
111 Vector { _handler: QDEC },
112 Vector {
113 _handler: COMP_LPCOMP,
114 },
115 Vector {
116 _handler: SWI0_EGU0,
117 },
118 Vector {
119 _handler: SWI1_EGU1,
120 },
121 Vector {
122 _handler: SWI2_EGU2,
123 },
124 Vector {
125 _handler: SWI3_EGU3,
126 },
127 Vector {
128 _handler: SWI4_EGU4,
129 },
130 Vector {
131 _handler: SWI5_EGU5,
132 },
133 Vector { _handler: TIMER3 },
134 Vector { _handler: TIMER4 },
135 Vector { _handler: PWM0 },
136 Vector { _handler: PDM },
137 Vector { _reserved: 0 },
138 Vector { _reserved: 0 },
139 Vector { _handler: MWU },
140 Vector { _handler: PWM1 },
141 Vector { _handler: PWM2 },
142 Vector {
143 _handler: SPIM2_SPIS2_SPI2,
144 },
145 Vector { _handler: RTC2 },
146 Vector { _handler: I2S },
147 Vector { _handler: FPU },
148];
149#[doc = r"Enumeration of all the interrupts."]
150#[derive(Copy, Clone, Debug, PartialEq, Eq)]
151#[repr(u16)]
152pub enum Interrupt {
153 #[doc = "0 - POWER_CLOCK"]
154 POWER_CLOCK = 0,
155 #[doc = "1 - RADIO"]
156 RADIO = 1,
157 #[doc = "2 - UARTE0_UART0"]
158 UARTE0_UART0 = 2,
159 #[doc = "3 - SPIM0_SPIS0_TWIM0_TWIS0_SPI0_TWI0"]
160 SPIM0_SPIS0_TWIM0_TWIS0_SPI0_TWI0 = 3,
161 #[doc = "4 - SPIM1_SPIS1_TWIM1_TWIS1_SPI1_TWI1"]
162 SPIM1_SPIS1_TWIM1_TWIS1_SPI1_TWI1 = 4,
163 #[doc = "5 - NFCT"]
164 NFCT = 5,
165 #[doc = "6 - GPIOTE"]
166 GPIOTE = 6,
167 #[doc = "7 - SAADC"]
168 SAADC = 7,
169 #[doc = "8 - TIMER0"]
170 TIMER0 = 8,
171 #[doc = "9 - TIMER1"]
172 TIMER1 = 9,
173 #[doc = "10 - TIMER2"]
174 TIMER2 = 10,
175 #[doc = "11 - RTC0"]
176 RTC0 = 11,
177 #[doc = "12 - TEMP"]
178 TEMP = 12,
179 #[doc = "13 - RNG"]
180 RNG = 13,
181 #[doc = "14 - ECB"]
182 ECB = 14,
183 #[doc = "15 - CCM_AAR"]
184 CCM_AAR = 15,
185 #[doc = "16 - WDT"]
186 WDT = 16,
187 #[doc = "17 - RTC1"]
188 RTC1 = 17,
189 #[doc = "18 - QDEC"]
190 QDEC = 18,
191 #[doc = "19 - COMP_LPCOMP"]
192 COMP_LPCOMP = 19,
193 #[doc = "20 - SWI0_EGU0"]
194 SWI0_EGU0 = 20,
195 #[doc = "21 - SWI1_EGU1"]
196 SWI1_EGU1 = 21,
197 #[doc = "22 - SWI2_EGU2"]
198 SWI2_EGU2 = 22,
199 #[doc = "23 - SWI3_EGU3"]
200 SWI3_EGU3 = 23,
201 #[doc = "24 - SWI4_EGU4"]
202 SWI4_EGU4 = 24,
203 #[doc = "25 - SWI5_EGU5"]
204 SWI5_EGU5 = 25,
205 #[doc = "26 - TIMER3"]
206 TIMER3 = 26,
207 #[doc = "27 - TIMER4"]
208 TIMER4 = 27,
209 #[doc = "28 - PWM0"]
210 PWM0 = 28,
211 #[doc = "29 - PDM"]
212 PDM = 29,
213 #[doc = "32 - MWU"]
214 MWU = 32,
215 #[doc = "33 - PWM1"]
216 PWM1 = 33,
217 #[doc = "34 - PWM2"]
218 PWM2 = 34,
219 #[doc = "35 - SPIM2_SPIS2_SPI2"]
220 SPIM2_SPIS2_SPI2 = 35,
221 #[doc = "36 - RTC2"]
222 RTC2 = 36,
223 #[doc = "37 - I2S"]
224 I2S = 37,
225 #[doc = "38 - FPU"]
226 FPU = 38,
227}
228unsafe impl cortex_m::interrupt::InterruptNumber for Interrupt {
229 #[inline(always)]
230 fn number(self) -> u16 {
231 self as u16
232 }
233}
234#[doc = "Factory Information Configuration Registers"]
235pub struct FICR {
236 _marker: PhantomData<*const ()>,
237}
238unsafe impl Send for FICR {}
239impl FICR {
240 #[doc = r"Pointer to the register block"]
241 pub const PTR: *const ficr::RegisterBlock = 0x1000_0000 as *const _;
242 #[doc = r"Return the pointer to the register block"]
243 #[inline(always)]
244 pub const fn ptr() -> *const ficr::RegisterBlock {
245 Self::PTR
246 }
247}
248impl Deref for FICR {
249 type Target = ficr::RegisterBlock;
250 #[inline(always)]
251 fn deref(&self) -> &Self::Target {
252 unsafe { &*Self::PTR }
253 }
254}
255impl core::fmt::Debug for FICR {
256 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
257 f.debug_struct("FICR").finish()
258 }
259}
260#[doc = "Factory Information Configuration Registers"]
261pub mod ficr;
262#[doc = "User Information Configuration Registers"]
263pub struct UICR {
264 _marker: PhantomData<*const ()>,
265}
266unsafe impl Send for UICR {}
267impl UICR {
268 #[doc = r"Pointer to the register block"]
269 pub const PTR: *const uicr::RegisterBlock = 0x1000_1000 as *const _;
270 #[doc = r"Return the pointer to the register block"]
271 #[inline(always)]
272 pub const fn ptr() -> *const uicr::RegisterBlock {
273 Self::PTR
274 }
275}
276impl Deref for UICR {
277 type Target = uicr::RegisterBlock;
278 #[inline(always)]
279 fn deref(&self) -> &Self::Target {
280 unsafe { &*Self::PTR }
281 }
282}
283impl core::fmt::Debug for UICR {
284 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
285 f.debug_struct("UICR").finish()
286 }
287}
288#[doc = "User Information Configuration Registers"]
289pub mod uicr;
290#[doc = "Block Protect"]
291pub struct BPROT {
292 _marker: PhantomData<*const ()>,
293}
294unsafe impl Send for BPROT {}
295impl BPROT {
296 #[doc = r"Pointer to the register block"]
297 pub const PTR: *const bprot::RegisterBlock = 0x4000_0000 as *const _;
298 #[doc = r"Return the pointer to the register block"]
299 #[inline(always)]
300 pub const fn ptr() -> *const bprot::RegisterBlock {
301 Self::PTR
302 }
303}
304impl Deref for BPROT {
305 type Target = bprot::RegisterBlock;
306 #[inline(always)]
307 fn deref(&self) -> &Self::Target {
308 unsafe { &*Self::PTR }
309 }
310}
311impl core::fmt::Debug for BPROT {
312 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
313 f.debug_struct("BPROT").finish()
314 }
315}
316#[doc = "Block Protect"]
317pub mod bprot;
318#[doc = "Power control"]
319pub struct POWER {
320 _marker: PhantomData<*const ()>,
321}
322unsafe impl Send for POWER {}
323impl POWER {
324 #[doc = r"Pointer to the register block"]
325 pub const PTR: *const power::RegisterBlock = 0x4000_0000 as *const _;
326 #[doc = r"Return the pointer to the register block"]
327 #[inline(always)]
328 pub const fn ptr() -> *const power::RegisterBlock {
329 Self::PTR
330 }
331}
332impl Deref for POWER {
333 type Target = power::RegisterBlock;
334 #[inline(always)]
335 fn deref(&self) -> &Self::Target {
336 unsafe { &*Self::PTR }
337 }
338}
339impl core::fmt::Debug for POWER {
340 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
341 f.debug_struct("POWER").finish()
342 }
343}
344#[doc = "Power control"]
345pub mod power;
346#[doc = "Clock control"]
347pub struct CLOCK {
348 _marker: PhantomData<*const ()>,
349}
350unsafe impl Send for CLOCK {}
351impl CLOCK {
352 #[doc = r"Pointer to the register block"]
353 pub const PTR: *const clock::RegisterBlock = 0x4000_0000 as *const _;
354 #[doc = r"Return the pointer to the register block"]
355 #[inline(always)]
356 pub const fn ptr() -> *const clock::RegisterBlock {
357 Self::PTR
358 }
359}
360impl Deref for CLOCK {
361 type Target = clock::RegisterBlock;
362 #[inline(always)]
363 fn deref(&self) -> &Self::Target {
364 unsafe { &*Self::PTR }
365 }
366}
367impl core::fmt::Debug for CLOCK {
368 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
369 f.debug_struct("CLOCK").finish()
370 }
371}
372#[doc = "Clock control"]
373pub mod clock;
374#[doc = "2.4 GHz Radio"]
375pub struct RADIO {
376 _marker: PhantomData<*const ()>,
377}
378unsafe impl Send for RADIO {}
379impl RADIO {
380 #[doc = r"Pointer to the register block"]
381 pub const PTR: *const radio::RegisterBlock = 0x4000_1000 as *const _;
382 #[doc = r"Return the pointer to the register block"]
383 #[inline(always)]
384 pub const fn ptr() -> *const radio::RegisterBlock {
385 Self::PTR
386 }
387}
388impl Deref for RADIO {
389 type Target = radio::RegisterBlock;
390 #[inline(always)]
391 fn deref(&self) -> &Self::Target {
392 unsafe { &*Self::PTR }
393 }
394}
395impl core::fmt::Debug for RADIO {
396 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
397 f.debug_struct("RADIO").finish()
398 }
399}
400#[doc = "2.4 GHz Radio"]
401pub mod radio;
402#[doc = "UART with EasyDMA"]
403pub struct UARTE0 {
404 _marker: PhantomData<*const ()>,
405}
406unsafe impl Send for UARTE0 {}
407impl UARTE0 {
408 #[doc = r"Pointer to the register block"]
409 pub const PTR: *const uarte0::RegisterBlock = 0x4000_2000 as *const _;
410 #[doc = r"Return the pointer to the register block"]
411 #[inline(always)]
412 pub const fn ptr() -> *const uarte0::RegisterBlock {
413 Self::PTR
414 }
415}
416impl Deref for UARTE0 {
417 type Target = uarte0::RegisterBlock;
418 #[inline(always)]
419 fn deref(&self) -> &Self::Target {
420 unsafe { &*Self::PTR }
421 }
422}
423impl core::fmt::Debug for UARTE0 {
424 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
425 f.debug_struct("UARTE0").finish()
426 }
427}
428#[doc = "UART with EasyDMA"]
429pub mod uarte0;
430#[doc = "Universal Asynchronous Receiver/Transmitter"]
431pub struct UART0 {
432 _marker: PhantomData<*const ()>,
433}
434unsafe impl Send for UART0 {}
435impl UART0 {
436 #[doc = r"Pointer to the register block"]
437 pub const PTR: *const uart0::RegisterBlock = 0x4000_2000 as *const _;
438 #[doc = r"Return the pointer to the register block"]
439 #[inline(always)]
440 pub const fn ptr() -> *const uart0::RegisterBlock {
441 Self::PTR
442 }
443}
444impl Deref for UART0 {
445 type Target = uart0::RegisterBlock;
446 #[inline(always)]
447 fn deref(&self) -> &Self::Target {
448 unsafe { &*Self::PTR }
449 }
450}
451impl core::fmt::Debug for UART0 {
452 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
453 f.debug_struct("UART0").finish()
454 }
455}
456#[doc = "Universal Asynchronous Receiver/Transmitter"]
457pub mod uart0;
458#[doc = "Serial Peripheral Interface Master with EasyDMA 0"]
459pub struct SPIM0 {
460 _marker: PhantomData<*const ()>,
461}
462unsafe impl Send for SPIM0 {}
463impl SPIM0 {
464 #[doc = r"Pointer to the register block"]
465 pub const PTR: *const spim0::RegisterBlock = 0x4000_3000 as *const _;
466 #[doc = r"Return the pointer to the register block"]
467 #[inline(always)]
468 pub const fn ptr() -> *const spim0::RegisterBlock {
469 Self::PTR
470 }
471}
472impl Deref for SPIM0 {
473 type Target = spim0::RegisterBlock;
474 #[inline(always)]
475 fn deref(&self) -> &Self::Target {
476 unsafe { &*Self::PTR }
477 }
478}
479impl core::fmt::Debug for SPIM0 {
480 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
481 f.debug_struct("SPIM0").finish()
482 }
483}
484#[doc = "Serial Peripheral Interface Master with EasyDMA 0"]
485pub mod spim0;
486#[doc = "SPI Slave 0"]
487pub struct SPIS0 {
488 _marker: PhantomData<*const ()>,
489}
490unsafe impl Send for SPIS0 {}
491impl SPIS0 {
492 #[doc = r"Pointer to the register block"]
493 pub const PTR: *const spis0::RegisterBlock = 0x4000_3000 as *const _;
494 #[doc = r"Return the pointer to the register block"]
495 #[inline(always)]
496 pub const fn ptr() -> *const spis0::RegisterBlock {
497 Self::PTR
498 }
499}
500impl Deref for SPIS0 {
501 type Target = spis0::RegisterBlock;
502 #[inline(always)]
503 fn deref(&self) -> &Self::Target {
504 unsafe { &*Self::PTR }
505 }
506}
507impl core::fmt::Debug for SPIS0 {
508 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
509 f.debug_struct("SPIS0").finish()
510 }
511}
512#[doc = "SPI Slave 0"]
513pub mod spis0;
514#[doc = "I2C compatible Two-Wire Master Interface with EasyDMA 0"]
515pub struct TWIM0 {
516 _marker: PhantomData<*const ()>,
517}
518unsafe impl Send for TWIM0 {}
519impl TWIM0 {
520 #[doc = r"Pointer to the register block"]
521 pub const PTR: *const twim0::RegisterBlock = 0x4000_3000 as *const _;
522 #[doc = r"Return the pointer to the register block"]
523 #[inline(always)]
524 pub const fn ptr() -> *const twim0::RegisterBlock {
525 Self::PTR
526 }
527}
528impl Deref for TWIM0 {
529 type Target = twim0::RegisterBlock;
530 #[inline(always)]
531 fn deref(&self) -> &Self::Target {
532 unsafe { &*Self::PTR }
533 }
534}
535impl core::fmt::Debug for TWIM0 {
536 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
537 f.debug_struct("TWIM0").finish()
538 }
539}
540#[doc = "I2C compatible Two-Wire Master Interface with EasyDMA 0"]
541pub mod twim0;
542#[doc = "I2C compatible Two-Wire Slave Interface with EasyDMA 0"]
543pub struct TWIS0 {
544 _marker: PhantomData<*const ()>,
545}
546unsafe impl Send for TWIS0 {}
547impl TWIS0 {
548 #[doc = r"Pointer to the register block"]
549 pub const PTR: *const twis0::RegisterBlock = 0x4000_3000 as *const _;
550 #[doc = r"Return the pointer to the register block"]
551 #[inline(always)]
552 pub const fn ptr() -> *const twis0::RegisterBlock {
553 Self::PTR
554 }
555}
556impl Deref for TWIS0 {
557 type Target = twis0::RegisterBlock;
558 #[inline(always)]
559 fn deref(&self) -> &Self::Target {
560 unsafe { &*Self::PTR }
561 }
562}
563impl core::fmt::Debug for TWIS0 {
564 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
565 f.debug_struct("TWIS0").finish()
566 }
567}
568#[doc = "I2C compatible Two-Wire Slave Interface with EasyDMA 0"]
569pub mod twis0;
570#[doc = "Serial Peripheral Interface 0"]
571pub struct SPI0 {
572 _marker: PhantomData<*const ()>,
573}
574unsafe impl Send for SPI0 {}
575impl SPI0 {
576 #[doc = r"Pointer to the register block"]
577 pub const PTR: *const spi0::RegisterBlock = 0x4000_3000 as *const _;
578 #[doc = r"Return the pointer to the register block"]
579 #[inline(always)]
580 pub const fn ptr() -> *const spi0::RegisterBlock {
581 Self::PTR
582 }
583}
584impl Deref for SPI0 {
585 type Target = spi0::RegisterBlock;
586 #[inline(always)]
587 fn deref(&self) -> &Self::Target {
588 unsafe { &*Self::PTR }
589 }
590}
591impl core::fmt::Debug for SPI0 {
592 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
593 f.debug_struct("SPI0").finish()
594 }
595}
596#[doc = "Serial Peripheral Interface 0"]
597pub mod spi0;
598#[doc = "I2C compatible Two-Wire Interface 0"]
599pub struct TWI0 {
600 _marker: PhantomData<*const ()>,
601}
602unsafe impl Send for TWI0 {}
603impl TWI0 {
604 #[doc = r"Pointer to the register block"]
605 pub const PTR: *const twi0::RegisterBlock = 0x4000_3000 as *const _;
606 #[doc = r"Return the pointer to the register block"]
607 #[inline(always)]
608 pub const fn ptr() -> *const twi0::RegisterBlock {
609 Self::PTR
610 }
611}
612impl Deref for TWI0 {
613 type Target = twi0::RegisterBlock;
614 #[inline(always)]
615 fn deref(&self) -> &Self::Target {
616 unsafe { &*Self::PTR }
617 }
618}
619impl core::fmt::Debug for TWI0 {
620 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
621 f.debug_struct("TWI0").finish()
622 }
623}
624#[doc = "I2C compatible Two-Wire Interface 0"]
625pub mod twi0;
626#[doc = "Serial Peripheral Interface Master with EasyDMA 1"]
627pub struct SPIM1 {
628 _marker: PhantomData<*const ()>,
629}
630unsafe impl Send for SPIM1 {}
631impl SPIM1 {
632 #[doc = r"Pointer to the register block"]
633 pub const PTR: *const spim0::RegisterBlock = 0x4000_4000 as *const _;
634 #[doc = r"Return the pointer to the register block"]
635 #[inline(always)]
636 pub const fn ptr() -> *const spim0::RegisterBlock {
637 Self::PTR
638 }
639}
640impl Deref for SPIM1 {
641 type Target = spim0::RegisterBlock;
642 #[inline(always)]
643 fn deref(&self) -> &Self::Target {
644 unsafe { &*Self::PTR }
645 }
646}
647impl core::fmt::Debug for SPIM1 {
648 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
649 f.debug_struct("SPIM1").finish()
650 }
651}
652#[doc = "Serial Peripheral Interface Master with EasyDMA 1"]
653pub use spim0 as spim1;
654#[doc = "SPI Slave 1"]
655pub struct SPIS1 {
656 _marker: PhantomData<*const ()>,
657}
658unsafe impl Send for SPIS1 {}
659impl SPIS1 {
660 #[doc = r"Pointer to the register block"]
661 pub const PTR: *const spis0::RegisterBlock = 0x4000_4000 as *const _;
662 #[doc = r"Return the pointer to the register block"]
663 #[inline(always)]
664 pub const fn ptr() -> *const spis0::RegisterBlock {
665 Self::PTR
666 }
667}
668impl Deref for SPIS1 {
669 type Target = spis0::RegisterBlock;
670 #[inline(always)]
671 fn deref(&self) -> &Self::Target {
672 unsafe { &*Self::PTR }
673 }
674}
675impl core::fmt::Debug for SPIS1 {
676 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
677 f.debug_struct("SPIS1").finish()
678 }
679}
680#[doc = "SPI Slave 1"]
681pub use spis0 as spis1;
682#[doc = "I2C compatible Two-Wire Master Interface with EasyDMA 1"]
683pub struct TWIM1 {
684 _marker: PhantomData<*const ()>,
685}
686unsafe impl Send for TWIM1 {}
687impl TWIM1 {
688 #[doc = r"Pointer to the register block"]
689 pub const PTR: *const twim0::RegisterBlock = 0x4000_4000 as *const _;
690 #[doc = r"Return the pointer to the register block"]
691 #[inline(always)]
692 pub const fn ptr() -> *const twim0::RegisterBlock {
693 Self::PTR
694 }
695}
696impl Deref for TWIM1 {
697 type Target = twim0::RegisterBlock;
698 #[inline(always)]
699 fn deref(&self) -> &Self::Target {
700 unsafe { &*Self::PTR }
701 }
702}
703impl core::fmt::Debug for TWIM1 {
704 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
705 f.debug_struct("TWIM1").finish()
706 }
707}
708#[doc = "I2C compatible Two-Wire Master Interface with EasyDMA 1"]
709pub use twim0 as twim1;
710#[doc = "I2C compatible Two-Wire Slave Interface with EasyDMA 1"]
711pub struct TWIS1 {
712 _marker: PhantomData<*const ()>,
713}
714unsafe impl Send for TWIS1 {}
715impl TWIS1 {
716 #[doc = r"Pointer to the register block"]
717 pub const PTR: *const twis0::RegisterBlock = 0x4000_4000 as *const _;
718 #[doc = r"Return the pointer to the register block"]
719 #[inline(always)]
720 pub const fn ptr() -> *const twis0::RegisterBlock {
721 Self::PTR
722 }
723}
724impl Deref for TWIS1 {
725 type Target = twis0::RegisterBlock;
726 #[inline(always)]
727 fn deref(&self) -> &Self::Target {
728 unsafe { &*Self::PTR }
729 }
730}
731impl core::fmt::Debug for TWIS1 {
732 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
733 f.debug_struct("TWIS1").finish()
734 }
735}
736#[doc = "I2C compatible Two-Wire Slave Interface with EasyDMA 1"]
737pub use twis0 as twis1;
738#[doc = "Serial Peripheral Interface 1"]
739pub struct SPI1 {
740 _marker: PhantomData<*const ()>,
741}
742unsafe impl Send for SPI1 {}
743impl SPI1 {
744 #[doc = r"Pointer to the register block"]
745 pub const PTR: *const spi0::RegisterBlock = 0x4000_4000 as *const _;
746 #[doc = r"Return the pointer to the register block"]
747 #[inline(always)]
748 pub const fn ptr() -> *const spi0::RegisterBlock {
749 Self::PTR
750 }
751}
752impl Deref for SPI1 {
753 type Target = spi0::RegisterBlock;
754 #[inline(always)]
755 fn deref(&self) -> &Self::Target {
756 unsafe { &*Self::PTR }
757 }
758}
759impl core::fmt::Debug for SPI1 {
760 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
761 f.debug_struct("SPI1").finish()
762 }
763}
764#[doc = "Serial Peripheral Interface 1"]
765pub use spi0 as spi1;
766#[doc = "I2C compatible Two-Wire Interface 1"]
767pub struct TWI1 {
768 _marker: PhantomData<*const ()>,
769}
770unsafe impl Send for TWI1 {}
771impl TWI1 {
772 #[doc = r"Pointer to the register block"]
773 pub const PTR: *const twi0::RegisterBlock = 0x4000_4000 as *const _;
774 #[doc = r"Return the pointer to the register block"]
775 #[inline(always)]
776 pub const fn ptr() -> *const twi0::RegisterBlock {
777 Self::PTR
778 }
779}
780impl Deref for TWI1 {
781 type Target = twi0::RegisterBlock;
782 #[inline(always)]
783 fn deref(&self) -> &Self::Target {
784 unsafe { &*Self::PTR }
785 }
786}
787impl core::fmt::Debug for TWI1 {
788 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
789 f.debug_struct("TWI1").finish()
790 }
791}
792#[doc = "I2C compatible Two-Wire Interface 1"]
793pub use twi0 as twi1;
794#[doc = "NFC-A compatible radio"]
795pub struct NFCT {
796 _marker: PhantomData<*const ()>,
797}
798unsafe impl Send for NFCT {}
799impl NFCT {
800 #[doc = r"Pointer to the register block"]
801 pub const PTR: *const nfct::RegisterBlock = 0x4000_5000 as *const _;
802 #[doc = r"Return the pointer to the register block"]
803 #[inline(always)]
804 pub const fn ptr() -> *const nfct::RegisterBlock {
805 Self::PTR
806 }
807}
808impl Deref for NFCT {
809 type Target = nfct::RegisterBlock;
810 #[inline(always)]
811 fn deref(&self) -> &Self::Target {
812 unsafe { &*Self::PTR }
813 }
814}
815impl core::fmt::Debug for NFCT {
816 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
817 f.debug_struct("NFCT").finish()
818 }
819}
820#[doc = "NFC-A compatible radio"]
821pub mod nfct;
822#[doc = "GPIO Tasks and Events"]
823pub struct GPIOTE {
824 _marker: PhantomData<*const ()>,
825}
826unsafe impl Send for GPIOTE {}
827impl GPIOTE {
828 #[doc = r"Pointer to the register block"]
829 pub const PTR: *const gpiote::RegisterBlock = 0x4000_6000 as *const _;
830 #[doc = r"Return the pointer to the register block"]
831 #[inline(always)]
832 pub const fn ptr() -> *const gpiote::RegisterBlock {
833 Self::PTR
834 }
835}
836impl Deref for GPIOTE {
837 type Target = gpiote::RegisterBlock;
838 #[inline(always)]
839 fn deref(&self) -> &Self::Target {
840 unsafe { &*Self::PTR }
841 }
842}
843impl core::fmt::Debug for GPIOTE {
844 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
845 f.debug_struct("GPIOTE").finish()
846 }
847}
848#[doc = "GPIO Tasks and Events"]
849pub mod gpiote;
850#[doc = "Analog to Digital Converter"]
851pub struct SAADC {
852 _marker: PhantomData<*const ()>,
853}
854unsafe impl Send for SAADC {}
855impl SAADC {
856 #[doc = r"Pointer to the register block"]
857 pub const PTR: *const saadc::RegisterBlock = 0x4000_7000 as *const _;
858 #[doc = r"Return the pointer to the register block"]
859 #[inline(always)]
860 pub const fn ptr() -> *const saadc::RegisterBlock {
861 Self::PTR
862 }
863}
864impl Deref for SAADC {
865 type Target = saadc::RegisterBlock;
866 #[inline(always)]
867 fn deref(&self) -> &Self::Target {
868 unsafe { &*Self::PTR }
869 }
870}
871impl core::fmt::Debug for SAADC {
872 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
873 f.debug_struct("SAADC").finish()
874 }
875}
876#[doc = "Analog to Digital Converter"]
877pub mod saadc;
878#[doc = "Timer/Counter 0"]
879pub struct TIMER0 {
880 _marker: PhantomData<*const ()>,
881}
882unsafe impl Send for TIMER0 {}
883impl TIMER0 {
884 #[doc = r"Pointer to the register block"]
885 pub const PTR: *const timer0::RegisterBlock = 0x4000_8000 as *const _;
886 #[doc = r"Return the pointer to the register block"]
887 #[inline(always)]
888 pub const fn ptr() -> *const timer0::RegisterBlock {
889 Self::PTR
890 }
891}
892impl Deref for TIMER0 {
893 type Target = timer0::RegisterBlock;
894 #[inline(always)]
895 fn deref(&self) -> &Self::Target {
896 unsafe { &*Self::PTR }
897 }
898}
899impl core::fmt::Debug for TIMER0 {
900 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
901 f.debug_struct("TIMER0").finish()
902 }
903}
904#[doc = "Timer/Counter 0"]
905pub mod timer0;
906#[doc = "Timer/Counter 1"]
907pub struct TIMER1 {
908 _marker: PhantomData<*const ()>,
909}
910unsafe impl Send for TIMER1 {}
911impl TIMER1 {
912 #[doc = r"Pointer to the register block"]
913 pub const PTR: *const timer0::RegisterBlock = 0x4000_9000 as *const _;
914 #[doc = r"Return the pointer to the register block"]
915 #[inline(always)]
916 pub const fn ptr() -> *const timer0::RegisterBlock {
917 Self::PTR
918 }
919}
920impl Deref for TIMER1 {
921 type Target = timer0::RegisterBlock;
922 #[inline(always)]
923 fn deref(&self) -> &Self::Target {
924 unsafe { &*Self::PTR }
925 }
926}
927impl core::fmt::Debug for TIMER1 {
928 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
929 f.debug_struct("TIMER1").finish()
930 }
931}
932#[doc = "Timer/Counter 1"]
933pub use timer0 as timer1;
934#[doc = "Timer/Counter 2"]
935pub struct TIMER2 {
936 _marker: PhantomData<*const ()>,
937}
938unsafe impl Send for TIMER2 {}
939impl TIMER2 {
940 #[doc = r"Pointer to the register block"]
941 pub const PTR: *const timer0::RegisterBlock = 0x4000_a000 as *const _;
942 #[doc = r"Return the pointer to the register block"]
943 #[inline(always)]
944 pub const fn ptr() -> *const timer0::RegisterBlock {
945 Self::PTR
946 }
947}
948impl Deref for TIMER2 {
949 type Target = timer0::RegisterBlock;
950 #[inline(always)]
951 fn deref(&self) -> &Self::Target {
952 unsafe { &*Self::PTR }
953 }
954}
955impl core::fmt::Debug for TIMER2 {
956 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
957 f.debug_struct("TIMER2").finish()
958 }
959}
960#[doc = "Timer/Counter 2"]
961pub use timer0 as timer2;
962#[doc = "Real time counter 0"]
963pub struct RTC0 {
964 _marker: PhantomData<*const ()>,
965}
966unsafe impl Send for RTC0 {}
967impl RTC0 {
968 #[doc = r"Pointer to the register block"]
969 pub const PTR: *const rtc0::RegisterBlock = 0x4000_b000 as *const _;
970 #[doc = r"Return the pointer to the register block"]
971 #[inline(always)]
972 pub const fn ptr() -> *const rtc0::RegisterBlock {
973 Self::PTR
974 }
975}
976impl Deref for RTC0 {
977 type Target = rtc0::RegisterBlock;
978 #[inline(always)]
979 fn deref(&self) -> &Self::Target {
980 unsafe { &*Self::PTR }
981 }
982}
983impl core::fmt::Debug for RTC0 {
984 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
985 f.debug_struct("RTC0").finish()
986 }
987}
988#[doc = "Real time counter 0"]
989pub mod rtc0;
990#[doc = "Temperature Sensor"]
991pub struct TEMP {
992 _marker: PhantomData<*const ()>,
993}
994unsafe impl Send for TEMP {}
995impl TEMP {
996 #[doc = r"Pointer to the register block"]
997 pub const PTR: *const temp::RegisterBlock = 0x4000_c000 as *const _;
998 #[doc = r"Return the pointer to the register block"]
999 #[inline(always)]
1000 pub const fn ptr() -> *const temp::RegisterBlock {
1001 Self::PTR
1002 }
1003}
1004impl Deref for TEMP {
1005 type Target = temp::RegisterBlock;
1006 #[inline(always)]
1007 fn deref(&self) -> &Self::Target {
1008 unsafe { &*Self::PTR }
1009 }
1010}
1011impl core::fmt::Debug for TEMP {
1012 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1013 f.debug_struct("TEMP").finish()
1014 }
1015}
1016#[doc = "Temperature Sensor"]
1017pub mod temp;
1018#[doc = "Random Number Generator"]
1019pub struct RNG {
1020 _marker: PhantomData<*const ()>,
1021}
1022unsafe impl Send for RNG {}
1023impl RNG {
1024 #[doc = r"Pointer to the register block"]
1025 pub const PTR: *const rng::RegisterBlock = 0x4000_d000 as *const _;
1026 #[doc = r"Return the pointer to the register block"]
1027 #[inline(always)]
1028 pub const fn ptr() -> *const rng::RegisterBlock {
1029 Self::PTR
1030 }
1031}
1032impl Deref for RNG {
1033 type Target = rng::RegisterBlock;
1034 #[inline(always)]
1035 fn deref(&self) -> &Self::Target {
1036 unsafe { &*Self::PTR }
1037 }
1038}
1039impl core::fmt::Debug for RNG {
1040 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1041 f.debug_struct("RNG").finish()
1042 }
1043}
1044#[doc = "Random Number Generator"]
1045pub mod rng;
1046#[doc = "AES ECB Mode Encryption"]
1047pub struct ECB {
1048 _marker: PhantomData<*const ()>,
1049}
1050unsafe impl Send for ECB {}
1051impl ECB {
1052 #[doc = r"Pointer to the register block"]
1053 pub const PTR: *const ecb::RegisterBlock = 0x4000_e000 as *const _;
1054 #[doc = r"Return the pointer to the register block"]
1055 #[inline(always)]
1056 pub const fn ptr() -> *const ecb::RegisterBlock {
1057 Self::PTR
1058 }
1059}
1060impl Deref for ECB {
1061 type Target = ecb::RegisterBlock;
1062 #[inline(always)]
1063 fn deref(&self) -> &Self::Target {
1064 unsafe { &*Self::PTR }
1065 }
1066}
1067impl core::fmt::Debug for ECB {
1068 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1069 f.debug_struct("ECB").finish()
1070 }
1071}
1072#[doc = "AES ECB Mode Encryption"]
1073pub mod ecb;
1074#[doc = "AES CCM Mode Encryption"]
1075pub struct CCM {
1076 _marker: PhantomData<*const ()>,
1077}
1078unsafe impl Send for CCM {}
1079impl CCM {
1080 #[doc = r"Pointer to the register block"]
1081 pub const PTR: *const ccm::RegisterBlock = 0x4000_f000 as *const _;
1082 #[doc = r"Return the pointer to the register block"]
1083 #[inline(always)]
1084 pub const fn ptr() -> *const ccm::RegisterBlock {
1085 Self::PTR
1086 }
1087}
1088impl Deref for CCM {
1089 type Target = ccm::RegisterBlock;
1090 #[inline(always)]
1091 fn deref(&self) -> &Self::Target {
1092 unsafe { &*Self::PTR }
1093 }
1094}
1095impl core::fmt::Debug for CCM {
1096 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1097 f.debug_struct("CCM").finish()
1098 }
1099}
1100#[doc = "AES CCM Mode Encryption"]
1101pub mod ccm;
1102#[doc = "Accelerated Address Resolver"]
1103pub struct AAR {
1104 _marker: PhantomData<*const ()>,
1105}
1106unsafe impl Send for AAR {}
1107impl AAR {
1108 #[doc = r"Pointer to the register block"]
1109 pub const PTR: *const aar::RegisterBlock = 0x4000_f000 as *const _;
1110 #[doc = r"Return the pointer to the register block"]
1111 #[inline(always)]
1112 pub const fn ptr() -> *const aar::RegisterBlock {
1113 Self::PTR
1114 }
1115}
1116impl Deref for AAR {
1117 type Target = aar::RegisterBlock;
1118 #[inline(always)]
1119 fn deref(&self) -> &Self::Target {
1120 unsafe { &*Self::PTR }
1121 }
1122}
1123impl core::fmt::Debug for AAR {
1124 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1125 f.debug_struct("AAR").finish()
1126 }
1127}
1128#[doc = "Accelerated Address Resolver"]
1129pub mod aar;
1130#[doc = "Watchdog Timer"]
1131pub struct WDT {
1132 _marker: PhantomData<*const ()>,
1133}
1134unsafe impl Send for WDT {}
1135impl WDT {
1136 #[doc = r"Pointer to the register block"]
1137 pub const PTR: *const wdt::RegisterBlock = 0x4001_0000 as *const _;
1138 #[doc = r"Return the pointer to the register block"]
1139 #[inline(always)]
1140 pub const fn ptr() -> *const wdt::RegisterBlock {
1141 Self::PTR
1142 }
1143}
1144impl Deref for WDT {
1145 type Target = wdt::RegisterBlock;
1146 #[inline(always)]
1147 fn deref(&self) -> &Self::Target {
1148 unsafe { &*Self::PTR }
1149 }
1150}
1151impl core::fmt::Debug for WDT {
1152 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1153 f.debug_struct("WDT").finish()
1154 }
1155}
1156#[doc = "Watchdog Timer"]
1157pub mod wdt;
1158#[doc = "Real time counter 1"]
1159pub struct RTC1 {
1160 _marker: PhantomData<*const ()>,
1161}
1162unsafe impl Send for RTC1 {}
1163impl RTC1 {
1164 #[doc = r"Pointer to the register block"]
1165 pub const PTR: *const rtc0::RegisterBlock = 0x4001_1000 as *const _;
1166 #[doc = r"Return the pointer to the register block"]
1167 #[inline(always)]
1168 pub const fn ptr() -> *const rtc0::RegisterBlock {
1169 Self::PTR
1170 }
1171}
1172impl Deref for RTC1 {
1173 type Target = rtc0::RegisterBlock;
1174 #[inline(always)]
1175 fn deref(&self) -> &Self::Target {
1176 unsafe { &*Self::PTR }
1177 }
1178}
1179impl core::fmt::Debug for RTC1 {
1180 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1181 f.debug_struct("RTC1").finish()
1182 }
1183}
1184#[doc = "Real time counter 1"]
1185pub use rtc0 as rtc1;
1186#[doc = "Quadrature Decoder"]
1187pub struct QDEC {
1188 _marker: PhantomData<*const ()>,
1189}
1190unsafe impl Send for QDEC {}
1191impl QDEC {
1192 #[doc = r"Pointer to the register block"]
1193 pub const PTR: *const qdec::RegisterBlock = 0x4001_2000 as *const _;
1194 #[doc = r"Return the pointer to the register block"]
1195 #[inline(always)]
1196 pub const fn ptr() -> *const qdec::RegisterBlock {
1197 Self::PTR
1198 }
1199}
1200impl Deref for QDEC {
1201 type Target = qdec::RegisterBlock;
1202 #[inline(always)]
1203 fn deref(&self) -> &Self::Target {
1204 unsafe { &*Self::PTR }
1205 }
1206}
1207impl core::fmt::Debug for QDEC {
1208 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1209 f.debug_struct("QDEC").finish()
1210 }
1211}
1212#[doc = "Quadrature Decoder"]
1213pub mod qdec;
1214#[doc = "Comparator"]
1215pub struct COMP {
1216 _marker: PhantomData<*const ()>,
1217}
1218unsafe impl Send for COMP {}
1219impl COMP {
1220 #[doc = r"Pointer to the register block"]
1221 pub const PTR: *const comp::RegisterBlock = 0x4001_3000 as *const _;
1222 #[doc = r"Return the pointer to the register block"]
1223 #[inline(always)]
1224 pub const fn ptr() -> *const comp::RegisterBlock {
1225 Self::PTR
1226 }
1227}
1228impl Deref for COMP {
1229 type Target = comp::RegisterBlock;
1230 #[inline(always)]
1231 fn deref(&self) -> &Self::Target {
1232 unsafe { &*Self::PTR }
1233 }
1234}
1235impl core::fmt::Debug for COMP {
1236 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1237 f.debug_struct("COMP").finish()
1238 }
1239}
1240#[doc = "Comparator"]
1241pub mod comp;
1242#[doc = "Low Power Comparator"]
1243pub struct LPCOMP {
1244 _marker: PhantomData<*const ()>,
1245}
1246unsafe impl Send for LPCOMP {}
1247impl LPCOMP {
1248 #[doc = r"Pointer to the register block"]
1249 pub const PTR: *const lpcomp::RegisterBlock = 0x4001_3000 as *const _;
1250 #[doc = r"Return the pointer to the register block"]
1251 #[inline(always)]
1252 pub const fn ptr() -> *const lpcomp::RegisterBlock {
1253 Self::PTR
1254 }
1255}
1256impl Deref for LPCOMP {
1257 type Target = lpcomp::RegisterBlock;
1258 #[inline(always)]
1259 fn deref(&self) -> &Self::Target {
1260 unsafe { &*Self::PTR }
1261 }
1262}
1263impl core::fmt::Debug for LPCOMP {
1264 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1265 f.debug_struct("LPCOMP").finish()
1266 }
1267}
1268#[doc = "Low Power Comparator"]
1269pub mod lpcomp;
1270#[doc = "Software interrupt 0"]
1271pub struct SWI0 {
1272 _marker: PhantomData<*const ()>,
1273}
1274unsafe impl Send for SWI0 {}
1275impl SWI0 {
1276 #[doc = r"Pointer to the register block"]
1277 pub const PTR: *const swi0::RegisterBlock = 0x4001_4000 as *const _;
1278 #[doc = r"Return the pointer to the register block"]
1279 #[inline(always)]
1280 pub const fn ptr() -> *const swi0::RegisterBlock {
1281 Self::PTR
1282 }
1283}
1284impl Deref for SWI0 {
1285 type Target = swi0::RegisterBlock;
1286 #[inline(always)]
1287 fn deref(&self) -> &Self::Target {
1288 unsafe { &*Self::PTR }
1289 }
1290}
1291impl core::fmt::Debug for SWI0 {
1292 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1293 f.debug_struct("SWI0").finish()
1294 }
1295}
1296#[doc = "Software interrupt 0"]
1297pub mod swi0;
1298#[doc = "Event Generator Unit 0"]
1299pub struct EGU0 {
1300 _marker: PhantomData<*const ()>,
1301}
1302unsafe impl Send for EGU0 {}
1303impl EGU0 {
1304 #[doc = r"Pointer to the register block"]
1305 pub const PTR: *const egu0::RegisterBlock = 0x4001_4000 as *const _;
1306 #[doc = r"Return the pointer to the register block"]
1307 #[inline(always)]
1308 pub const fn ptr() -> *const egu0::RegisterBlock {
1309 Self::PTR
1310 }
1311}
1312impl Deref for EGU0 {
1313 type Target = egu0::RegisterBlock;
1314 #[inline(always)]
1315 fn deref(&self) -> &Self::Target {
1316 unsafe { &*Self::PTR }
1317 }
1318}
1319impl core::fmt::Debug for EGU0 {
1320 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1321 f.debug_struct("EGU0").finish()
1322 }
1323}
1324#[doc = "Event Generator Unit 0"]
1325pub mod egu0;
1326#[doc = "Software interrupt 1"]
1327pub struct SWI1 {
1328 _marker: PhantomData<*const ()>,
1329}
1330unsafe impl Send for SWI1 {}
1331impl SWI1 {
1332 #[doc = r"Pointer to the register block"]
1333 pub const PTR: *const swi0::RegisterBlock = 0x4001_5000 as *const _;
1334 #[doc = r"Return the pointer to the register block"]
1335 #[inline(always)]
1336 pub const fn ptr() -> *const swi0::RegisterBlock {
1337 Self::PTR
1338 }
1339}
1340impl Deref for SWI1 {
1341 type Target = swi0::RegisterBlock;
1342 #[inline(always)]
1343 fn deref(&self) -> &Self::Target {
1344 unsafe { &*Self::PTR }
1345 }
1346}
1347impl core::fmt::Debug for SWI1 {
1348 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1349 f.debug_struct("SWI1").finish()
1350 }
1351}
1352#[doc = "Software interrupt 1"]
1353pub use swi0 as swi1;
1354#[doc = "Event Generator Unit 1"]
1355pub struct EGU1 {
1356 _marker: PhantomData<*const ()>,
1357}
1358unsafe impl Send for EGU1 {}
1359impl EGU1 {
1360 #[doc = r"Pointer to the register block"]
1361 pub const PTR: *const egu0::RegisterBlock = 0x4001_5000 as *const _;
1362 #[doc = r"Return the pointer to the register block"]
1363 #[inline(always)]
1364 pub const fn ptr() -> *const egu0::RegisterBlock {
1365 Self::PTR
1366 }
1367}
1368impl Deref for EGU1 {
1369 type Target = egu0::RegisterBlock;
1370 #[inline(always)]
1371 fn deref(&self) -> &Self::Target {
1372 unsafe { &*Self::PTR }
1373 }
1374}
1375impl core::fmt::Debug for EGU1 {
1376 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1377 f.debug_struct("EGU1").finish()
1378 }
1379}
1380#[doc = "Event Generator Unit 1"]
1381pub use egu0 as egu1;
1382#[doc = "Software interrupt 2"]
1383pub struct SWI2 {
1384 _marker: PhantomData<*const ()>,
1385}
1386unsafe impl Send for SWI2 {}
1387impl SWI2 {
1388 #[doc = r"Pointer to the register block"]
1389 pub const PTR: *const swi0::RegisterBlock = 0x4001_6000 as *const _;
1390 #[doc = r"Return the pointer to the register block"]
1391 #[inline(always)]
1392 pub const fn ptr() -> *const swi0::RegisterBlock {
1393 Self::PTR
1394 }
1395}
1396impl Deref for SWI2 {
1397 type Target = swi0::RegisterBlock;
1398 #[inline(always)]
1399 fn deref(&self) -> &Self::Target {
1400 unsafe { &*Self::PTR }
1401 }
1402}
1403impl core::fmt::Debug for SWI2 {
1404 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1405 f.debug_struct("SWI2").finish()
1406 }
1407}
1408#[doc = "Software interrupt 2"]
1409pub use swi0 as swi2;
1410#[doc = "Event Generator Unit 2"]
1411pub struct EGU2 {
1412 _marker: PhantomData<*const ()>,
1413}
1414unsafe impl Send for EGU2 {}
1415impl EGU2 {
1416 #[doc = r"Pointer to the register block"]
1417 pub const PTR: *const egu0::RegisterBlock = 0x4001_6000 as *const _;
1418 #[doc = r"Return the pointer to the register block"]
1419 #[inline(always)]
1420 pub const fn ptr() -> *const egu0::RegisterBlock {
1421 Self::PTR
1422 }
1423}
1424impl Deref for EGU2 {
1425 type Target = egu0::RegisterBlock;
1426 #[inline(always)]
1427 fn deref(&self) -> &Self::Target {
1428 unsafe { &*Self::PTR }
1429 }
1430}
1431impl core::fmt::Debug for EGU2 {
1432 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1433 f.debug_struct("EGU2").finish()
1434 }
1435}
1436#[doc = "Event Generator Unit 2"]
1437pub use egu0 as egu2;
1438#[doc = "Software interrupt 3"]
1439pub struct SWI3 {
1440 _marker: PhantomData<*const ()>,
1441}
1442unsafe impl Send for SWI3 {}
1443impl SWI3 {
1444 #[doc = r"Pointer to the register block"]
1445 pub const PTR: *const swi0::RegisterBlock = 0x4001_7000 as *const _;
1446 #[doc = r"Return the pointer to the register block"]
1447 #[inline(always)]
1448 pub const fn ptr() -> *const swi0::RegisterBlock {
1449 Self::PTR
1450 }
1451}
1452impl Deref for SWI3 {
1453 type Target = swi0::RegisterBlock;
1454 #[inline(always)]
1455 fn deref(&self) -> &Self::Target {
1456 unsafe { &*Self::PTR }
1457 }
1458}
1459impl core::fmt::Debug for SWI3 {
1460 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1461 f.debug_struct("SWI3").finish()
1462 }
1463}
1464#[doc = "Software interrupt 3"]
1465pub use swi0 as swi3;
1466#[doc = "Event Generator Unit 3"]
1467pub struct EGU3 {
1468 _marker: PhantomData<*const ()>,
1469}
1470unsafe impl Send for EGU3 {}
1471impl EGU3 {
1472 #[doc = r"Pointer to the register block"]
1473 pub const PTR: *const egu0::RegisterBlock = 0x4001_7000 as *const _;
1474 #[doc = r"Return the pointer to the register block"]
1475 #[inline(always)]
1476 pub const fn ptr() -> *const egu0::RegisterBlock {
1477 Self::PTR
1478 }
1479}
1480impl Deref for EGU3 {
1481 type Target = egu0::RegisterBlock;
1482 #[inline(always)]
1483 fn deref(&self) -> &Self::Target {
1484 unsafe { &*Self::PTR }
1485 }
1486}
1487impl core::fmt::Debug for EGU3 {
1488 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1489 f.debug_struct("EGU3").finish()
1490 }
1491}
1492#[doc = "Event Generator Unit 3"]
1493pub use egu0 as egu3;
1494#[doc = "Software interrupt 4"]
1495pub struct SWI4 {
1496 _marker: PhantomData<*const ()>,
1497}
1498unsafe impl Send for SWI4 {}
1499impl SWI4 {
1500 #[doc = r"Pointer to the register block"]
1501 pub const PTR: *const swi0::RegisterBlock = 0x4001_8000 as *const _;
1502 #[doc = r"Return the pointer to the register block"]
1503 #[inline(always)]
1504 pub const fn ptr() -> *const swi0::RegisterBlock {
1505 Self::PTR
1506 }
1507}
1508impl Deref for SWI4 {
1509 type Target = swi0::RegisterBlock;
1510 #[inline(always)]
1511 fn deref(&self) -> &Self::Target {
1512 unsafe { &*Self::PTR }
1513 }
1514}
1515impl core::fmt::Debug for SWI4 {
1516 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1517 f.debug_struct("SWI4").finish()
1518 }
1519}
1520#[doc = "Software interrupt 4"]
1521pub use swi0 as swi4;
1522#[doc = "Event Generator Unit 4"]
1523pub struct EGU4 {
1524 _marker: PhantomData<*const ()>,
1525}
1526unsafe impl Send for EGU4 {}
1527impl EGU4 {
1528 #[doc = r"Pointer to the register block"]
1529 pub const PTR: *const egu0::RegisterBlock = 0x4001_8000 as *const _;
1530 #[doc = r"Return the pointer to the register block"]
1531 #[inline(always)]
1532 pub const fn ptr() -> *const egu0::RegisterBlock {
1533 Self::PTR
1534 }
1535}
1536impl Deref for EGU4 {
1537 type Target = egu0::RegisterBlock;
1538 #[inline(always)]
1539 fn deref(&self) -> &Self::Target {
1540 unsafe { &*Self::PTR }
1541 }
1542}
1543impl core::fmt::Debug for EGU4 {
1544 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1545 f.debug_struct("EGU4").finish()
1546 }
1547}
1548#[doc = "Event Generator Unit 4"]
1549pub use egu0 as egu4;
1550#[doc = "Software interrupt 5"]
1551pub struct SWI5 {
1552 _marker: PhantomData<*const ()>,
1553}
1554unsafe impl Send for SWI5 {}
1555impl SWI5 {
1556 #[doc = r"Pointer to the register block"]
1557 pub const PTR: *const swi0::RegisterBlock = 0x4001_9000 as *const _;
1558 #[doc = r"Return the pointer to the register block"]
1559 #[inline(always)]
1560 pub const fn ptr() -> *const swi0::RegisterBlock {
1561 Self::PTR
1562 }
1563}
1564impl Deref for SWI5 {
1565 type Target = swi0::RegisterBlock;
1566 #[inline(always)]
1567 fn deref(&self) -> &Self::Target {
1568 unsafe { &*Self::PTR }
1569 }
1570}
1571impl core::fmt::Debug for SWI5 {
1572 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1573 f.debug_struct("SWI5").finish()
1574 }
1575}
1576#[doc = "Software interrupt 5"]
1577pub use swi0 as swi5;
1578#[doc = "Event Generator Unit 5"]
1579pub struct EGU5 {
1580 _marker: PhantomData<*const ()>,
1581}
1582unsafe impl Send for EGU5 {}
1583impl EGU5 {
1584 #[doc = r"Pointer to the register block"]
1585 pub const PTR: *const egu0::RegisterBlock = 0x4001_9000 as *const _;
1586 #[doc = r"Return the pointer to the register block"]
1587 #[inline(always)]
1588 pub const fn ptr() -> *const egu0::RegisterBlock {
1589 Self::PTR
1590 }
1591}
1592impl Deref for EGU5 {
1593 type Target = egu0::RegisterBlock;
1594 #[inline(always)]
1595 fn deref(&self) -> &Self::Target {
1596 unsafe { &*Self::PTR }
1597 }
1598}
1599impl core::fmt::Debug for EGU5 {
1600 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1601 f.debug_struct("EGU5").finish()
1602 }
1603}
1604#[doc = "Event Generator Unit 5"]
1605pub use egu0 as egu5;
1606#[doc = "Timer/Counter 3"]
1607pub struct TIMER3 {
1608 _marker: PhantomData<*const ()>,
1609}
1610unsafe impl Send for TIMER3 {}
1611impl TIMER3 {
1612 #[doc = r"Pointer to the register block"]
1613 pub const PTR: *const timer3::RegisterBlock = 0x4001_a000 as *const _;
1614 #[doc = r"Return the pointer to the register block"]
1615 #[inline(always)]
1616 pub const fn ptr() -> *const timer3::RegisterBlock {
1617 Self::PTR
1618 }
1619}
1620impl Deref for TIMER3 {
1621 type Target = timer3::RegisterBlock;
1622 #[inline(always)]
1623 fn deref(&self) -> &Self::Target {
1624 unsafe { &*Self::PTR }
1625 }
1626}
1627impl core::fmt::Debug for TIMER3 {
1628 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1629 f.debug_struct("TIMER3").finish()
1630 }
1631}
1632#[doc = "Timer/Counter 3"]
1633pub mod timer3;
1634#[doc = "Timer/Counter 4"]
1635pub struct TIMER4 {
1636 _marker: PhantomData<*const ()>,
1637}
1638unsafe impl Send for TIMER4 {}
1639impl TIMER4 {
1640 #[doc = r"Pointer to the register block"]
1641 pub const PTR: *const timer3::RegisterBlock = 0x4001_b000 as *const _;
1642 #[doc = r"Return the pointer to the register block"]
1643 #[inline(always)]
1644 pub const fn ptr() -> *const timer3::RegisterBlock {
1645 Self::PTR
1646 }
1647}
1648impl Deref for TIMER4 {
1649 type Target = timer3::RegisterBlock;
1650 #[inline(always)]
1651 fn deref(&self) -> &Self::Target {
1652 unsafe { &*Self::PTR }
1653 }
1654}
1655impl core::fmt::Debug for TIMER4 {
1656 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1657 f.debug_struct("TIMER4").finish()
1658 }
1659}
1660#[doc = "Timer/Counter 4"]
1661pub use timer3 as timer4;
1662#[doc = "Pulse Width Modulation Unit 0"]
1663pub struct PWM0 {
1664 _marker: PhantomData<*const ()>,
1665}
1666unsafe impl Send for PWM0 {}
1667impl PWM0 {
1668 #[doc = r"Pointer to the register block"]
1669 pub const PTR: *const pwm0::RegisterBlock = 0x4001_c000 as *const _;
1670 #[doc = r"Return the pointer to the register block"]
1671 #[inline(always)]
1672 pub const fn ptr() -> *const pwm0::RegisterBlock {
1673 Self::PTR
1674 }
1675}
1676impl Deref for PWM0 {
1677 type Target = pwm0::RegisterBlock;
1678 #[inline(always)]
1679 fn deref(&self) -> &Self::Target {
1680 unsafe { &*Self::PTR }
1681 }
1682}
1683impl core::fmt::Debug for PWM0 {
1684 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1685 f.debug_struct("PWM0").finish()
1686 }
1687}
1688#[doc = "Pulse Width Modulation Unit 0"]
1689pub mod pwm0;
1690#[doc = "Pulse Density Modulation (Digital Microphone) Interface"]
1691pub struct PDM {
1692 _marker: PhantomData<*const ()>,
1693}
1694unsafe impl Send for PDM {}
1695impl PDM {
1696 #[doc = r"Pointer to the register block"]
1697 pub const PTR: *const pdm::RegisterBlock = 0x4001_d000 as *const _;
1698 #[doc = r"Return the pointer to the register block"]
1699 #[inline(always)]
1700 pub const fn ptr() -> *const pdm::RegisterBlock {
1701 Self::PTR
1702 }
1703}
1704impl Deref for PDM {
1705 type Target = pdm::RegisterBlock;
1706 #[inline(always)]
1707 fn deref(&self) -> &Self::Target {
1708 unsafe { &*Self::PTR }
1709 }
1710}
1711impl core::fmt::Debug for PDM {
1712 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1713 f.debug_struct("PDM").finish()
1714 }
1715}
1716#[doc = "Pulse Density Modulation (Digital Microphone) Interface"]
1717pub mod pdm;
1718#[doc = "Non Volatile Memory Controller"]
1719pub struct NVMC {
1720 _marker: PhantomData<*const ()>,
1721}
1722unsafe impl Send for NVMC {}
1723impl NVMC {
1724 #[doc = r"Pointer to the register block"]
1725 pub const PTR: *const nvmc::RegisterBlock = 0x4001_e000 as *const _;
1726 #[doc = r"Return the pointer to the register block"]
1727 #[inline(always)]
1728 pub const fn ptr() -> *const nvmc::RegisterBlock {
1729 Self::PTR
1730 }
1731}
1732impl Deref for NVMC {
1733 type Target = nvmc::RegisterBlock;
1734 #[inline(always)]
1735 fn deref(&self) -> &Self::Target {
1736 unsafe { &*Self::PTR }
1737 }
1738}
1739impl core::fmt::Debug for NVMC {
1740 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1741 f.debug_struct("NVMC").finish()
1742 }
1743}
1744#[doc = "Non Volatile Memory Controller"]
1745pub mod nvmc;
1746#[doc = "Programmable Peripheral Interconnect"]
1747pub struct PPI {
1748 _marker: PhantomData<*const ()>,
1749}
1750unsafe impl Send for PPI {}
1751impl PPI {
1752 #[doc = r"Pointer to the register block"]
1753 pub const PTR: *const ppi::RegisterBlock = 0x4001_f000 as *const _;
1754 #[doc = r"Return the pointer to the register block"]
1755 #[inline(always)]
1756 pub const fn ptr() -> *const ppi::RegisterBlock {
1757 Self::PTR
1758 }
1759}
1760impl Deref for PPI {
1761 type Target = ppi::RegisterBlock;
1762 #[inline(always)]
1763 fn deref(&self) -> &Self::Target {
1764 unsafe { &*Self::PTR }
1765 }
1766}
1767impl core::fmt::Debug for PPI {
1768 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1769 f.debug_struct("PPI").finish()
1770 }
1771}
1772#[doc = "Programmable Peripheral Interconnect"]
1773pub mod ppi;
1774#[doc = "Memory Watch Unit"]
1775pub struct MWU {
1776 _marker: PhantomData<*const ()>,
1777}
1778unsafe impl Send for MWU {}
1779impl MWU {
1780 #[doc = r"Pointer to the register block"]
1781 pub const PTR: *const mwu::RegisterBlock = 0x4002_0000 as *const _;
1782 #[doc = r"Return the pointer to the register block"]
1783 #[inline(always)]
1784 pub const fn ptr() -> *const mwu::RegisterBlock {
1785 Self::PTR
1786 }
1787}
1788impl Deref for MWU {
1789 type Target = mwu::RegisterBlock;
1790 #[inline(always)]
1791 fn deref(&self) -> &Self::Target {
1792 unsafe { &*Self::PTR }
1793 }
1794}
1795impl core::fmt::Debug for MWU {
1796 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1797 f.debug_struct("MWU").finish()
1798 }
1799}
1800#[doc = "Memory Watch Unit"]
1801pub mod mwu;
1802#[doc = "Pulse Width Modulation Unit 1"]
1803pub struct PWM1 {
1804 _marker: PhantomData<*const ()>,
1805}
1806unsafe impl Send for PWM1 {}
1807impl PWM1 {
1808 #[doc = r"Pointer to the register block"]
1809 pub const PTR: *const pwm0::RegisterBlock = 0x4002_1000 as *const _;
1810 #[doc = r"Return the pointer to the register block"]
1811 #[inline(always)]
1812 pub const fn ptr() -> *const pwm0::RegisterBlock {
1813 Self::PTR
1814 }
1815}
1816impl Deref for PWM1 {
1817 type Target = pwm0::RegisterBlock;
1818 #[inline(always)]
1819 fn deref(&self) -> &Self::Target {
1820 unsafe { &*Self::PTR }
1821 }
1822}
1823impl core::fmt::Debug for PWM1 {
1824 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1825 f.debug_struct("PWM1").finish()
1826 }
1827}
1828#[doc = "Pulse Width Modulation Unit 1"]
1829pub use pwm0 as pwm1;
1830#[doc = "Pulse Width Modulation Unit 2"]
1831pub struct PWM2 {
1832 _marker: PhantomData<*const ()>,
1833}
1834unsafe impl Send for PWM2 {}
1835impl PWM2 {
1836 #[doc = r"Pointer to the register block"]
1837 pub const PTR: *const pwm0::RegisterBlock = 0x4002_2000 as *const _;
1838 #[doc = r"Return the pointer to the register block"]
1839 #[inline(always)]
1840 pub const fn ptr() -> *const pwm0::RegisterBlock {
1841 Self::PTR
1842 }
1843}
1844impl Deref for PWM2 {
1845 type Target = pwm0::RegisterBlock;
1846 #[inline(always)]
1847 fn deref(&self) -> &Self::Target {
1848 unsafe { &*Self::PTR }
1849 }
1850}
1851impl core::fmt::Debug for PWM2 {
1852 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1853 f.debug_struct("PWM2").finish()
1854 }
1855}
1856#[doc = "Pulse Width Modulation Unit 2"]
1857pub use pwm0 as pwm2;
1858#[doc = "Serial Peripheral Interface Master with EasyDMA 2"]
1859pub struct SPIM2 {
1860 _marker: PhantomData<*const ()>,
1861}
1862unsafe impl Send for SPIM2 {}
1863impl SPIM2 {
1864 #[doc = r"Pointer to the register block"]
1865 pub const PTR: *const spim0::RegisterBlock = 0x4002_3000 as *const _;
1866 #[doc = r"Return the pointer to the register block"]
1867 #[inline(always)]
1868 pub const fn ptr() -> *const spim0::RegisterBlock {
1869 Self::PTR
1870 }
1871}
1872impl Deref for SPIM2 {
1873 type Target = spim0::RegisterBlock;
1874 #[inline(always)]
1875 fn deref(&self) -> &Self::Target {
1876 unsafe { &*Self::PTR }
1877 }
1878}
1879impl core::fmt::Debug for SPIM2 {
1880 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1881 f.debug_struct("SPIM2").finish()
1882 }
1883}
1884#[doc = "Serial Peripheral Interface Master with EasyDMA 2"]
1885pub use spim0 as spim2;
1886#[doc = "SPI Slave 2"]
1887pub struct SPIS2 {
1888 _marker: PhantomData<*const ()>,
1889}
1890unsafe impl Send for SPIS2 {}
1891impl SPIS2 {
1892 #[doc = r"Pointer to the register block"]
1893 pub const PTR: *const spis0::RegisterBlock = 0x4002_3000 as *const _;
1894 #[doc = r"Return the pointer to the register block"]
1895 #[inline(always)]
1896 pub const fn ptr() -> *const spis0::RegisterBlock {
1897 Self::PTR
1898 }
1899}
1900impl Deref for SPIS2 {
1901 type Target = spis0::RegisterBlock;
1902 #[inline(always)]
1903 fn deref(&self) -> &Self::Target {
1904 unsafe { &*Self::PTR }
1905 }
1906}
1907impl core::fmt::Debug for SPIS2 {
1908 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1909 f.debug_struct("SPIS2").finish()
1910 }
1911}
1912#[doc = "SPI Slave 2"]
1913pub use spis0 as spis2;
1914#[doc = "Serial Peripheral Interface 2"]
1915pub struct SPI2 {
1916 _marker: PhantomData<*const ()>,
1917}
1918unsafe impl Send for SPI2 {}
1919impl SPI2 {
1920 #[doc = r"Pointer to the register block"]
1921 pub const PTR: *const spi0::RegisterBlock = 0x4002_3000 as *const _;
1922 #[doc = r"Return the pointer to the register block"]
1923 #[inline(always)]
1924 pub const fn ptr() -> *const spi0::RegisterBlock {
1925 Self::PTR
1926 }
1927}
1928impl Deref for SPI2 {
1929 type Target = spi0::RegisterBlock;
1930 #[inline(always)]
1931 fn deref(&self) -> &Self::Target {
1932 unsafe { &*Self::PTR }
1933 }
1934}
1935impl core::fmt::Debug for SPI2 {
1936 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1937 f.debug_struct("SPI2").finish()
1938 }
1939}
1940#[doc = "Serial Peripheral Interface 2"]
1941pub use spi0 as spi2;
1942#[doc = "Real time counter 2"]
1943pub struct RTC2 {
1944 _marker: PhantomData<*const ()>,
1945}
1946unsafe impl Send for RTC2 {}
1947impl RTC2 {
1948 #[doc = r"Pointer to the register block"]
1949 pub const PTR: *const rtc0::RegisterBlock = 0x4002_4000 as *const _;
1950 #[doc = r"Return the pointer to the register block"]
1951 #[inline(always)]
1952 pub const fn ptr() -> *const rtc0::RegisterBlock {
1953 Self::PTR
1954 }
1955}
1956impl Deref for RTC2 {
1957 type Target = rtc0::RegisterBlock;
1958 #[inline(always)]
1959 fn deref(&self) -> &Self::Target {
1960 unsafe { &*Self::PTR }
1961 }
1962}
1963impl core::fmt::Debug for RTC2 {
1964 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1965 f.debug_struct("RTC2").finish()
1966 }
1967}
1968#[doc = "Real time counter 2"]
1969pub use rtc0 as rtc2;
1970#[doc = "Inter-IC Sound"]
1971pub struct I2S {
1972 _marker: PhantomData<*const ()>,
1973}
1974unsafe impl Send for I2S {}
1975impl I2S {
1976 #[doc = r"Pointer to the register block"]
1977 pub const PTR: *const i2s::RegisterBlock = 0x4002_5000 as *const _;
1978 #[doc = r"Return the pointer to the register block"]
1979 #[inline(always)]
1980 pub const fn ptr() -> *const i2s::RegisterBlock {
1981 Self::PTR
1982 }
1983}
1984impl Deref for I2S {
1985 type Target = i2s::RegisterBlock;
1986 #[inline(always)]
1987 fn deref(&self) -> &Self::Target {
1988 unsafe { &*Self::PTR }
1989 }
1990}
1991impl core::fmt::Debug for I2S {
1992 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1993 f.debug_struct("I2S").finish()
1994 }
1995}
1996#[doc = "Inter-IC Sound"]
1997pub mod i2s;
1998#[doc = "GPIO Port 1"]
1999pub struct P0 {
2000 _marker: PhantomData<*const ()>,
2001}
2002unsafe impl Send for P0 {}
2003impl P0 {
2004 #[doc = r"Pointer to the register block"]
2005 pub const PTR: *const p0::RegisterBlock = 0x5000_0000 as *const _;
2006 #[doc = r"Return the pointer to the register block"]
2007 #[inline(always)]
2008 pub const fn ptr() -> *const p0::RegisterBlock {
2009 Self::PTR
2010 }
2011}
2012impl Deref for P0 {
2013 type Target = p0::RegisterBlock;
2014 #[inline(always)]
2015 fn deref(&self) -> &Self::Target {
2016 unsafe { &*Self::PTR }
2017 }
2018}
2019impl core::fmt::Debug for P0 {
2020 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2021 f.debug_struct("P0").finish()
2022 }
2023}
2024#[doc = "GPIO Port 1"]
2025pub mod p0;
2026#[no_mangle]
2027static mut DEVICE_PERIPHERALS: bool = false;
2028#[doc = r"All the peripherals"]
2029#[allow(non_snake_case)]
2030pub struct Peripherals {
2031 #[doc = "FICR"]
2032 pub FICR: FICR,
2033 #[doc = "UICR"]
2034 pub UICR: UICR,
2035 #[doc = "BPROT"]
2036 pub BPROT: BPROT,
2037 #[doc = "POWER"]
2038 pub POWER: POWER,
2039 #[doc = "CLOCK"]
2040 pub CLOCK: CLOCK,
2041 #[doc = "RADIO"]
2042 pub RADIO: RADIO,
2043 #[doc = "UARTE0"]
2044 pub UARTE0: UARTE0,
2045 #[doc = "UART0"]
2046 pub UART0: UART0,
2047 #[doc = "SPIM0"]
2048 pub SPIM0: SPIM0,
2049 #[doc = "SPIS0"]
2050 pub SPIS0: SPIS0,
2051 #[doc = "TWIM0"]
2052 pub TWIM0: TWIM0,
2053 #[doc = "TWIS0"]
2054 pub TWIS0: TWIS0,
2055 #[doc = "SPI0"]
2056 pub SPI0: SPI0,
2057 #[doc = "TWI0"]
2058 pub TWI0: TWI0,
2059 #[doc = "SPIM1"]
2060 pub SPIM1: SPIM1,
2061 #[doc = "SPIS1"]
2062 pub SPIS1: SPIS1,
2063 #[doc = "TWIM1"]
2064 pub TWIM1: TWIM1,
2065 #[doc = "TWIS1"]
2066 pub TWIS1: TWIS1,
2067 #[doc = "SPI1"]
2068 pub SPI1: SPI1,
2069 #[doc = "TWI1"]
2070 pub TWI1: TWI1,
2071 #[doc = "NFCT"]
2072 pub NFCT: NFCT,
2073 #[doc = "GPIOTE"]
2074 pub GPIOTE: GPIOTE,
2075 #[doc = "SAADC"]
2076 pub SAADC: SAADC,
2077 #[doc = "TIMER0"]
2078 pub TIMER0: TIMER0,
2079 #[doc = "TIMER1"]
2080 pub TIMER1: TIMER1,
2081 #[doc = "TIMER2"]
2082 pub TIMER2: TIMER2,
2083 #[doc = "RTC0"]
2084 pub RTC0: RTC0,
2085 #[doc = "TEMP"]
2086 pub TEMP: TEMP,
2087 #[doc = "RNG"]
2088 pub RNG: RNG,
2089 #[doc = "ECB"]
2090 pub ECB: ECB,
2091 #[doc = "CCM"]
2092 pub CCM: CCM,
2093 #[doc = "AAR"]
2094 pub AAR: AAR,
2095 #[doc = "WDT"]
2096 pub WDT: WDT,
2097 #[doc = "RTC1"]
2098 pub RTC1: RTC1,
2099 #[doc = "QDEC"]
2100 pub QDEC: QDEC,
2101 #[doc = "COMP"]
2102 pub COMP: COMP,
2103 #[doc = "LPCOMP"]
2104 pub LPCOMP: LPCOMP,
2105 #[doc = "SWI0"]
2106 pub SWI0: SWI0,
2107 #[doc = "EGU0"]
2108 pub EGU0: EGU0,
2109 #[doc = "SWI1"]
2110 pub SWI1: SWI1,
2111 #[doc = "EGU1"]
2112 pub EGU1: EGU1,
2113 #[doc = "SWI2"]
2114 pub SWI2: SWI2,
2115 #[doc = "EGU2"]
2116 pub EGU2: EGU2,
2117 #[doc = "SWI3"]
2118 pub SWI3: SWI3,
2119 #[doc = "EGU3"]
2120 pub EGU3: EGU3,
2121 #[doc = "SWI4"]
2122 pub SWI4: SWI4,
2123 #[doc = "EGU4"]
2124 pub EGU4: EGU4,
2125 #[doc = "SWI5"]
2126 pub SWI5: SWI5,
2127 #[doc = "EGU5"]
2128 pub EGU5: EGU5,
2129 #[doc = "TIMER3"]
2130 pub TIMER3: TIMER3,
2131 #[doc = "TIMER4"]
2132 pub TIMER4: TIMER4,
2133 #[doc = "PWM0"]
2134 pub PWM0: PWM0,
2135 #[doc = "PDM"]
2136 pub PDM: PDM,
2137 #[doc = "NVMC"]
2138 pub NVMC: NVMC,
2139 #[doc = "PPI"]
2140 pub PPI: PPI,
2141 #[doc = "MWU"]
2142 pub MWU: MWU,
2143 #[doc = "PWM1"]
2144 pub PWM1: PWM1,
2145 #[doc = "PWM2"]
2146 pub PWM2: PWM2,
2147 #[doc = "SPIM2"]
2148 pub SPIM2: SPIM2,
2149 #[doc = "SPIS2"]
2150 pub SPIS2: SPIS2,
2151 #[doc = "SPI2"]
2152 pub SPI2: SPI2,
2153 #[doc = "RTC2"]
2154 pub RTC2: RTC2,
2155 #[doc = "I2S"]
2156 pub I2S: I2S,
2157 #[doc = "P0"]
2158 pub P0: P0,
2159}
2160impl Peripherals {
2161 #[doc = r"Returns all the peripherals *once*"]
2162 #[inline]
2163 pub fn take() -> Option<Self> {
2164 cortex_m::interrupt::free(|_| {
2165 if unsafe { DEVICE_PERIPHERALS } {
2166 None
2167 } else {
2168 Some(unsafe { Peripherals::steal() })
2169 }
2170 })
2171 }
2172 #[doc = r"Unchecked version of `Peripherals::take`"]
2173 #[inline]
2174 pub unsafe fn steal() -> Self {
2175 DEVICE_PERIPHERALS = true;
2176 Peripherals {
2177 FICR: FICR {
2178 _marker: PhantomData,
2179 },
2180 UICR: UICR {
2181 _marker: PhantomData,
2182 },
2183 BPROT: BPROT {
2184 _marker: PhantomData,
2185 },
2186 POWER: POWER {
2187 _marker: PhantomData,
2188 },
2189 CLOCK: CLOCK {
2190 _marker: PhantomData,
2191 },
2192 RADIO: RADIO {
2193 _marker: PhantomData,
2194 },
2195 UARTE0: UARTE0 {
2196 _marker: PhantomData,
2197 },
2198 UART0: UART0 {
2199 _marker: PhantomData,
2200 },
2201 SPIM0: SPIM0 {
2202 _marker: PhantomData,
2203 },
2204 SPIS0: SPIS0 {
2205 _marker: PhantomData,
2206 },
2207 TWIM0: TWIM0 {
2208 _marker: PhantomData,
2209 },
2210 TWIS0: TWIS0 {
2211 _marker: PhantomData,
2212 },
2213 SPI0: SPI0 {
2214 _marker: PhantomData,
2215 },
2216 TWI0: TWI0 {
2217 _marker: PhantomData,
2218 },
2219 SPIM1: SPIM1 {
2220 _marker: PhantomData,
2221 },
2222 SPIS1: SPIS1 {
2223 _marker: PhantomData,
2224 },
2225 TWIM1: TWIM1 {
2226 _marker: PhantomData,
2227 },
2228 TWIS1: TWIS1 {
2229 _marker: PhantomData,
2230 },
2231 SPI1: SPI1 {
2232 _marker: PhantomData,
2233 },
2234 TWI1: TWI1 {
2235 _marker: PhantomData,
2236 },
2237 NFCT: NFCT {
2238 _marker: PhantomData,
2239 },
2240 GPIOTE: GPIOTE {
2241 _marker: PhantomData,
2242 },
2243 SAADC: SAADC {
2244 _marker: PhantomData,
2245 },
2246 TIMER0: TIMER0 {
2247 _marker: PhantomData,
2248 },
2249 TIMER1: TIMER1 {
2250 _marker: PhantomData,
2251 },
2252 TIMER2: TIMER2 {
2253 _marker: PhantomData,
2254 },
2255 RTC0: RTC0 {
2256 _marker: PhantomData,
2257 },
2258 TEMP: TEMP {
2259 _marker: PhantomData,
2260 },
2261 RNG: RNG {
2262 _marker: PhantomData,
2263 },
2264 ECB: ECB {
2265 _marker: PhantomData,
2266 },
2267 CCM: CCM {
2268 _marker: PhantomData,
2269 },
2270 AAR: AAR {
2271 _marker: PhantomData,
2272 },
2273 WDT: WDT {
2274 _marker: PhantomData,
2275 },
2276 RTC1: RTC1 {
2277 _marker: PhantomData,
2278 },
2279 QDEC: QDEC {
2280 _marker: PhantomData,
2281 },
2282 COMP: COMP {
2283 _marker: PhantomData,
2284 },
2285 LPCOMP: LPCOMP {
2286 _marker: PhantomData,
2287 },
2288 SWI0: SWI0 {
2289 _marker: PhantomData,
2290 },
2291 EGU0: EGU0 {
2292 _marker: PhantomData,
2293 },
2294 SWI1: SWI1 {
2295 _marker: PhantomData,
2296 },
2297 EGU1: EGU1 {
2298 _marker: PhantomData,
2299 },
2300 SWI2: SWI2 {
2301 _marker: PhantomData,
2302 },
2303 EGU2: EGU2 {
2304 _marker: PhantomData,
2305 },
2306 SWI3: SWI3 {
2307 _marker: PhantomData,
2308 },
2309 EGU3: EGU3 {
2310 _marker: PhantomData,
2311 },
2312 SWI4: SWI4 {
2313 _marker: PhantomData,
2314 },
2315 EGU4: EGU4 {
2316 _marker: PhantomData,
2317 },
2318 SWI5: SWI5 {
2319 _marker: PhantomData,
2320 },
2321 EGU5: EGU5 {
2322 _marker: PhantomData,
2323 },
2324 TIMER3: TIMER3 {
2325 _marker: PhantomData,
2326 },
2327 TIMER4: TIMER4 {
2328 _marker: PhantomData,
2329 },
2330 PWM0: PWM0 {
2331 _marker: PhantomData,
2332 },
2333 PDM: PDM {
2334 _marker: PhantomData,
2335 },
2336 NVMC: NVMC {
2337 _marker: PhantomData,
2338 },
2339 PPI: PPI {
2340 _marker: PhantomData,
2341 },
2342 MWU: MWU {
2343 _marker: PhantomData,
2344 },
2345 PWM1: PWM1 {
2346 _marker: PhantomData,
2347 },
2348 PWM2: PWM2 {
2349 _marker: PhantomData,
2350 },
2351 SPIM2: SPIM2 {
2352 _marker: PhantomData,
2353 },
2354 SPIS2: SPIS2 {
2355 _marker: PhantomData,
2356 },
2357 SPI2: SPI2 {
2358 _marker: PhantomData,
2359 },
2360 RTC2: RTC2 {
2361 _marker: PhantomData,
2362 },
2363 I2S: I2S {
2364 _marker: PhantomData,
2365 },
2366 P0: P0 {
2367 _marker: PhantomData,
2368 },
2369 }
2370 }
2371}