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