1#![doc = "Peripheral access API for MKL26Z4 microcontrollers (generated using svd2rust v0.16.0)\n\nYou can find an overview of the API [here].\n\n[here]: https://docs.rs/svd2rust/0.16.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 = 2;
15#[cfg(feature = "rt")]
16extern "C" {
17 fn DMA0();
18 fn DMA1();
19 fn DMA2();
20 fn DMA3();
21 fn FTFA();
22 fn LVD_LVW();
23 fn LLWU();
24 fn I2C0();
25 fn I2C1();
26 fn SPI0();
27 fn SPI1();
28 fn UART0();
29 fn UART1();
30 fn UART2();
31 fn ADC0();
32 fn CMP0();
33 fn TPM0();
34 fn TPM1();
35 fn TPM2();
36 fn RTC();
37 fn RTC_SECONDS();
38 fn PIT();
39 fn I2S0();
40 fn USB0();
41 fn DAC0();
42 fn TSI0();
43 fn MCG();
44 fn LPTMR0();
45 fn PORTA();
46 fn PORTC_PORTD();
47}
48#[doc(hidden)]
49pub union Vector {
50 _handler: unsafe extern "C" fn(),
51 _reserved: u32,
52}
53#[cfg(feature = "rt")]
54#[doc(hidden)]
55#[link_section = ".vector_table.interrupts"]
56#[no_mangle]
57pub static __INTERRUPTS: [Vector; 32] = [
58 Vector { _handler: DMA0 },
59 Vector { _handler: DMA1 },
60 Vector { _handler: DMA2 },
61 Vector { _handler: DMA3 },
62 Vector { _reserved: 0 },
63 Vector { _handler: FTFA },
64 Vector { _handler: LVD_LVW },
65 Vector { _handler: LLWU },
66 Vector { _handler: I2C0 },
67 Vector { _handler: I2C1 },
68 Vector { _handler: SPI0 },
69 Vector { _handler: SPI1 },
70 Vector { _handler: UART0 },
71 Vector { _handler: UART1 },
72 Vector { _handler: UART2 },
73 Vector { _handler: ADC0 },
74 Vector { _handler: CMP0 },
75 Vector { _handler: TPM0 },
76 Vector { _handler: TPM1 },
77 Vector { _handler: TPM2 },
78 Vector { _handler: RTC },
79 Vector {
80 _handler: RTC_SECONDS,
81 },
82 Vector { _handler: PIT },
83 Vector { _handler: I2S0 },
84 Vector { _handler: USB0 },
85 Vector { _handler: DAC0 },
86 Vector { _handler: TSI0 },
87 Vector { _handler: MCG },
88 Vector { _handler: LPTMR0 },
89 Vector { _reserved: 0 },
90 Vector { _handler: PORTA },
91 Vector {
92 _handler: PORTC_PORTD,
93 },
94];
95#[doc = r"Enumeration of all the interrupts"]
96#[derive(Copy, Clone, Debug)]
97pub enum Interrupt {
98 #[doc = "0 - DMA0"]
99 DMA0,
100 #[doc = "1 - DMA1"]
101 DMA1,
102 #[doc = "2 - DMA2"]
103 DMA2,
104 #[doc = "3 - DMA3"]
105 DMA3,
106 #[doc = "5 - FTFA"]
107 FTFA,
108 #[doc = "6 - LVD_LVW"]
109 LVD_LVW,
110 #[doc = "7 - LLWU"]
111 LLWU,
112 #[doc = "8 - I2C0"]
113 I2C0,
114 #[doc = "9 - I2C1"]
115 I2C1,
116 #[doc = "10 - SPI0"]
117 SPI0,
118 #[doc = "11 - SPI1"]
119 SPI1,
120 #[doc = "12 - UART0"]
121 UART0,
122 #[doc = "13 - UART1"]
123 UART1,
124 #[doc = "14 - UART2"]
125 UART2,
126 #[doc = "15 - ADC0"]
127 ADC0,
128 #[doc = "16 - CMP0"]
129 CMP0,
130 #[doc = "17 - TPM0"]
131 TPM0,
132 #[doc = "18 - TPM1"]
133 TPM1,
134 #[doc = "19 - TPM2"]
135 TPM2,
136 #[doc = "20 - RTC"]
137 RTC,
138 #[doc = "21 - RTC_Seconds"]
139 RTC_SECONDS,
140 #[doc = "22 - PIT"]
141 PIT,
142 #[doc = "23 - I2S0"]
143 I2S0,
144 #[doc = "24 - USB0"]
145 USB0,
146 #[doc = "25 - DAC0"]
147 DAC0,
148 #[doc = "26 - TSI0"]
149 TSI0,
150 #[doc = "27 - MCG"]
151 MCG,
152 #[doc = "28 - LPTMR0"]
153 LPTMR0,
154 #[doc = "30 - PORTA"]
155 PORTA,
156 #[doc = "31 - PORTC_PORTD"]
157 PORTC_PORTD,
158}
159unsafe impl bare_metal::Nr for Interrupt {
160 #[inline]
161 fn nr(&self) -> u8 {
162 match *self {
163 Interrupt::DMA0 => 0,
164 Interrupt::DMA1 => 1,
165 Interrupt::DMA2 => 2,
166 Interrupt::DMA3 => 3,
167 Interrupt::FTFA => 5,
168 Interrupt::LVD_LVW => 6,
169 Interrupt::LLWU => 7,
170 Interrupt::I2C0 => 8,
171 Interrupt::I2C1 => 9,
172 Interrupt::SPI0 => 10,
173 Interrupt::SPI1 => 11,
174 Interrupt::UART0 => 12,
175 Interrupt::UART1 => 13,
176 Interrupt::UART2 => 14,
177 Interrupt::ADC0 => 15,
178 Interrupt::CMP0 => 16,
179 Interrupt::TPM0 => 17,
180 Interrupt::TPM1 => 18,
181 Interrupt::TPM2 => 19,
182 Interrupt::RTC => 20,
183 Interrupt::RTC_SECONDS => 21,
184 Interrupt::PIT => 22,
185 Interrupt::I2S0 => 23,
186 Interrupt::USB0 => 24,
187 Interrupt::DAC0 => 25,
188 Interrupt::TSI0 => 26,
189 Interrupt::MCG => 27,
190 Interrupt::LPTMR0 => 28,
191 Interrupt::PORTA => 30,
192 Interrupt::PORTC_PORTD => 31,
193 }
194 }
195}
196#[cfg(feature = "rt")]
197pub use self::Interrupt as interrupt;
198pub use cortex_m::peripheral::Peripherals as CorePeripherals;
199pub use cortex_m::peripheral::{CBP, CPUID, DCB, DWT, FPB, ITM, MPU, NVIC, SCB, SYST, TPIU};
200#[cfg(feature = "rt")]
201pub use cortex_m_rt::interrupt;
202#[allow(unused_imports)]
203use generic::*;
204#[doc = r"Common register and bit access and modify traits"]
205pub mod generic;
206#[doc = "Flash configuration field"]
207pub struct FTFA_FLASHCONFIG {
208 _marker: PhantomData<*const ()>,
209}
210unsafe impl Send for FTFA_FLASHCONFIG {}
211impl FTFA_FLASHCONFIG {
212 #[doc = r"Returns a pointer to the register block"]
213 #[inline(always)]
214 pub const fn ptr() -> *const ftfa_flash_config::RegisterBlock {
215 0x0400 as *const _
216 }
217}
218impl Deref for FTFA_FLASHCONFIG {
219 type Target = ftfa_flash_config::RegisterBlock;
220 fn deref(&self) -> &Self::Target {
221 unsafe { &*FTFA_FLASHCONFIG::ptr() }
222 }
223}
224#[doc = "Flash configuration field"]
225pub mod ftfa_flash_config;
226#[doc = "DMA Controller"]
227pub struct DMA {
228 _marker: PhantomData<*const ()>,
229}
230unsafe impl Send for DMA {}
231impl DMA {
232 #[doc = r"Returns a pointer to the register block"]
233 #[inline(always)]
234 pub const fn ptr() -> *const dma::RegisterBlock {
235 0x4000_8000 as *const _
236 }
237}
238impl Deref for DMA {
239 type Target = dma::RegisterBlock;
240 fn deref(&self) -> &Self::Target {
241 unsafe { &*DMA::ptr() }
242 }
243}
244#[doc = "DMA Controller"]
245pub mod dma;
246#[doc = "Flash Memory Interface"]
247pub struct FTFA {
248 _marker: PhantomData<*const ()>,
249}
250unsafe impl Send for FTFA {}
251impl FTFA {
252 #[doc = r"Returns a pointer to the register block"]
253 #[inline(always)]
254 pub const fn ptr() -> *const ftfa::RegisterBlock {
255 0x4002_0000 as *const _
256 }
257}
258impl Deref for FTFA {
259 type Target = ftfa::RegisterBlock;
260 fn deref(&self) -> &Self::Target {
261 unsafe { &*FTFA::ptr() }
262 }
263}
264#[doc = "Flash Memory Interface"]
265pub mod ftfa;
266#[doc = "DMA channel multiplexor"]
267pub struct DMAMUX0 {
268 _marker: PhantomData<*const ()>,
269}
270unsafe impl Send for DMAMUX0 {}
271impl DMAMUX0 {
272 #[doc = r"Returns a pointer to the register block"]
273 #[inline(always)]
274 pub const fn ptr() -> *const dmamux0::RegisterBlock {
275 0x4002_1000 as *const _
276 }
277}
278impl Deref for DMAMUX0 {
279 type Target = dmamux0::RegisterBlock;
280 fn deref(&self) -> &Self::Target {
281 unsafe { &*DMAMUX0::ptr() }
282 }
283}
284#[doc = "DMA channel multiplexor"]
285pub mod dmamux0;
286#[doc = "Inter-IC Sound / Synchronous Audio Interface"]
287pub struct I2S0 {
288 _marker: PhantomData<*const ()>,
289}
290unsafe impl Send for I2S0 {}
291impl I2S0 {
292 #[doc = r"Returns a pointer to the register block"]
293 #[inline(always)]
294 pub const fn ptr() -> *const i2s0::RegisterBlock {
295 0x4002_f000 as *const _
296 }
297}
298impl Deref for I2S0 {
299 type Target = i2s0::RegisterBlock;
300 fn deref(&self) -> &Self::Target {
301 unsafe { &*I2S0::ptr() }
302 }
303}
304#[doc = "Inter-IC Sound / Synchronous Audio Interface"]
305pub mod i2s0;
306#[doc = "Periodic Interrupt Timer"]
307pub struct PIT {
308 _marker: PhantomData<*const ()>,
309}
310unsafe impl Send for PIT {}
311impl PIT {
312 #[doc = r"Returns a pointer to the register block"]
313 #[inline(always)]
314 pub const fn ptr() -> *const pit::RegisterBlock {
315 0x4003_7000 as *const _
316 }
317}
318impl Deref for PIT {
319 type Target = pit::RegisterBlock;
320 fn deref(&self) -> &Self::Target {
321 unsafe { &*PIT::ptr() }
322 }
323}
324#[doc = "Periodic Interrupt Timer"]
325pub mod pit;
326#[doc = "Timer/PWM Module"]
327pub struct TPM0 {
328 _marker: PhantomData<*const ()>,
329}
330unsafe impl Send for TPM0 {}
331impl TPM0 {
332 #[doc = r"Returns a pointer to the register block"]
333 #[inline(always)]
334 pub const fn ptr() -> *const tpm0::RegisterBlock {
335 0x4003_8000 as *const _
336 }
337}
338impl Deref for TPM0 {
339 type Target = tpm0::RegisterBlock;
340 fn deref(&self) -> &Self::Target {
341 unsafe { &*TPM0::ptr() }
342 }
343}
344#[doc = "Timer/PWM Module"]
345pub mod tpm0;
346#[doc = "Timer/PWM Module"]
347pub struct TPM1 {
348 _marker: PhantomData<*const ()>,
349}
350unsafe impl Send for TPM1 {}
351impl TPM1 {
352 #[doc = r"Returns a pointer to the register block"]
353 #[inline(always)]
354 pub const fn ptr() -> *const tpm1::RegisterBlock {
355 0x4003_9000 as *const _
356 }
357}
358impl Deref for TPM1 {
359 type Target = tpm1::RegisterBlock;
360 fn deref(&self) -> &Self::Target {
361 unsafe { &*TPM1::ptr() }
362 }
363}
364#[doc = "Timer/PWM Module"]
365pub mod tpm1;
366#[doc = "Timer/PWM Module"]
367pub struct TPM2 {
368 _marker: PhantomData<*const ()>,
369}
370unsafe impl Send for TPM2 {}
371impl TPM2 {
372 #[doc = r"Returns a pointer to the register block"]
373 #[inline(always)]
374 pub const fn ptr() -> *const tpm2::RegisterBlock {
375 0x4003_a000 as *const _
376 }
377}
378impl Deref for TPM2 {
379 type Target = tpm2::RegisterBlock;
380 fn deref(&self) -> &Self::Target {
381 unsafe { &*TPM2::ptr() }
382 }
383}
384#[doc = "Timer/PWM Module"]
385pub mod tpm2;
386#[doc = "Analog-to-Digital Converter"]
387pub struct ADC0 {
388 _marker: PhantomData<*const ()>,
389}
390unsafe impl Send for ADC0 {}
391impl ADC0 {
392 #[doc = r"Returns a pointer to the register block"]
393 #[inline(always)]
394 pub const fn ptr() -> *const adc0::RegisterBlock {
395 0x4003_b000 as *const _
396 }
397}
398impl Deref for ADC0 {
399 type Target = adc0::RegisterBlock;
400 fn deref(&self) -> &Self::Target {
401 unsafe { &*ADC0::ptr() }
402 }
403}
404#[doc = "Analog-to-Digital Converter"]
405pub mod adc0;
406#[doc = "Secure Real Time Clock"]
407pub struct RTC {
408 _marker: PhantomData<*const ()>,
409}
410unsafe impl Send for RTC {}
411impl RTC {
412 #[doc = r"Returns a pointer to the register block"]
413 #[inline(always)]
414 pub const fn ptr() -> *const rtc::RegisterBlock {
415 0x4003_d000 as *const _
416 }
417}
418impl Deref for RTC {
419 type Target = rtc::RegisterBlock;
420 fn deref(&self) -> &Self::Target {
421 unsafe { &*RTC::ptr() }
422 }
423}
424#[doc = "Secure Real Time Clock"]
425pub mod rtc;
426#[doc = "12-Bit Digital-to-Analog Converter"]
427pub struct DAC0 {
428 _marker: PhantomData<*const ()>,
429}
430unsafe impl Send for DAC0 {}
431impl DAC0 {
432 #[doc = r"Returns a pointer to the register block"]
433 #[inline(always)]
434 pub const fn ptr() -> *const dac0::RegisterBlock {
435 0x4003_f000 as *const _
436 }
437}
438impl Deref for DAC0 {
439 type Target = dac0::RegisterBlock;
440 fn deref(&self) -> &Self::Target {
441 unsafe { &*DAC0::ptr() }
442 }
443}
444#[doc = "12-Bit Digital-to-Analog Converter"]
445pub mod dac0;
446#[doc = "Low Power Timer"]
447pub struct LPTMR0 {
448 _marker: PhantomData<*const ()>,
449}
450unsafe impl Send for LPTMR0 {}
451impl LPTMR0 {
452 #[doc = r"Returns a pointer to the register block"]
453 #[inline(always)]
454 pub const fn ptr() -> *const lptmr0::RegisterBlock {
455 0x4004_0000 as *const _
456 }
457}
458impl Deref for LPTMR0 {
459 type Target = lptmr0::RegisterBlock;
460 fn deref(&self) -> &Self::Target {
461 unsafe { &*LPTMR0::ptr() }
462 }
463}
464#[doc = "Low Power Timer"]
465pub mod lptmr0;
466#[doc = "Touch sense input"]
467pub struct TSI0 {
468 _marker: PhantomData<*const ()>,
469}
470unsafe impl Send for TSI0 {}
471impl TSI0 {
472 #[doc = r"Returns a pointer to the register block"]
473 #[inline(always)]
474 pub const fn ptr() -> *const tsi0::RegisterBlock {
475 0x4004_5000 as *const _
476 }
477}
478impl Deref for TSI0 {
479 type Target = tsi0::RegisterBlock;
480 fn deref(&self) -> &Self::Target {
481 unsafe { &*TSI0::ptr() }
482 }
483}
484#[doc = "Touch sense input"]
485pub mod tsi0;
486#[doc = "System Integration Module"]
487pub struct SIM {
488 _marker: PhantomData<*const ()>,
489}
490unsafe impl Send for SIM {}
491impl SIM {
492 #[doc = r"Returns a pointer to the register block"]
493 #[inline(always)]
494 pub const fn ptr() -> *const sim::RegisterBlock {
495 0x4004_7000 as *const _
496 }
497}
498impl Deref for SIM {
499 type Target = sim::RegisterBlock;
500 fn deref(&self) -> &Self::Target {
501 unsafe { &*SIM::ptr() }
502 }
503}
504#[doc = "System Integration Module"]
505pub mod sim;
506#[doc = "Pin Control and Interrupts"]
507pub struct PORTA {
508 _marker: PhantomData<*const ()>,
509}
510unsafe impl Send for PORTA {}
511impl PORTA {
512 #[doc = r"Returns a pointer to the register block"]
513 #[inline(always)]
514 pub const fn ptr() -> *const porta::RegisterBlock {
515 0x4004_9000 as *const _
516 }
517}
518impl Deref for PORTA {
519 type Target = porta::RegisterBlock;
520 fn deref(&self) -> &Self::Target {
521 unsafe { &*PORTA::ptr() }
522 }
523}
524#[doc = "Pin Control and Interrupts"]
525pub mod porta;
526#[doc = "Pin Control and Interrupts"]
527pub struct PORTB {
528 _marker: PhantomData<*const ()>,
529}
530unsafe impl Send for PORTB {}
531impl PORTB {
532 #[doc = r"Returns a pointer to the register block"]
533 #[inline(always)]
534 pub const fn ptr() -> *const portb::RegisterBlock {
535 0x4004_a000 as *const _
536 }
537}
538impl Deref for PORTB {
539 type Target = portb::RegisterBlock;
540 fn deref(&self) -> &Self::Target {
541 unsafe { &*PORTB::ptr() }
542 }
543}
544#[doc = "Pin Control and Interrupts"]
545pub mod portb;
546#[doc = "Pin Control and Interrupts"]
547pub struct PORTC {
548 _marker: PhantomData<*const ()>,
549}
550unsafe impl Send for PORTC {}
551impl PORTC {
552 #[doc = r"Returns a pointer to the register block"]
553 #[inline(always)]
554 pub const fn ptr() -> *const portc::RegisterBlock {
555 0x4004_b000 as *const _
556 }
557}
558impl Deref for PORTC {
559 type Target = portc::RegisterBlock;
560 fn deref(&self) -> &Self::Target {
561 unsafe { &*PORTC::ptr() }
562 }
563}
564#[doc = "Pin Control and Interrupts"]
565pub mod portc;
566#[doc = "Pin Control and Interrupts"]
567pub struct PORTD {
568 _marker: PhantomData<*const ()>,
569}
570unsafe impl Send for PORTD {}
571impl PORTD {
572 #[doc = r"Returns a pointer to the register block"]
573 #[inline(always)]
574 pub const fn ptr() -> *const portd::RegisterBlock {
575 0x4004_c000 as *const _
576 }
577}
578impl Deref for PORTD {
579 type Target = portd::RegisterBlock;
580 fn deref(&self) -> &Self::Target {
581 unsafe { &*PORTD::ptr() }
582 }
583}
584#[doc = "Pin Control and Interrupts"]
585pub mod portd;
586#[doc = "Pin Control and Interrupts"]
587pub struct PORTE {
588 _marker: PhantomData<*const ()>,
589}
590unsafe impl Send for PORTE {}
591impl PORTE {
592 #[doc = r"Returns a pointer to the register block"]
593 #[inline(always)]
594 pub const fn ptr() -> *const porte::RegisterBlock {
595 0x4004_d000 as *const _
596 }
597}
598impl Deref for PORTE {
599 type Target = porte::RegisterBlock;
600 fn deref(&self) -> &Self::Target {
601 unsafe { &*PORTE::ptr() }
602 }
603}
604#[doc = "Pin Control and Interrupts"]
605pub mod porte;
606#[doc = "Multipurpose Clock Generator module"]
607pub struct MCG {
608 _marker: PhantomData<*const ()>,
609}
610unsafe impl Send for MCG {}
611impl MCG {
612 #[doc = r"Returns a pointer to the register block"]
613 #[inline(always)]
614 pub const fn ptr() -> *const mcg::RegisterBlock {
615 0x4006_4000 as *const _
616 }
617}
618impl Deref for MCG {
619 type Target = mcg::RegisterBlock;
620 fn deref(&self) -> &Self::Target {
621 unsafe { &*MCG::ptr() }
622 }
623}
624#[doc = "Multipurpose Clock Generator module"]
625pub mod mcg;
626#[doc = "Oscillator"]
627pub struct OSC0 {
628 _marker: PhantomData<*const ()>,
629}
630unsafe impl Send for OSC0 {}
631impl OSC0 {
632 #[doc = r"Returns a pointer to the register block"]
633 #[inline(always)]
634 pub const fn ptr() -> *const osc0::RegisterBlock {
635 0x4006_5000 as *const _
636 }
637}
638impl Deref for OSC0 {
639 type Target = osc0::RegisterBlock;
640 fn deref(&self) -> &Self::Target {
641 unsafe { &*OSC0::ptr() }
642 }
643}
644#[doc = "Oscillator"]
645pub mod osc0;
646#[doc = "Inter-Integrated Circuit"]
647pub struct I2C0 {
648 _marker: PhantomData<*const ()>,
649}
650unsafe impl Send for I2C0 {}
651impl I2C0 {
652 #[doc = r"Returns a pointer to the register block"]
653 #[inline(always)]
654 pub const fn ptr() -> *const i2c0::RegisterBlock {
655 0x4006_6000 as *const _
656 }
657}
658impl Deref for I2C0 {
659 type Target = i2c0::RegisterBlock;
660 fn deref(&self) -> &Self::Target {
661 unsafe { &*I2C0::ptr() }
662 }
663}
664#[doc = "Inter-Integrated Circuit"]
665pub mod i2c0;
666#[doc = "Inter-Integrated Circuit"]
667pub struct I2C1 {
668 _marker: PhantomData<*const ()>,
669}
670unsafe impl Send for I2C1 {}
671impl I2C1 {
672 #[doc = r"Returns a pointer to the register block"]
673 #[inline(always)]
674 pub const fn ptr() -> *const i2c1::RegisterBlock {
675 0x4006_7000 as *const _
676 }
677}
678impl Deref for I2C1 {
679 type Target = i2c1::RegisterBlock;
680 fn deref(&self) -> &Self::Target {
681 unsafe { &*I2C1::ptr() }
682 }
683}
684#[doc = "Inter-Integrated Circuit"]
685pub mod i2c1;
686#[doc = "Universal Asynchronous Receiver/Transmitter"]
687pub struct UART0 {
688 _marker: PhantomData<*const ()>,
689}
690unsafe impl Send for UART0 {}
691impl UART0 {
692 #[doc = r"Returns a pointer to the register block"]
693 #[inline(always)]
694 pub const fn ptr() -> *const uart0::RegisterBlock {
695 0x4006_a000 as *const _
696 }
697}
698impl Deref for UART0 {
699 type Target = uart0::RegisterBlock;
700 fn deref(&self) -> &Self::Target {
701 unsafe { &*UART0::ptr() }
702 }
703}
704#[doc = "Universal Asynchronous Receiver/Transmitter"]
705pub mod uart0;
706#[doc = "Universal Asynchronous Receiver/Transmitter (UART)"]
707pub struct UART1 {
708 _marker: PhantomData<*const ()>,
709}
710unsafe impl Send for UART1 {}
711impl UART1 {
712 #[doc = r"Returns a pointer to the register block"]
713 #[inline(always)]
714 pub const fn ptr() -> *const uart1::RegisterBlock {
715 0x4006_b000 as *const _
716 }
717}
718impl Deref for UART1 {
719 type Target = uart1::RegisterBlock;
720 fn deref(&self) -> &Self::Target {
721 unsafe { &*UART1::ptr() }
722 }
723}
724#[doc = "Universal Asynchronous Receiver/Transmitter (UART)"]
725pub mod uart1;
726#[doc = "Universal Asynchronous Receiver/Transmitter (UART)"]
727pub struct UART2 {
728 _marker: PhantomData<*const ()>,
729}
730unsafe impl Send for UART2 {}
731impl UART2 {
732 #[doc = r"Returns a pointer to the register block"]
733 #[inline(always)]
734 pub const fn ptr() -> *const uart2::RegisterBlock {
735 0x4006_c000 as *const _
736 }
737}
738impl Deref for UART2 {
739 type Target = uart2::RegisterBlock;
740 fn deref(&self) -> &Self::Target {
741 unsafe { &*UART2::ptr() }
742 }
743}
744#[doc = "Universal Asynchronous Receiver/Transmitter (UART)"]
745pub mod uart2;
746#[doc = "Universal Serial Bus, OTG Capable Controller"]
747pub struct USB0 {
748 _marker: PhantomData<*const ()>,
749}
750unsafe impl Send for USB0 {}
751impl USB0 {
752 #[doc = r"Returns a pointer to the register block"]
753 #[inline(always)]
754 pub const fn ptr() -> *const usb0::RegisterBlock {
755 0x4007_2000 as *const _
756 }
757}
758impl Deref for USB0 {
759 type Target = usb0::RegisterBlock;
760 fn deref(&self) -> &Self::Target {
761 unsafe { &*USB0::ptr() }
762 }
763}
764#[doc = "Universal Serial Bus, OTG Capable Controller"]
765pub mod usb0;
766#[doc = "High-Speed Comparator (CMP), Voltage Reference (VREF) Digital-to-Analog Converter (DAC), and Analog Mux (ANMUX)"]
767pub struct CMP0 {
768 _marker: PhantomData<*const ()>,
769}
770unsafe impl Send for CMP0 {}
771impl CMP0 {
772 #[doc = r"Returns a pointer to the register block"]
773 #[inline(always)]
774 pub const fn ptr() -> *const cmp0::RegisterBlock {
775 0x4007_3000 as *const _
776 }
777}
778impl Deref for CMP0 {
779 type Target = cmp0::RegisterBlock;
780 fn deref(&self) -> &Self::Target {
781 unsafe { &*CMP0::ptr() }
782 }
783}
784#[doc = "High-Speed Comparator (CMP), Voltage Reference (VREF) Digital-to-Analog Converter (DAC), and Analog Mux (ANMUX)"]
785pub mod cmp0;
786#[doc = "Serial Peripheral Interface"]
787pub struct SPI0 {
788 _marker: PhantomData<*const ()>,
789}
790unsafe impl Send for SPI0 {}
791impl SPI0 {
792 #[doc = r"Returns a pointer to the register block"]
793 #[inline(always)]
794 pub const fn ptr() -> *const spi0::RegisterBlock {
795 0x4007_6000 as *const _
796 }
797}
798impl Deref for SPI0 {
799 type Target = spi0::RegisterBlock;
800 fn deref(&self) -> &Self::Target {
801 unsafe { &*SPI0::ptr() }
802 }
803}
804#[doc = "Serial Peripheral Interface"]
805pub mod spi0;
806#[doc = "Serial Peripheral Interface"]
807pub struct SPI1 {
808 _marker: PhantomData<*const ()>,
809}
810unsafe impl Send for SPI1 {}
811impl SPI1 {
812 #[doc = r"Returns a pointer to the register block"]
813 #[inline(always)]
814 pub const fn ptr() -> *const spi1::RegisterBlock {
815 0x4007_7000 as *const _
816 }
817}
818impl Deref for SPI1 {
819 type Target = spi1::RegisterBlock;
820 fn deref(&self) -> &Self::Target {
821 unsafe { &*SPI1::ptr() }
822 }
823}
824#[doc = "Serial Peripheral Interface"]
825pub mod spi1;
826#[doc = "Low leakage wakeup unit"]
827pub struct LLWU {
828 _marker: PhantomData<*const ()>,
829}
830unsafe impl Send for LLWU {}
831impl LLWU {
832 #[doc = r"Returns a pointer to the register block"]
833 #[inline(always)]
834 pub const fn ptr() -> *const llwu::RegisterBlock {
835 0x4007_c000 as *const _
836 }
837}
838impl Deref for LLWU {
839 type Target = llwu::RegisterBlock;
840 fn deref(&self) -> &Self::Target {
841 unsafe { &*LLWU::ptr() }
842 }
843}
844#[doc = "Low leakage wakeup unit"]
845pub mod llwu;
846#[doc = "Power Management Controller"]
847pub struct PMC {
848 _marker: PhantomData<*const ()>,
849}
850unsafe impl Send for PMC {}
851impl PMC {
852 #[doc = r"Returns a pointer to the register block"]
853 #[inline(always)]
854 pub const fn ptr() -> *const pmc::RegisterBlock {
855 0x4007_d000 as *const _
856 }
857}
858impl Deref for PMC {
859 type Target = pmc::RegisterBlock;
860 fn deref(&self) -> &Self::Target {
861 unsafe { &*PMC::ptr() }
862 }
863}
864#[doc = "Power Management Controller"]
865pub mod pmc;
866#[doc = "System Mode Controller"]
867pub struct SMC {
868 _marker: PhantomData<*const ()>,
869}
870unsafe impl Send for SMC {}
871impl SMC {
872 #[doc = r"Returns a pointer to the register block"]
873 #[inline(always)]
874 pub const fn ptr() -> *const smc::RegisterBlock {
875 0x4007_e000 as *const _
876 }
877}
878impl Deref for SMC {
879 type Target = smc::RegisterBlock;
880 fn deref(&self) -> &Self::Target {
881 unsafe { &*SMC::ptr() }
882 }
883}
884#[doc = "System Mode Controller"]
885pub mod smc;
886#[doc = "Reset Control Module"]
887pub struct RCM {
888 _marker: PhantomData<*const ()>,
889}
890unsafe impl Send for RCM {}
891impl RCM {
892 #[doc = r"Returns a pointer to the register block"]
893 #[inline(always)]
894 pub const fn ptr() -> *const rcm::RegisterBlock {
895 0x4007_f000 as *const _
896 }
897}
898impl Deref for RCM {
899 type Target = rcm::RegisterBlock;
900 fn deref(&self) -> &Self::Target {
901 unsafe { &*RCM::ptr() }
902 }
903}
904#[doc = "Reset Control Module"]
905pub mod rcm;
906#[doc = "General Purpose Input/Output"]
907pub struct GPIOA {
908 _marker: PhantomData<*const ()>,
909}
910unsafe impl Send for GPIOA {}
911impl GPIOA {
912 #[doc = r"Returns a pointer to the register block"]
913 #[inline(always)]
914 pub const fn ptr() -> *const gpioa::RegisterBlock {
915 0x400f_f000 as *const _
916 }
917}
918impl Deref for GPIOA {
919 type Target = gpioa::RegisterBlock;
920 fn deref(&self) -> &Self::Target {
921 unsafe { &*GPIOA::ptr() }
922 }
923}
924#[doc = "General Purpose Input/Output"]
925pub mod gpioa;
926#[doc = "General Purpose Input/Output"]
927pub struct GPIOB {
928 _marker: PhantomData<*const ()>,
929}
930unsafe impl Send for GPIOB {}
931impl GPIOB {
932 #[doc = r"Returns a pointer to the register block"]
933 #[inline(always)]
934 pub const fn ptr() -> *const gpiob::RegisterBlock {
935 0x400f_f040 as *const _
936 }
937}
938impl Deref for GPIOB {
939 type Target = gpiob::RegisterBlock;
940 fn deref(&self) -> &Self::Target {
941 unsafe { &*GPIOB::ptr() }
942 }
943}
944#[doc = "General Purpose Input/Output"]
945pub mod gpiob;
946#[doc = "General Purpose Input/Output"]
947pub struct GPIOC {
948 _marker: PhantomData<*const ()>,
949}
950unsafe impl Send for GPIOC {}
951impl GPIOC {
952 #[doc = r"Returns a pointer to the register block"]
953 #[inline(always)]
954 pub const fn ptr() -> *const gpioc::RegisterBlock {
955 0x400f_f080 as *const _
956 }
957}
958impl Deref for GPIOC {
959 type Target = gpioc::RegisterBlock;
960 fn deref(&self) -> &Self::Target {
961 unsafe { &*GPIOC::ptr() }
962 }
963}
964#[doc = "General Purpose Input/Output"]
965pub mod gpioc;
966#[doc = "General Purpose Input/Output"]
967pub struct GPIOD {
968 _marker: PhantomData<*const ()>,
969}
970unsafe impl Send for GPIOD {}
971impl GPIOD {
972 #[doc = r"Returns a pointer to the register block"]
973 #[inline(always)]
974 pub const fn ptr() -> *const gpiod::RegisterBlock {
975 0x400f_f0c0 as *const _
976 }
977}
978impl Deref for GPIOD {
979 type Target = gpiod::RegisterBlock;
980 fn deref(&self) -> &Self::Target {
981 unsafe { &*GPIOD::ptr() }
982 }
983}
984#[doc = "General Purpose Input/Output"]
985pub mod gpiod;
986#[doc = "General Purpose Input/Output"]
987pub struct GPIOE {
988 _marker: PhantomData<*const ()>,
989}
990unsafe impl Send for GPIOE {}
991impl GPIOE {
992 #[doc = r"Returns a pointer to the register block"]
993 #[inline(always)]
994 pub const fn ptr() -> *const gpioe::RegisterBlock {
995 0x400f_f100 as *const _
996 }
997}
998impl Deref for GPIOE {
999 type Target = gpioe::RegisterBlock;
1000 fn deref(&self) -> &Self::Target {
1001 unsafe { &*GPIOE::ptr() }
1002 }
1003}
1004#[doc = "General Purpose Input/Output"]
1005pub mod gpioe;
1006#[doc = "Micro Trace Buffer"]
1007pub struct MTB {
1008 _marker: PhantomData<*const ()>,
1009}
1010unsafe impl Send for MTB {}
1011impl MTB {
1012 #[doc = r"Returns a pointer to the register block"]
1013 #[inline(always)]
1014 pub const fn ptr() -> *const mtb::RegisterBlock {
1015 0xf000_0000 as *const _
1016 }
1017}
1018impl Deref for MTB {
1019 type Target = mtb::RegisterBlock;
1020 fn deref(&self) -> &Self::Target {
1021 unsafe { &*MTB::ptr() }
1022 }
1023}
1024#[doc = "Micro Trace Buffer"]
1025pub mod mtb;
1026#[doc = "MTB data watchpoint and trace"]
1027pub struct MTBDWT {
1028 _marker: PhantomData<*const ()>,
1029}
1030unsafe impl Send for MTBDWT {}
1031impl MTBDWT {
1032 #[doc = r"Returns a pointer to the register block"]
1033 #[inline(always)]
1034 pub const fn ptr() -> *const mtbdwt::RegisterBlock {
1035 0xf000_1000 as *const _
1036 }
1037}
1038impl Deref for MTBDWT {
1039 type Target = mtbdwt::RegisterBlock;
1040 fn deref(&self) -> &Self::Target {
1041 unsafe { &*MTBDWT::ptr() }
1042 }
1043}
1044#[doc = "MTB data watchpoint and trace"]
1045pub mod mtbdwt;
1046#[doc = "System ROM"]
1047pub struct ROM {
1048 _marker: PhantomData<*const ()>,
1049}
1050unsafe impl Send for ROM {}
1051impl ROM {
1052 #[doc = r"Returns a pointer to the register block"]
1053 #[inline(always)]
1054 pub const fn ptr() -> *const rom::RegisterBlock {
1055 0xf000_2000 as *const _
1056 }
1057}
1058impl Deref for ROM {
1059 type Target = rom::RegisterBlock;
1060 fn deref(&self) -> &Self::Target {
1061 unsafe { &*ROM::ptr() }
1062 }
1063}
1064#[doc = "System ROM"]
1065pub mod rom;
1066#[doc = "Core Platform Miscellaneous Control Module"]
1067pub struct MCM {
1068 _marker: PhantomData<*const ()>,
1069}
1070unsafe impl Send for MCM {}
1071impl MCM {
1072 #[doc = r"Returns a pointer to the register block"]
1073 #[inline(always)]
1074 pub const fn ptr() -> *const mcm::RegisterBlock {
1075 0xf000_3000 as *const _
1076 }
1077}
1078impl Deref for MCM {
1079 type Target = mcm::RegisterBlock;
1080 fn deref(&self) -> &Self::Target {
1081 unsafe { &*MCM::ptr() }
1082 }
1083}
1084#[doc = "Core Platform Miscellaneous Control Module"]
1085pub mod mcm;
1086#[doc = "General Purpose Input/Output"]
1087pub struct FGPIOA {
1088 _marker: PhantomData<*const ()>,
1089}
1090unsafe impl Send for FGPIOA {}
1091impl FGPIOA {
1092 #[doc = r"Returns a pointer to the register block"]
1093 #[inline(always)]
1094 pub const fn ptr() -> *const fgpioa::RegisterBlock {
1095 0xf800_0000 as *const _
1096 }
1097}
1098impl Deref for FGPIOA {
1099 type Target = fgpioa::RegisterBlock;
1100 fn deref(&self) -> &Self::Target {
1101 unsafe { &*FGPIOA::ptr() }
1102 }
1103}
1104#[doc = "General Purpose Input/Output"]
1105pub mod fgpioa;
1106#[doc = "General Purpose Input/Output"]
1107pub struct FGPIOB {
1108 _marker: PhantomData<*const ()>,
1109}
1110unsafe impl Send for FGPIOB {}
1111impl FGPIOB {
1112 #[doc = r"Returns a pointer to the register block"]
1113 #[inline(always)]
1114 pub const fn ptr() -> *const fgpiob::RegisterBlock {
1115 0xf800_0040 as *const _
1116 }
1117}
1118impl Deref for FGPIOB {
1119 type Target = fgpiob::RegisterBlock;
1120 fn deref(&self) -> &Self::Target {
1121 unsafe { &*FGPIOB::ptr() }
1122 }
1123}
1124#[doc = "General Purpose Input/Output"]
1125pub mod fgpiob;
1126#[doc = "General Purpose Input/Output"]
1127pub struct FGPIOC {
1128 _marker: PhantomData<*const ()>,
1129}
1130unsafe impl Send for FGPIOC {}
1131impl FGPIOC {
1132 #[doc = r"Returns a pointer to the register block"]
1133 #[inline(always)]
1134 pub const fn ptr() -> *const fgpioc::RegisterBlock {
1135 0xf800_0080 as *const _
1136 }
1137}
1138impl Deref for FGPIOC {
1139 type Target = fgpioc::RegisterBlock;
1140 fn deref(&self) -> &Self::Target {
1141 unsafe { &*FGPIOC::ptr() }
1142 }
1143}
1144#[doc = "General Purpose Input/Output"]
1145pub mod fgpioc;
1146#[doc = "General Purpose Input/Output"]
1147pub struct FGPIOD {
1148 _marker: PhantomData<*const ()>,
1149}
1150unsafe impl Send for FGPIOD {}
1151impl FGPIOD {
1152 #[doc = r"Returns a pointer to the register block"]
1153 #[inline(always)]
1154 pub const fn ptr() -> *const fgpiod::RegisterBlock {
1155 0xf800_00c0 as *const _
1156 }
1157}
1158impl Deref for FGPIOD {
1159 type Target = fgpiod::RegisterBlock;
1160 fn deref(&self) -> &Self::Target {
1161 unsafe { &*FGPIOD::ptr() }
1162 }
1163}
1164#[doc = "General Purpose Input/Output"]
1165pub mod fgpiod;
1166#[doc = "General Purpose Input/Output"]
1167pub struct FGPIOE {
1168 _marker: PhantomData<*const ()>,
1169}
1170unsafe impl Send for FGPIOE {}
1171impl FGPIOE {
1172 #[doc = r"Returns a pointer to the register block"]
1173 #[inline(always)]
1174 pub const fn ptr() -> *const fgpioe::RegisterBlock {
1175 0xf800_0100 as *const _
1176 }
1177}
1178impl Deref for FGPIOE {
1179 type Target = fgpioe::RegisterBlock;
1180 fn deref(&self) -> &Self::Target {
1181 unsafe { &*FGPIOE::ptr() }
1182 }
1183}
1184#[doc = "General Purpose Input/Output"]
1185pub mod fgpioe;
1186#[no_mangle]
1187static mut DEVICE_PERIPHERALS: bool = false;
1188#[doc = r"All the peripherals"]
1189#[allow(non_snake_case)]
1190pub struct Peripherals {
1191 #[doc = "FTFA_FLASHCONFIG"]
1192 pub FTFA_FLASHCONFIG: FTFA_FLASHCONFIG,
1193 #[doc = "DMA"]
1194 pub DMA: DMA,
1195 #[doc = "FTFA"]
1196 pub FTFA: FTFA,
1197 #[doc = "DMAMUX0"]
1198 pub DMAMUX0: DMAMUX0,
1199 #[doc = "I2S0"]
1200 pub I2S0: I2S0,
1201 #[doc = "PIT"]
1202 pub PIT: PIT,
1203 #[doc = "TPM0"]
1204 pub TPM0: TPM0,
1205 #[doc = "TPM1"]
1206 pub TPM1: TPM1,
1207 #[doc = "TPM2"]
1208 pub TPM2: TPM2,
1209 #[doc = "ADC0"]
1210 pub ADC0: ADC0,
1211 #[doc = "RTC"]
1212 pub RTC: RTC,
1213 #[doc = "DAC0"]
1214 pub DAC0: DAC0,
1215 #[doc = "LPTMR0"]
1216 pub LPTMR0: LPTMR0,
1217 #[doc = "TSI0"]
1218 pub TSI0: TSI0,
1219 #[doc = "SIM"]
1220 pub SIM: SIM,
1221 #[doc = "PORTA"]
1222 pub PORTA: PORTA,
1223 #[doc = "PORTB"]
1224 pub PORTB: PORTB,
1225 #[doc = "PORTC"]
1226 pub PORTC: PORTC,
1227 #[doc = "PORTD"]
1228 pub PORTD: PORTD,
1229 #[doc = "PORTE"]
1230 pub PORTE: PORTE,
1231 #[doc = "MCG"]
1232 pub MCG: MCG,
1233 #[doc = "OSC0"]
1234 pub OSC0: OSC0,
1235 #[doc = "I2C0"]
1236 pub I2C0: I2C0,
1237 #[doc = "I2C1"]
1238 pub I2C1: I2C1,
1239 #[doc = "UART0"]
1240 pub UART0: UART0,
1241 #[doc = "UART1"]
1242 pub UART1: UART1,
1243 #[doc = "UART2"]
1244 pub UART2: UART2,
1245 #[doc = "USB0"]
1246 pub USB0: USB0,
1247 #[doc = "CMP0"]
1248 pub CMP0: CMP0,
1249 #[doc = "SPI0"]
1250 pub SPI0: SPI0,
1251 #[doc = "SPI1"]
1252 pub SPI1: SPI1,
1253 #[doc = "LLWU"]
1254 pub LLWU: LLWU,
1255 #[doc = "PMC"]
1256 pub PMC: PMC,
1257 #[doc = "SMC"]
1258 pub SMC: SMC,
1259 #[doc = "RCM"]
1260 pub RCM: RCM,
1261 #[doc = "GPIOA"]
1262 pub GPIOA: GPIOA,
1263 #[doc = "GPIOB"]
1264 pub GPIOB: GPIOB,
1265 #[doc = "GPIOC"]
1266 pub GPIOC: GPIOC,
1267 #[doc = "GPIOD"]
1268 pub GPIOD: GPIOD,
1269 #[doc = "GPIOE"]
1270 pub GPIOE: GPIOE,
1271 #[doc = "MTB"]
1272 pub MTB: MTB,
1273 #[doc = "MTBDWT"]
1274 pub MTBDWT: MTBDWT,
1275 #[doc = "ROM"]
1276 pub ROM: ROM,
1277 #[doc = "MCM"]
1278 pub MCM: MCM,
1279 #[doc = "FGPIOA"]
1280 pub FGPIOA: FGPIOA,
1281 #[doc = "FGPIOB"]
1282 pub FGPIOB: FGPIOB,
1283 #[doc = "FGPIOC"]
1284 pub FGPIOC: FGPIOC,
1285 #[doc = "FGPIOD"]
1286 pub FGPIOD: FGPIOD,
1287 #[doc = "FGPIOE"]
1288 pub FGPIOE: FGPIOE,
1289}
1290impl Peripherals {
1291 #[doc = r"Returns all the peripherals *once*"]
1292 #[inline]
1293 pub fn take() -> Option<Self> {
1294 cortex_m::interrupt::free(|_| {
1295 if unsafe { DEVICE_PERIPHERALS } {
1296 None
1297 } else {
1298 Some(unsafe { Peripherals::steal() })
1299 }
1300 })
1301 }
1302 #[doc = r"Unchecked version of `Peripherals::take`"]
1303 pub unsafe fn steal() -> Self {
1304 DEVICE_PERIPHERALS = true;
1305 Peripherals {
1306 FTFA_FLASHCONFIG: FTFA_FLASHCONFIG {
1307 _marker: PhantomData,
1308 },
1309 DMA: DMA {
1310 _marker: PhantomData,
1311 },
1312 FTFA: FTFA {
1313 _marker: PhantomData,
1314 },
1315 DMAMUX0: DMAMUX0 {
1316 _marker: PhantomData,
1317 },
1318 I2S0: I2S0 {
1319 _marker: PhantomData,
1320 },
1321 PIT: PIT {
1322 _marker: PhantomData,
1323 },
1324 TPM0: TPM0 {
1325 _marker: PhantomData,
1326 },
1327 TPM1: TPM1 {
1328 _marker: PhantomData,
1329 },
1330 TPM2: TPM2 {
1331 _marker: PhantomData,
1332 },
1333 ADC0: ADC0 {
1334 _marker: PhantomData,
1335 },
1336 RTC: RTC {
1337 _marker: PhantomData,
1338 },
1339 DAC0: DAC0 {
1340 _marker: PhantomData,
1341 },
1342 LPTMR0: LPTMR0 {
1343 _marker: PhantomData,
1344 },
1345 TSI0: TSI0 {
1346 _marker: PhantomData,
1347 },
1348 SIM: SIM {
1349 _marker: PhantomData,
1350 },
1351 PORTA: PORTA {
1352 _marker: PhantomData,
1353 },
1354 PORTB: PORTB {
1355 _marker: PhantomData,
1356 },
1357 PORTC: PORTC {
1358 _marker: PhantomData,
1359 },
1360 PORTD: PORTD {
1361 _marker: PhantomData,
1362 },
1363 PORTE: PORTE {
1364 _marker: PhantomData,
1365 },
1366 MCG: MCG {
1367 _marker: PhantomData,
1368 },
1369 OSC0: OSC0 {
1370 _marker: PhantomData,
1371 },
1372 I2C0: I2C0 {
1373 _marker: PhantomData,
1374 },
1375 I2C1: I2C1 {
1376 _marker: PhantomData,
1377 },
1378 UART0: UART0 {
1379 _marker: PhantomData,
1380 },
1381 UART1: UART1 {
1382 _marker: PhantomData,
1383 },
1384 UART2: UART2 {
1385 _marker: PhantomData,
1386 },
1387 USB0: USB0 {
1388 _marker: PhantomData,
1389 },
1390 CMP0: CMP0 {
1391 _marker: PhantomData,
1392 },
1393 SPI0: SPI0 {
1394 _marker: PhantomData,
1395 },
1396 SPI1: SPI1 {
1397 _marker: PhantomData,
1398 },
1399 LLWU: LLWU {
1400 _marker: PhantomData,
1401 },
1402 PMC: PMC {
1403 _marker: PhantomData,
1404 },
1405 SMC: SMC {
1406 _marker: PhantomData,
1407 },
1408 RCM: RCM {
1409 _marker: PhantomData,
1410 },
1411 GPIOA: GPIOA {
1412 _marker: PhantomData,
1413 },
1414 GPIOB: GPIOB {
1415 _marker: PhantomData,
1416 },
1417 GPIOC: GPIOC {
1418 _marker: PhantomData,
1419 },
1420 GPIOD: GPIOD {
1421 _marker: PhantomData,
1422 },
1423 GPIOE: GPIOE {
1424 _marker: PhantomData,
1425 },
1426 MTB: MTB {
1427 _marker: PhantomData,
1428 },
1429 MTBDWT: MTBDWT {
1430 _marker: PhantomData,
1431 },
1432 ROM: ROM {
1433 _marker: PhantomData,
1434 },
1435 MCM: MCM {
1436 _marker: PhantomData,
1437 },
1438 FGPIOA: FGPIOA {
1439 _marker: PhantomData,
1440 },
1441 FGPIOB: FGPIOB {
1442 _marker: PhantomData,
1443 },
1444 FGPIOC: FGPIOC {
1445 _marker: PhantomData,
1446 },
1447 FGPIOD: FGPIOD {
1448 _marker: PhantomData,
1449 },
1450 FGPIOE: FGPIOE {
1451 _marker: PhantomData,
1452 },
1453 }
1454 }
1455}