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