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