1#![doc = "Peripheral access API for APOLLO3P microcontrollers (generated using svd2rust v0.17.0)\n\nYou can find an overview of the API [here].\n\n[here]: https://docs.rs/svd2rust/0.17.0/svd2rust/#peripheral-api"]
2#![deny(const_err)]
3#![deny(dead_code)]
4#![deny(improper_ctypes)]
5#![deny(legacy_directory_ownership)]
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(plugin_as_library)]
13#![deny(private_in_public)]
14#![deny(safe_extern_statics)]
15#![deny(unconditional_recursion)]
16#![deny(unions_with_drop_fields)]
17#![deny(unused_allocation)]
18#![deny(unused_comparisons)]
19#![deny(unused_parens)]
20#![deny(while_true)]
21#![allow(non_camel_case_types)]
22#![allow(non_snake_case)]
23#![no_std]
24extern crate bare_metal;
25extern crate cortex_m;
26#[cfg(feature = "rt")]
27extern crate cortex_m_rt;
28extern crate vcell;
29use core::marker::PhantomData;
30use core::ops::Deref;
31#[doc = r"Number available in the NVIC for configuring priority"]
32pub const NVIC_PRIO_BITS: u8 = 3;
33#[cfg(feature = "rt")]
34extern "C" {
35 fn BROWNOUT();
36 fn WDT();
37 fn RTC();
38 fn VCOMP();
39 fn IOSLAVE();
40 fn IOSLAVEACC();
41 fn IOMSTR0();
42 fn IOMSTR1();
43 fn IOMSTR2();
44 fn IOMSTR3();
45 fn IOMSTR4();
46 fn IOMSTR5();
47 fn BLE();
48 fn GPIO();
49 fn CTIMER();
50 fn UART0();
51 fn UART1();
52 fn SCARD();
53 fn ADC();
54 fn PDM();
55 fn MSPI0();
56 fn STIMER();
57 fn STIMER_CMPR0();
58 fn STIMER_CMPR1();
59 fn STIMER_CMPR2();
60 fn STIMER_CMPR3();
61 fn STIMER_CMPR4();
62 fn STIMER_CMPR5();
63 fn STIMER_CMPR6();
64 fn STIMER_CMPR7();
65 fn CLKGEN();
66 fn MSPI1();
67 fn MSPI2();
68}
69#[doc(hidden)]
70pub union Vector {
71 _handler: unsafe extern "C" fn(),
72 _reserved: u32,
73}
74#[cfg(feature = "rt")]
75#[doc(hidden)]
76#[link_section = ".vector_table.interrupts"]
77#[no_mangle]
78pub static __INTERRUPTS: [Vector; 34] = [
79 Vector { _handler: BROWNOUT },
80 Vector { _handler: WDT },
81 Vector { _handler: RTC },
82 Vector { _handler: VCOMP },
83 Vector { _handler: IOSLAVE },
84 Vector {
85 _handler: IOSLAVEACC,
86 },
87 Vector { _handler: IOMSTR0 },
88 Vector { _handler: IOMSTR1 },
89 Vector { _handler: IOMSTR2 },
90 Vector { _handler: IOMSTR3 },
91 Vector { _handler: IOMSTR4 },
92 Vector { _handler: IOMSTR5 },
93 Vector { _handler: BLE },
94 Vector { _handler: GPIO },
95 Vector { _handler: CTIMER },
96 Vector { _handler: UART0 },
97 Vector { _handler: UART1 },
98 Vector { _handler: SCARD },
99 Vector { _handler: ADC },
100 Vector { _handler: PDM },
101 Vector { _handler: MSPI0 },
102 Vector { _reserved: 0 },
103 Vector { _handler: STIMER },
104 Vector {
105 _handler: STIMER_CMPR0,
106 },
107 Vector {
108 _handler: STIMER_CMPR1,
109 },
110 Vector {
111 _handler: STIMER_CMPR2,
112 },
113 Vector {
114 _handler: STIMER_CMPR3,
115 },
116 Vector {
117 _handler: STIMER_CMPR4,
118 },
119 Vector {
120 _handler: STIMER_CMPR5,
121 },
122 Vector {
123 _handler: STIMER_CMPR6,
124 },
125 Vector {
126 _handler: STIMER_CMPR7,
127 },
128 Vector { _handler: CLKGEN },
129 Vector { _handler: MSPI1 },
130 Vector { _handler: MSPI2 },
131];
132#[doc = r"Enumeration of all the interrupts"]
133#[derive(Copy, Clone, Debug)]
134#[repr(u8)]
135pub enum Interrupt {
136 #[doc = "0 - BROWNOUT"]
137 BROWNOUT = 0,
138 #[doc = "1 - WDT"]
139 WDT = 1,
140 #[doc = "2 - RTC"]
141 RTC = 2,
142 #[doc = "3 - VCOMP"]
143 VCOMP = 3,
144 #[doc = "4 - IOSLAVE"]
145 IOSLAVE = 4,
146 #[doc = "5 - IOSLAVEACC"]
147 IOSLAVEACC = 5,
148 #[doc = "6 - IOMSTR0"]
149 IOMSTR0 = 6,
150 #[doc = "7 - IOMSTR1"]
151 IOMSTR1 = 7,
152 #[doc = "8 - IOMSTR2"]
153 IOMSTR2 = 8,
154 #[doc = "9 - IOMSTR3"]
155 IOMSTR3 = 9,
156 #[doc = "10 - IOMSTR4"]
157 IOMSTR4 = 10,
158 #[doc = "11 - IOMSTR5"]
159 IOMSTR5 = 11,
160 #[doc = "12 - BLE"]
161 BLE = 12,
162 #[doc = "13 - GPIO"]
163 GPIO = 13,
164 #[doc = "14 - CTIMER"]
165 CTIMER = 14,
166 #[doc = "15 - UART0"]
167 UART0 = 15,
168 #[doc = "16 - UART1"]
169 UART1 = 16,
170 #[doc = "17 - SCARD"]
171 SCARD = 17,
172 #[doc = "18 - ADC"]
173 ADC = 18,
174 #[doc = "19 - PDM"]
175 PDM = 19,
176 #[doc = "20 - MSPI0"]
177 MSPI0 = 20,
178 #[doc = "22 - STIMER"]
179 STIMER = 22,
180 #[doc = "23 - STIMER_CMPR0"]
181 STIMER_CMPR0 = 23,
182 #[doc = "24 - STIMER_CMPR1"]
183 STIMER_CMPR1 = 24,
184 #[doc = "25 - STIMER_CMPR2"]
185 STIMER_CMPR2 = 25,
186 #[doc = "26 - STIMER_CMPR3"]
187 STIMER_CMPR3 = 26,
188 #[doc = "27 - STIMER_CMPR4"]
189 STIMER_CMPR4 = 27,
190 #[doc = "28 - STIMER_CMPR5"]
191 STIMER_CMPR5 = 28,
192 #[doc = "29 - STIMER_CMPR6"]
193 STIMER_CMPR6 = 29,
194 #[doc = "30 - STIMER_CMPR7"]
195 STIMER_CMPR7 = 30,
196 #[doc = "31 - CLKGEN"]
197 CLKGEN = 31,
198 #[doc = "32 - MSPI1"]
199 MSPI1 = 32,
200 #[doc = "33 - MSPI2"]
201 MSPI2 = 33,
202}
203unsafe impl bare_metal::Nr for Interrupt {
204 #[inline(always)]
205 fn nr(&self) -> u8 {
206 *self as u8
207 }
208}
209#[cfg(feature = "rt")]
210pub use self::Interrupt as interrupt;
211pub use cortex_m::peripheral::Peripherals as CorePeripherals;
212pub use cortex_m::peripheral::{CBP, CPUID, DCB, DWT, FPB, FPU, ITM, MPU, NVIC, SCB, SYST, TPIU};
213#[cfg(feature = "rt")]
214pub use cortex_m_rt::interrupt;
215#[allow(unused_imports)]
216use generic::*;
217#[doc = r"Common register and bit access and modify traits"]
218pub mod generic;
219#[doc = "Analog Digital Converter Control"]
220pub struct ADC {
221 _marker: PhantomData<*const ()>,
222}
223unsafe impl Send for ADC {}
224impl ADC {
225 #[doc = r"Returns a pointer to the register block"]
226 #[inline(always)]
227 pub const fn ptr() -> *const adc::RegisterBlock {
228 0x5001_0000 as *const _
229 }
230}
231impl Deref for ADC {
232 type Target = adc::RegisterBlock;
233 #[inline(always)]
234 fn deref(&self) -> &Self::Target {
235 unsafe { &*ADC::ptr() }
236 }
237}
238#[doc = "Analog Digital Converter Control"]
239pub mod adc;
240#[doc = "APB DMA Register Interfaces"]
241pub struct APBDMA {
242 _marker: PhantomData<*const ()>,
243}
244unsafe impl Send for APBDMA {}
245impl APBDMA {
246 #[doc = r"Returns a pointer to the register block"]
247 #[inline(always)]
248 pub const fn ptr() -> *const apbdma::RegisterBlock {
249 0x4001_1000 as *const _
250 }
251}
252impl Deref for APBDMA {
253 type Target = apbdma::RegisterBlock;
254 #[inline(always)]
255 fn deref(&self) -> &Self::Target {
256 unsafe { &*APBDMA::ptr() }
257 }
258}
259#[doc = "APB DMA Register Interfaces"]
260pub mod apbdma;
261#[doc = "BLE Interface"]
262pub struct BLEIF {
263 _marker: PhantomData<*const ()>,
264}
265unsafe impl Send for BLEIF {}
266impl BLEIF {
267 #[doc = r"Returns a pointer to the register block"]
268 #[inline(always)]
269 pub const fn ptr() -> *const bleif::RegisterBlock {
270 0x5000_c000 as *const _
271 }
272}
273impl Deref for BLEIF {
274 type Target = bleif::RegisterBlock;
275 #[inline(always)]
276 fn deref(&self) -> &Self::Target {
277 unsafe { &*BLEIF::ptr() }
278 }
279}
280#[doc = "BLE Interface"]
281pub mod bleif;
282#[doc = "FLASH Cache Controller"]
283pub struct CACHECTRL {
284 _marker: PhantomData<*const ()>,
285}
286unsafe impl Send for CACHECTRL {}
287impl CACHECTRL {
288 #[doc = r"Returns a pointer to the register block"]
289 #[inline(always)]
290 pub const fn ptr() -> *const cachectrl::RegisterBlock {
291 0x4001_8000 as *const _
292 }
293}
294impl Deref for CACHECTRL {
295 type Target = cachectrl::RegisterBlock;
296 #[inline(always)]
297 fn deref(&self) -> &Self::Target {
298 unsafe { &*CACHECTRL::ptr() }
299 }
300}
301#[doc = "FLASH Cache Controller"]
302pub mod cachectrl;
303#[doc = "Clock Generator"]
304pub struct CLKGEN {
305 _marker: PhantomData<*const ()>,
306}
307unsafe impl Send for CLKGEN {}
308impl CLKGEN {
309 #[doc = r"Returns a pointer to the register block"]
310 #[inline(always)]
311 pub const fn ptr() -> *const clkgen::RegisterBlock {
312 0x4000_4000 as *const _
313 }
314}
315impl Deref for CLKGEN {
316 type Target = clkgen::RegisterBlock;
317 #[inline(always)]
318 fn deref(&self) -> &Self::Target {
319 unsafe { &*CLKGEN::ptr() }
320 }
321}
322#[doc = "Clock Generator"]
323pub mod clkgen;
324#[doc = "Counter/Timer"]
325pub struct CTIMER {
326 _marker: PhantomData<*const ()>,
327}
328unsafe impl Send for CTIMER {}
329impl CTIMER {
330 #[doc = r"Returns a pointer to the register block"]
331 #[inline(always)]
332 pub const fn ptr() -> *const ctimer::RegisterBlock {
333 0x4000_8000 as *const _
334 }
335}
336impl Deref for CTIMER {
337 type Target = ctimer::RegisterBlock;
338 #[inline(always)]
339 fn deref(&self) -> &Self::Target {
340 unsafe { &*CTIMER::ptr() }
341 }
342}
343#[doc = "Counter/Timer"]
344pub mod ctimer;
345#[doc = "General Purpose IO"]
346pub struct GPIO {
347 _marker: PhantomData<*const ()>,
348}
349unsafe impl Send for GPIO {}
350impl GPIO {
351 #[doc = r"Returns a pointer to the register block"]
352 #[inline(always)]
353 pub const fn ptr() -> *const gpio::RegisterBlock {
354 0x4001_0000 as *const _
355 }
356}
357impl Deref for GPIO {
358 type Target = gpio::RegisterBlock;
359 #[inline(always)]
360 fn deref(&self) -> &Self::Target {
361 unsafe { &*GPIO::ptr() }
362 }
363}
364#[doc = "General Purpose IO"]
365pub mod gpio;
366#[doc = "IO Peripheral Master"]
367pub struct IOM0 {
368 _marker: PhantomData<*const ()>,
369}
370unsafe impl Send for IOM0 {}
371impl IOM0 {
372 #[doc = r"Returns a pointer to the register block"]
373 #[inline(always)]
374 pub const fn ptr() -> *const iom0::RegisterBlock {
375 0x5000_4000 as *const _
376 }
377}
378impl Deref for IOM0 {
379 type Target = iom0::RegisterBlock;
380 #[inline(always)]
381 fn deref(&self) -> &Self::Target {
382 unsafe { &*IOM0::ptr() }
383 }
384}
385#[doc = "IO Peripheral Master"]
386pub mod iom0;
387#[doc = "IO Peripheral Master"]
388pub struct IOM1 {
389 _marker: PhantomData<*const ()>,
390}
391unsafe impl Send for IOM1 {}
392impl IOM1 {
393 #[doc = r"Returns a pointer to the register block"]
394 #[inline(always)]
395 pub const fn ptr() -> *const iom0::RegisterBlock {
396 0x5000_5000 as *const _
397 }
398}
399impl Deref for IOM1 {
400 type Target = iom0::RegisterBlock;
401 #[inline(always)]
402 fn deref(&self) -> &Self::Target {
403 unsafe { &*IOM1::ptr() }
404 }
405}
406#[doc = "IO Peripheral Master"]
407pub struct IOM2 {
408 _marker: PhantomData<*const ()>,
409}
410unsafe impl Send for IOM2 {}
411impl IOM2 {
412 #[doc = r"Returns a pointer to the register block"]
413 #[inline(always)]
414 pub const fn ptr() -> *const iom0::RegisterBlock {
415 0x5000_6000 as *const _
416 }
417}
418impl Deref for IOM2 {
419 type Target = iom0::RegisterBlock;
420 #[inline(always)]
421 fn deref(&self) -> &Self::Target {
422 unsafe { &*IOM2::ptr() }
423 }
424}
425#[doc = "IO Peripheral Master"]
426pub struct IOM3 {
427 _marker: PhantomData<*const ()>,
428}
429unsafe impl Send for IOM3 {}
430impl IOM3 {
431 #[doc = r"Returns a pointer to the register block"]
432 #[inline(always)]
433 pub const fn ptr() -> *const iom0::RegisterBlock {
434 0x5000_7000 as *const _
435 }
436}
437impl Deref for IOM3 {
438 type Target = iom0::RegisterBlock;
439 #[inline(always)]
440 fn deref(&self) -> &Self::Target {
441 unsafe { &*IOM3::ptr() }
442 }
443}
444#[doc = "IO Peripheral Master"]
445pub struct IOM4 {
446 _marker: PhantomData<*const ()>,
447}
448unsafe impl Send for IOM4 {}
449impl IOM4 {
450 #[doc = r"Returns a pointer to the register block"]
451 #[inline(always)]
452 pub const fn ptr() -> *const iom0::RegisterBlock {
453 0x5000_8000 as *const _
454 }
455}
456impl Deref for IOM4 {
457 type Target = iom0::RegisterBlock;
458 #[inline(always)]
459 fn deref(&self) -> &Self::Target {
460 unsafe { &*IOM4::ptr() }
461 }
462}
463#[doc = "IO Peripheral Master"]
464pub struct IOM5 {
465 _marker: PhantomData<*const ()>,
466}
467unsafe impl Send for IOM5 {}
468impl IOM5 {
469 #[doc = r"Returns a pointer to the register block"]
470 #[inline(always)]
471 pub const fn ptr() -> *const iom0::RegisterBlock {
472 0x5000_9000 as *const _
473 }
474}
475impl Deref for IOM5 {
476 type Target = iom0::RegisterBlock;
477 #[inline(always)]
478 fn deref(&self) -> &Self::Target {
479 unsafe { &*IOM5::ptr() }
480 }
481}
482#[doc = "I2C/SPI Slave"]
483pub struct IOSLAVE {
484 _marker: PhantomData<*const ()>,
485}
486unsafe impl Send for IOSLAVE {}
487impl IOSLAVE {
488 #[doc = r"Returns a pointer to the register block"]
489 #[inline(always)]
490 pub const fn ptr() -> *const ioslave::RegisterBlock {
491 0x5000_0000 as *const _
492 }
493}
494impl Deref for IOSLAVE {
495 type Target = ioslave::RegisterBlock;
496 #[inline(always)]
497 fn deref(&self) -> &Self::Target {
498 unsafe { &*IOSLAVE::ptr() }
499 }
500}
501#[doc = "I2C/SPI Slave"]
502pub mod ioslave;
503#[doc = "MCU Miscellaneous Control Logic"]
504pub struct MCUCTRL {
505 _marker: PhantomData<*const ()>,
506}
507unsafe impl Send for MCUCTRL {}
508impl MCUCTRL {
509 #[doc = r"Returns a pointer to the register block"]
510 #[inline(always)]
511 pub const fn ptr() -> *const mcuctrl::RegisterBlock {
512 0x4002_0000 as *const _
513 }
514}
515impl Deref for MCUCTRL {
516 type Target = mcuctrl::RegisterBlock;
517 #[inline(always)]
518 fn deref(&self) -> &Self::Target {
519 unsafe { &*MCUCTRL::ptr() }
520 }
521}
522#[doc = "MCU Miscellaneous Control Logic"]
523pub mod mcuctrl;
524#[doc = "Multi-bit SPI Master"]
525pub struct MSPI0 {
526 _marker: PhantomData<*const ()>,
527}
528unsafe impl Send for MSPI0 {}
529impl MSPI0 {
530 #[doc = r"Returns a pointer to the register block"]
531 #[inline(always)]
532 pub const fn ptr() -> *const mspi0::RegisterBlock {
533 0x5001_4000 as *const _
534 }
535}
536impl Deref for MSPI0 {
537 type Target = mspi0::RegisterBlock;
538 #[inline(always)]
539 fn deref(&self) -> &Self::Target {
540 unsafe { &*MSPI0::ptr() }
541 }
542}
543#[doc = "Multi-bit SPI Master"]
544pub mod mspi0;
545#[doc = "Multi-bit SPI Master"]
546pub struct MSPI1 {
547 _marker: PhantomData<*const ()>,
548}
549unsafe impl Send for MSPI1 {}
550impl MSPI1 {
551 #[doc = r"Returns a pointer to the register block"]
552 #[inline(always)]
553 pub const fn ptr() -> *const mspi0::RegisterBlock {
554 0x5001_5000 as *const _
555 }
556}
557impl Deref for MSPI1 {
558 type Target = mspi0::RegisterBlock;
559 #[inline(always)]
560 fn deref(&self) -> &Self::Target {
561 unsafe { &*MSPI1::ptr() }
562 }
563}
564#[doc = "Multi-bit SPI Master"]
565pub struct MSPI2 {
566 _marker: PhantomData<*const ()>,
567}
568unsafe impl Send for MSPI2 {}
569impl MSPI2 {
570 #[doc = r"Returns a pointer to the register block"]
571 #[inline(always)]
572 pub const fn ptr() -> *const mspi0::RegisterBlock {
573 0x5001_6000 as *const _
574 }
575}
576impl Deref for MSPI2 {
577 type Target = mspi0::RegisterBlock;
578 #[inline(always)]
579 fn deref(&self) -> &Self::Target {
580 unsafe { &*MSPI2::ptr() }
581 }
582}
583#[doc = "PDM Audio"]
584pub struct PDM {
585 _marker: PhantomData<*const ()>,
586}
587unsafe impl Send for PDM {}
588impl PDM {
589 #[doc = r"Returns a pointer to the register block"]
590 #[inline(always)]
591 pub const fn ptr() -> *const pdm::RegisterBlock {
592 0x5001_1000 as *const _
593 }
594}
595impl Deref for PDM {
596 type Target = pdm::RegisterBlock;
597 #[inline(always)]
598 fn deref(&self) -> &Self::Target {
599 unsafe { &*PDM::ptr() }
600 }
601}
602#[doc = "PDM Audio"]
603pub mod pdm;
604#[doc = "PWR Controller Register Bank"]
605pub struct PWRCTRL {
606 _marker: PhantomData<*const ()>,
607}
608unsafe impl Send for PWRCTRL {}
609impl PWRCTRL {
610 #[doc = r"Returns a pointer to the register block"]
611 #[inline(always)]
612 pub const fn ptr() -> *const pwrctrl::RegisterBlock {
613 0x4002_1000 as *const _
614 }
615}
616impl Deref for PWRCTRL {
617 type Target = pwrctrl::RegisterBlock;
618 #[inline(always)]
619 fn deref(&self) -> &Self::Target {
620 unsafe { &*PWRCTRL::ptr() }
621 }
622}
623#[doc = "PWR Controller Register Bank"]
624pub mod pwrctrl;
625#[doc = "MCU Reset Generator"]
626pub struct RSTGEN {
627 _marker: PhantomData<*const ()>,
628}
629unsafe impl Send for RSTGEN {}
630impl RSTGEN {
631 #[doc = r"Returns a pointer to the register block"]
632 #[inline(always)]
633 pub const fn ptr() -> *const rstgen::RegisterBlock {
634 0x4000_0000 as *const _
635 }
636}
637impl Deref for RSTGEN {
638 type Target = rstgen::RegisterBlock;
639 #[inline(always)]
640 fn deref(&self) -> &Self::Target {
641 unsafe { &*RSTGEN::ptr() }
642 }
643}
644#[doc = "MCU Reset Generator"]
645pub mod rstgen;
646#[doc = "Real Time Clock"]
647pub struct RTC {
648 _marker: PhantomData<*const ()>,
649}
650unsafe impl Send for RTC {}
651impl RTC {
652 #[doc = r"Returns a pointer to the register block"]
653 #[inline(always)]
654 pub const fn ptr() -> *const rtc::RegisterBlock {
655 0x4000_4200 as *const _
656 }
657}
658impl Deref for RTC {
659 type Target = rtc::RegisterBlock;
660 #[inline(always)]
661 fn deref(&self) -> &Self::Target {
662 unsafe { &*RTC::ptr() }
663 }
664}
665#[doc = "Real Time Clock"]
666pub mod rtc;
667#[doc = "Serial ISO7816"]
668pub struct SCARD {
669 _marker: PhantomData<*const ()>,
670}
671unsafe impl Send for SCARD {}
672impl SCARD {
673 #[doc = r"Returns a pointer to the register block"]
674 #[inline(always)]
675 pub const fn ptr() -> *const scard::RegisterBlock {
676 0x4008_0000 as *const _
677 }
678}
679impl Deref for SCARD {
680 type Target = scard::RegisterBlock;
681 #[inline(always)]
682 fn deref(&self) -> &Self::Target {
683 unsafe { &*SCARD::ptr() }
684 }
685}
686#[doc = "Serial ISO7816"]
687pub mod scard;
688#[doc = "Security Interfaces"]
689pub struct SECURITY {
690 _marker: PhantomData<*const ()>,
691}
692unsafe impl Send for SECURITY {}
693impl SECURITY {
694 #[doc = r"Returns a pointer to the register block"]
695 #[inline(always)]
696 pub const fn ptr() -> *const security::RegisterBlock {
697 0x4003_0000 as *const _
698 }
699}
700impl Deref for SECURITY {
701 type Target = security::RegisterBlock;
702 #[inline(always)]
703 fn deref(&self) -> &Self::Target {
704 unsafe { &*SECURITY::ptr() }
705 }
706}
707#[doc = "Security Interfaces"]
708pub mod security;
709#[doc = "Serial UART"]
710pub struct UART0 {
711 _marker: PhantomData<*const ()>,
712}
713unsafe impl Send for UART0 {}
714impl UART0 {
715 #[doc = r"Returns a pointer to the register block"]
716 #[inline(always)]
717 pub const fn ptr() -> *const uart0::RegisterBlock {
718 0x4001_c000 as *const _
719 }
720}
721impl Deref for UART0 {
722 type Target = uart0::RegisterBlock;
723 #[inline(always)]
724 fn deref(&self) -> &Self::Target {
725 unsafe { &*UART0::ptr() }
726 }
727}
728#[doc = "Serial UART"]
729pub mod uart0;
730#[doc = "Serial UART"]
731pub struct UART1 {
732 _marker: PhantomData<*const ()>,
733}
734unsafe impl Send for UART1 {}
735impl UART1 {
736 #[doc = r"Returns a pointer to the register block"]
737 #[inline(always)]
738 pub const fn ptr() -> *const uart0::RegisterBlock {
739 0x4001_d000 as *const _
740 }
741}
742impl Deref for UART1 {
743 type Target = uart0::RegisterBlock;
744 #[inline(always)]
745 fn deref(&self) -> &Self::Target {
746 unsafe { &*UART1::ptr() }
747 }
748}
749#[doc = "Voltage Comparator"]
750pub struct VCOMP {
751 _marker: PhantomData<*const ()>,
752}
753unsafe impl Send for VCOMP {}
754impl VCOMP {
755 #[doc = r"Returns a pointer to the register block"]
756 #[inline(always)]
757 pub const fn ptr() -> *const vcomp::RegisterBlock {
758 0x4000_c000 as *const _
759 }
760}
761impl Deref for VCOMP {
762 type Target = vcomp::RegisterBlock;
763 #[inline(always)]
764 fn deref(&self) -> &Self::Target {
765 unsafe { &*VCOMP::ptr() }
766 }
767}
768#[doc = "Voltage Comparator"]
769pub mod vcomp;
770#[doc = "Watchdog Timer"]
771pub struct WDT {
772 _marker: PhantomData<*const ()>,
773}
774unsafe impl Send for WDT {}
775impl WDT {
776 #[doc = r"Returns a pointer to the register block"]
777 #[inline(always)]
778 pub const fn ptr() -> *const wdt::RegisterBlock {
779 0x4002_4000 as *const _
780 }
781}
782impl Deref for WDT {
783 type Target = wdt::RegisterBlock;
784 #[inline(always)]
785 fn deref(&self) -> &Self::Target {
786 unsafe { &*WDT::ptr() }
787 }
788}
789#[doc = "Watchdog Timer"]
790pub mod wdt;
791#[no_mangle]
792static mut DEVICE_PERIPHERALS: bool = false;
793#[doc = r"All the peripherals"]
794#[allow(non_snake_case)]
795pub struct Peripherals {
796 #[doc = "ADC"]
797 pub ADC: ADC,
798 #[doc = "APBDMA"]
799 pub APBDMA: APBDMA,
800 #[doc = "BLEIF"]
801 pub BLEIF: BLEIF,
802 #[doc = "CACHECTRL"]
803 pub CACHECTRL: CACHECTRL,
804 #[doc = "CLKGEN"]
805 pub CLKGEN: CLKGEN,
806 #[doc = "CTIMER"]
807 pub CTIMER: CTIMER,
808 #[doc = "GPIO"]
809 pub GPIO: GPIO,
810 #[doc = "IOM0"]
811 pub IOM0: IOM0,
812 #[doc = "IOM1"]
813 pub IOM1: IOM1,
814 #[doc = "IOM2"]
815 pub IOM2: IOM2,
816 #[doc = "IOM3"]
817 pub IOM3: IOM3,
818 #[doc = "IOM4"]
819 pub IOM4: IOM4,
820 #[doc = "IOM5"]
821 pub IOM5: IOM5,
822 #[doc = "IOSLAVE"]
823 pub IOSLAVE: IOSLAVE,
824 #[doc = "MCUCTRL"]
825 pub MCUCTRL: MCUCTRL,
826 #[doc = "MSPI0"]
827 pub MSPI0: MSPI0,
828 #[doc = "MSPI1"]
829 pub MSPI1: MSPI1,
830 #[doc = "MSPI2"]
831 pub MSPI2: MSPI2,
832 #[doc = "PDM"]
833 pub PDM: PDM,
834 #[doc = "PWRCTRL"]
835 pub PWRCTRL: PWRCTRL,
836 #[doc = "RSTGEN"]
837 pub RSTGEN: RSTGEN,
838 #[doc = "RTC"]
839 pub RTC: RTC,
840 #[doc = "SCARD"]
841 pub SCARD: SCARD,
842 #[doc = "SECURITY"]
843 pub SECURITY: SECURITY,
844 #[doc = "UART0"]
845 pub UART0: UART0,
846 #[doc = "UART1"]
847 pub UART1: UART1,
848 #[doc = "VCOMP"]
849 pub VCOMP: VCOMP,
850 #[doc = "WDT"]
851 pub WDT: WDT,
852}
853impl Peripherals {
854 #[doc = r"Returns all the peripherals *once*"]
855 #[inline]
856 pub fn take() -> Option<Self> {
857 cortex_m::interrupt::free(|_| {
858 if unsafe { DEVICE_PERIPHERALS } {
859 None
860 } else {
861 Some(unsafe { Peripherals::steal() })
862 }
863 })
864 }
865 #[doc = r"Unchecked version of `Peripherals::take`"]
866 #[inline]
867 pub unsafe fn steal() -> Self {
868 DEVICE_PERIPHERALS = true;
869 Peripherals {
870 ADC: ADC {
871 _marker: PhantomData,
872 },
873 APBDMA: APBDMA {
874 _marker: PhantomData,
875 },
876 BLEIF: BLEIF {
877 _marker: PhantomData,
878 },
879 CACHECTRL: CACHECTRL {
880 _marker: PhantomData,
881 },
882 CLKGEN: CLKGEN {
883 _marker: PhantomData,
884 },
885 CTIMER: CTIMER {
886 _marker: PhantomData,
887 },
888 GPIO: GPIO {
889 _marker: PhantomData,
890 },
891 IOM0: IOM0 {
892 _marker: PhantomData,
893 },
894 IOM1: IOM1 {
895 _marker: PhantomData,
896 },
897 IOM2: IOM2 {
898 _marker: PhantomData,
899 },
900 IOM3: IOM3 {
901 _marker: PhantomData,
902 },
903 IOM4: IOM4 {
904 _marker: PhantomData,
905 },
906 IOM5: IOM5 {
907 _marker: PhantomData,
908 },
909 IOSLAVE: IOSLAVE {
910 _marker: PhantomData,
911 },
912 MCUCTRL: MCUCTRL {
913 _marker: PhantomData,
914 },
915 MSPI0: MSPI0 {
916 _marker: PhantomData,
917 },
918 MSPI1: MSPI1 {
919 _marker: PhantomData,
920 },
921 MSPI2: MSPI2 {
922 _marker: PhantomData,
923 },
924 PDM: PDM {
925 _marker: PhantomData,
926 },
927 PWRCTRL: PWRCTRL {
928 _marker: PhantomData,
929 },
930 RSTGEN: RSTGEN {
931 _marker: PhantomData,
932 },
933 RTC: RTC {
934 _marker: PhantomData,
935 },
936 SCARD: SCARD {
937 _marker: PhantomData,
938 },
939 SECURITY: SECURITY {
940 _marker: PhantomData,
941 },
942 UART0: UART0 {
943 _marker: PhantomData,
944 },
945 UART1: UART1 {
946 _marker: PhantomData,
947 },
948 VCOMP: VCOMP {
949 _marker: PhantomData,
950 },
951 WDT: WDT {
952 _marker: PhantomData,
953 },
954 }
955 }
956}