s32k142w_pac/
lib.rs

1#![doc = "Peripheral access API for S32K142W microcontrollers (generated using svd2rust v0.21.0 ( ))\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.21.0/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 = 4;
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#[doc(hidden)]
38pub union Vector {
39    _handler: unsafe extern "C" fn(),
40    _reserved: u32,
41}
42#[cfg(feature = "rt")]
43#[doc(hidden)]
44#[link_section = ".vector_table.interrupts"]
45#[no_mangle]
46pub static __INTERRUPTS: [Vector; 0] = [];
47#[doc = r"Enumeration of all the interrupts."]
48#[derive(Copy, Clone, Debug, PartialEq, Eq)]
49pub enum Interrupt {}
50unsafe impl cortex_m::interrupt::InterruptNumber for Interrupt {
51    #[inline(always)]
52    fn number(self) -> u16 {
53        match self {}
54    }
55}
56#[doc = "AIPS"]
57pub struct AIPS {
58    _marker: PhantomData<*const ()>,
59}
60unsafe impl Send for AIPS {}
61impl AIPS {
62    #[doc = r"Pointer to the register block"]
63    pub const PTR: *const aips::RegisterBlock = 0x4000_0000 as *const _;
64    #[doc = r"Return the pointer to the register block"]
65    #[inline(always)]
66    pub const fn ptr() -> *const aips::RegisterBlock {
67        Self::PTR
68    }
69}
70impl Deref for AIPS {
71    type Target = aips::RegisterBlock;
72    #[inline(always)]
73    fn deref(&self) -> &Self::Target {
74        unsafe { &*Self::PTR }
75    }
76}
77impl core::fmt::Debug for AIPS {
78    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
79        f.debug_struct("AIPS").finish()
80    }
81}
82#[doc = "AIPS"]
83pub mod aips;
84#[doc = "MSCM"]
85pub struct MSCM {
86    _marker: PhantomData<*const ()>,
87}
88unsafe impl Send for MSCM {}
89impl MSCM {
90    #[doc = r"Pointer to the register block"]
91    pub const PTR: *const mscm::RegisterBlock = 0x4000_1000 as *const _;
92    #[doc = r"Return the pointer to the register block"]
93    #[inline(always)]
94    pub const fn ptr() -> *const mscm::RegisterBlock {
95        Self::PTR
96    }
97}
98impl Deref for MSCM {
99    type Target = mscm::RegisterBlock;
100    #[inline(always)]
101    fn deref(&self) -> &Self::Target {
102        unsafe { &*Self::PTR }
103    }
104}
105impl core::fmt::Debug for MSCM {
106    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
107        f.debug_struct("MSCM").finish()
108    }
109}
110#[doc = "MSCM"]
111pub mod mscm;
112#[doc = "DMA"]
113pub struct DMA {
114    _marker: PhantomData<*const ()>,
115}
116unsafe impl Send for DMA {}
117impl DMA {
118    #[doc = r"Pointer to the register block"]
119    pub const PTR: *const dma::RegisterBlock = 0x4000_8000 as *const _;
120    #[doc = r"Return the pointer to the register block"]
121    #[inline(always)]
122    pub const fn ptr() -> *const dma::RegisterBlock {
123        Self::PTR
124    }
125}
126impl Deref for DMA {
127    type Target = dma::RegisterBlock;
128    #[inline(always)]
129    fn deref(&self) -> &Self::Target {
130        unsafe { &*Self::PTR }
131    }
132}
133impl core::fmt::Debug for DMA {
134    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
135        f.debug_struct("DMA").finish()
136    }
137}
138#[doc = "DMA"]
139pub mod dma;
140#[doc = "ERM"]
141pub struct ERM {
142    _marker: PhantomData<*const ()>,
143}
144unsafe impl Send for ERM {}
145impl ERM {
146    #[doc = r"Pointer to the register block"]
147    pub const PTR: *const erm::RegisterBlock = 0x4001_8000 as *const _;
148    #[doc = r"Return the pointer to the register block"]
149    #[inline(always)]
150    pub const fn ptr() -> *const erm::RegisterBlock {
151        Self::PTR
152    }
153}
154impl Deref for ERM {
155    type Target = erm::RegisterBlock;
156    #[inline(always)]
157    fn deref(&self) -> &Self::Target {
158        unsafe { &*Self::PTR }
159    }
160}
161impl core::fmt::Debug for ERM {
162    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
163        f.debug_struct("ERM").finish()
164    }
165}
166#[doc = "ERM"]
167pub mod erm;
168#[doc = "EIM"]
169pub struct EIM {
170    _marker: PhantomData<*const ()>,
171}
172unsafe impl Send for EIM {}
173impl EIM {
174    #[doc = r"Pointer to the register block"]
175    pub const PTR: *const eim::RegisterBlock = 0x4001_9000 as *const _;
176    #[doc = r"Return the pointer to the register block"]
177    #[inline(always)]
178    pub const fn ptr() -> *const eim::RegisterBlock {
179        Self::PTR
180    }
181}
182impl Deref for EIM {
183    type Target = eim::RegisterBlock;
184    #[inline(always)]
185    fn deref(&self) -> &Self::Target {
186        unsafe { &*Self::PTR }
187    }
188}
189impl core::fmt::Debug for EIM {
190    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
191        f.debug_struct("EIM").finish()
192    }
193}
194#[doc = "EIM"]
195pub mod eim;
196#[doc = "FTFM"]
197pub struct FTFM {
198    _marker: PhantomData<*const ()>,
199}
200unsafe impl Send for FTFM {}
201impl FTFM {
202    #[doc = r"Pointer to the register block"]
203    pub const PTR: *const ftfm::RegisterBlock = 0x4002_0000 as *const _;
204    #[doc = r"Return the pointer to the register block"]
205    #[inline(always)]
206    pub const fn ptr() -> *const ftfm::RegisterBlock {
207        Self::PTR
208    }
209}
210impl Deref for FTFM {
211    type Target = ftfm::RegisterBlock;
212    #[inline(always)]
213    fn deref(&self) -> &Self::Target {
214        unsafe { &*Self::PTR }
215    }
216}
217impl core::fmt::Debug for FTFM {
218    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
219        f.debug_struct("FTFM").finish()
220    }
221}
222#[doc = "FTFM"]
223pub mod ftfm;
224#[doc = "DMAMUX"]
225pub struct DMAMUX {
226    _marker: PhantomData<*const ()>,
227}
228unsafe impl Send for DMAMUX {}
229impl DMAMUX {
230    #[doc = r"Pointer to the register block"]
231    pub const PTR: *const dmamux::RegisterBlock = 0x4002_1000 as *const _;
232    #[doc = r"Return the pointer to the register block"]
233    #[inline(always)]
234    pub const fn ptr() -> *const dmamux::RegisterBlock {
235        Self::PTR
236    }
237}
238impl Deref for DMAMUX {
239    type Target = dmamux::RegisterBlock;
240    #[inline(always)]
241    fn deref(&self) -> &Self::Target {
242        unsafe { &*Self::PTR }
243    }
244}
245impl core::fmt::Debug for DMAMUX {
246    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
247        f.debug_struct("DMAMUX").finish()
248    }
249}
250#[doc = "DMAMUX"]
251pub mod dmamux;
252#[doc = "CAN"]
253pub struct CAN0 {
254    _marker: PhantomData<*const ()>,
255}
256unsafe impl Send for CAN0 {}
257impl CAN0 {
258    #[doc = r"Pointer to the register block"]
259    pub const PTR: *const can0::RegisterBlock = 0x4002_4000 as *const _;
260    #[doc = r"Return the pointer to the register block"]
261    #[inline(always)]
262    pub const fn ptr() -> *const can0::RegisterBlock {
263        Self::PTR
264    }
265}
266impl Deref for CAN0 {
267    type Target = can0::RegisterBlock;
268    #[inline(always)]
269    fn deref(&self) -> &Self::Target {
270        unsafe { &*Self::PTR }
271    }
272}
273impl core::fmt::Debug for CAN0 {
274    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
275        f.debug_struct("CAN0").finish()
276    }
277}
278#[doc = "CAN"]
279pub mod can0;
280#[doc = "CAN"]
281pub struct CAN1 {
282    _marker: PhantomData<*const ()>,
283}
284unsafe impl Send for CAN1 {}
285impl CAN1 {
286    #[doc = r"Pointer to the register block"]
287    pub const PTR: *const can1::RegisterBlock = 0x4002_5000 as *const _;
288    #[doc = r"Return the pointer to the register block"]
289    #[inline(always)]
290    pub const fn ptr() -> *const can1::RegisterBlock {
291        Self::PTR
292    }
293}
294impl Deref for CAN1 {
295    type Target = can1::RegisterBlock;
296    #[inline(always)]
297    fn deref(&self) -> &Self::Target {
298        unsafe { &*Self::PTR }
299    }
300}
301impl core::fmt::Debug for CAN1 {
302    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
303        f.debug_struct("CAN1").finish()
304    }
305}
306#[doc = "CAN"]
307pub mod can1;
308#[doc = "LPSPI"]
309pub struct LPSPI0 {
310    _marker: PhantomData<*const ()>,
311}
312unsafe impl Send for LPSPI0 {}
313impl LPSPI0 {
314    #[doc = r"Pointer to the register block"]
315    pub const PTR: *const lpspi0::RegisterBlock = 0x4002_c000 as *const _;
316    #[doc = r"Return the pointer to the register block"]
317    #[inline(always)]
318    pub const fn ptr() -> *const lpspi0::RegisterBlock {
319        Self::PTR
320    }
321}
322impl Deref for LPSPI0 {
323    type Target = lpspi0::RegisterBlock;
324    #[inline(always)]
325    fn deref(&self) -> &Self::Target {
326        unsafe { &*Self::PTR }
327    }
328}
329impl core::fmt::Debug for LPSPI0 {
330    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
331        f.debug_struct("LPSPI0").finish()
332    }
333}
334#[doc = "LPSPI"]
335pub mod lpspi0;
336#[doc = "LPSPI"]
337pub struct LPSPI1 {
338    _marker: PhantomData<*const ()>,
339}
340unsafe impl Send for LPSPI1 {}
341impl LPSPI1 {
342    #[doc = r"Pointer to the register block"]
343    pub const PTR: *const lpspi0::RegisterBlock = 0x4002_d000 as *const _;
344    #[doc = r"Return the pointer to the register block"]
345    #[inline(always)]
346    pub const fn ptr() -> *const lpspi0::RegisterBlock {
347        Self::PTR
348    }
349}
350impl Deref for LPSPI1 {
351    type Target = lpspi0::RegisterBlock;
352    #[inline(always)]
353    fn deref(&self) -> &Self::Target {
354        unsafe { &*Self::PTR }
355    }
356}
357impl core::fmt::Debug for LPSPI1 {
358    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
359        f.debug_struct("LPSPI1").finish()
360    }
361}
362#[doc = "LPSPI"]
363pub use lpspi0 as lpspi1;
364#[doc = "LPSPI"]
365pub struct LPSPI2 {
366    _marker: PhantomData<*const ()>,
367}
368unsafe impl Send for LPSPI2 {}
369impl LPSPI2 {
370    #[doc = r"Pointer to the register block"]
371    pub const PTR: *const lpspi0::RegisterBlock = 0x4002_e000 as *const _;
372    #[doc = r"Return the pointer to the register block"]
373    #[inline(always)]
374    pub const fn ptr() -> *const lpspi0::RegisterBlock {
375        Self::PTR
376    }
377}
378impl Deref for LPSPI2 {
379    type Target = lpspi0::RegisterBlock;
380    #[inline(always)]
381    fn deref(&self) -> &Self::Target {
382        unsafe { &*Self::PTR }
383    }
384}
385impl core::fmt::Debug for LPSPI2 {
386    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
387        f.debug_struct("LPSPI2").finish()
388    }
389}
390#[doc = "LPSPI"]
391pub use lpspi0 as lpspi2;
392#[doc = "CRC"]
393pub struct CRC {
394    _marker: PhantomData<*const ()>,
395}
396unsafe impl Send for CRC {}
397impl CRC {
398    #[doc = r"Pointer to the register block"]
399    pub const PTR: *const crc::RegisterBlock = 0x4003_2000 as *const _;
400    #[doc = r"Return the pointer to the register block"]
401    #[inline(always)]
402    pub const fn ptr() -> *const crc::RegisterBlock {
403        Self::PTR
404    }
405}
406impl Deref for CRC {
407    type Target = crc::RegisterBlock;
408    #[inline(always)]
409    fn deref(&self) -> &Self::Target {
410        unsafe { &*Self::PTR }
411    }
412}
413impl core::fmt::Debug for CRC {
414    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
415        f.debug_struct("CRC").finish()
416    }
417}
418#[doc = "CRC"]
419pub mod crc;
420#[doc = "Programmable Delay Block"]
421pub struct PDB0 {
422    _marker: PhantomData<*const ()>,
423}
424unsafe impl Send for PDB0 {}
425impl PDB0 {
426    #[doc = r"Pointer to the register block"]
427    pub const PTR: *const pdb0::RegisterBlock = 0x4003_6000 as *const _;
428    #[doc = r"Return the pointer to the register block"]
429    #[inline(always)]
430    pub const fn ptr() -> *const pdb0::RegisterBlock {
431        Self::PTR
432    }
433}
434impl Deref for PDB0 {
435    type Target = pdb0::RegisterBlock;
436    #[inline(always)]
437    fn deref(&self) -> &Self::Target {
438        unsafe { &*Self::PTR }
439    }
440}
441impl core::fmt::Debug for PDB0 {
442    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
443        f.debug_struct("PDB0").finish()
444    }
445}
446#[doc = "Programmable Delay Block"]
447pub mod pdb0;
448#[doc = "Programmable Delay Block"]
449pub struct PDB1 {
450    _marker: PhantomData<*const ()>,
451}
452unsafe impl Send for PDB1 {}
453impl PDB1 {
454    #[doc = r"Pointer to the register block"]
455    pub const PTR: *const pdb0::RegisterBlock = 0x4003_1000 as *const _;
456    #[doc = r"Return the pointer to the register block"]
457    #[inline(always)]
458    pub const fn ptr() -> *const pdb0::RegisterBlock {
459        Self::PTR
460    }
461}
462impl Deref for PDB1 {
463    type Target = pdb0::RegisterBlock;
464    #[inline(always)]
465    fn deref(&self) -> &Self::Target {
466        unsafe { &*Self::PTR }
467    }
468}
469impl core::fmt::Debug for PDB1 {
470    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
471        f.debug_struct("PDB1").finish()
472    }
473}
474#[doc = "Programmable Delay Block"]
475pub use pdb0 as pdb1;
476#[doc = "LPIT"]
477pub struct LPIT0 {
478    _marker: PhantomData<*const ()>,
479}
480unsafe impl Send for LPIT0 {}
481impl LPIT0 {
482    #[doc = r"Pointer to the register block"]
483    pub const PTR: *const lpit0::RegisterBlock = 0x4003_7000 as *const _;
484    #[doc = r"Return the pointer to the register block"]
485    #[inline(always)]
486    pub const fn ptr() -> *const lpit0::RegisterBlock {
487        Self::PTR
488    }
489}
490impl Deref for LPIT0 {
491    type Target = lpit0::RegisterBlock;
492    #[inline(always)]
493    fn deref(&self) -> &Self::Target {
494        unsafe { &*Self::PTR }
495    }
496}
497impl core::fmt::Debug for LPIT0 {
498    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
499        f.debug_struct("LPIT0").finish()
500    }
501}
502#[doc = "LPIT"]
503pub mod lpit0;
504#[doc = "FTM"]
505pub struct FTM0 {
506    _marker: PhantomData<*const ()>,
507}
508unsafe impl Send for FTM0 {}
509impl FTM0 {
510    #[doc = r"Pointer to the register block"]
511    pub const PTR: *const ftm0::RegisterBlock = 0x4003_8000 as *const _;
512    #[doc = r"Return the pointer to the register block"]
513    #[inline(always)]
514    pub const fn ptr() -> *const ftm0::RegisterBlock {
515        Self::PTR
516    }
517}
518impl Deref for FTM0 {
519    type Target = ftm0::RegisterBlock;
520    #[inline(always)]
521    fn deref(&self) -> &Self::Target {
522        unsafe { &*Self::PTR }
523    }
524}
525impl core::fmt::Debug for FTM0 {
526    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
527        f.debug_struct("FTM0").finish()
528    }
529}
530#[doc = "FTM"]
531pub mod ftm0;
532#[doc = "FTM"]
533pub struct FTM3 {
534    _marker: PhantomData<*const ()>,
535}
536unsafe impl Send for FTM3 {}
537impl FTM3 {
538    #[doc = r"Pointer to the register block"]
539    pub const PTR: *const ftm0::RegisterBlock = 0x4002_6000 as *const _;
540    #[doc = r"Return the pointer to the register block"]
541    #[inline(always)]
542    pub const fn ptr() -> *const ftm0::RegisterBlock {
543        Self::PTR
544    }
545}
546impl Deref for FTM3 {
547    type Target = ftm0::RegisterBlock;
548    #[inline(always)]
549    fn deref(&self) -> &Self::Target {
550        unsafe { &*Self::PTR }
551    }
552}
553impl core::fmt::Debug for FTM3 {
554    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
555        f.debug_struct("FTM3").finish()
556    }
557}
558#[doc = "FTM"]
559pub use ftm0 as ftm3;
560#[doc = "FTM"]
561pub struct FTM1 {
562    _marker: PhantomData<*const ()>,
563}
564unsafe impl Send for FTM1 {}
565impl FTM1 {
566    #[doc = r"Pointer to the register block"]
567    pub const PTR: *const ftm1::RegisterBlock = 0x4003_9000 as *const _;
568    #[doc = r"Return the pointer to the register block"]
569    #[inline(always)]
570    pub const fn ptr() -> *const ftm1::RegisterBlock {
571        Self::PTR
572    }
573}
574impl Deref for FTM1 {
575    type Target = ftm1::RegisterBlock;
576    #[inline(always)]
577    fn deref(&self) -> &Self::Target {
578        unsafe { &*Self::PTR }
579    }
580}
581impl core::fmt::Debug for FTM1 {
582    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
583        f.debug_struct("FTM1").finish()
584    }
585}
586#[doc = "FTM"]
587pub mod ftm1;
588#[doc = "FTM"]
589pub struct FTM2 {
590    _marker: PhantomData<*const ()>,
591}
592unsafe impl Send for FTM2 {}
593impl FTM2 {
594    #[doc = r"Pointer to the register block"]
595    pub const PTR: *const ftm1::RegisterBlock = 0x4003_a000 as *const _;
596    #[doc = r"Return the pointer to the register block"]
597    #[inline(always)]
598    pub const fn ptr() -> *const ftm1::RegisterBlock {
599        Self::PTR
600    }
601}
602impl Deref for FTM2 {
603    type Target = ftm1::RegisterBlock;
604    #[inline(always)]
605    fn deref(&self) -> &Self::Target {
606        unsafe { &*Self::PTR }
607    }
608}
609impl core::fmt::Debug for FTM2 {
610    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
611        f.debug_struct("FTM2").finish()
612    }
613}
614#[doc = "FTM"]
615pub use ftm1 as ftm2;
616#[doc = "ADC"]
617pub struct ADC0 {
618    _marker: PhantomData<*const ()>,
619}
620unsafe impl Send for ADC0 {}
621impl ADC0 {
622    #[doc = r"Pointer to the register block"]
623    pub const PTR: *const adc0::RegisterBlock = 0x4003_b000 as *const _;
624    #[doc = r"Return the pointer to the register block"]
625    #[inline(always)]
626    pub const fn ptr() -> *const adc0::RegisterBlock {
627        Self::PTR
628    }
629}
630impl Deref for ADC0 {
631    type Target = adc0::RegisterBlock;
632    #[inline(always)]
633    fn deref(&self) -> &Self::Target {
634        unsafe { &*Self::PTR }
635    }
636}
637impl core::fmt::Debug for ADC0 {
638    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
639        f.debug_struct("ADC0").finish()
640    }
641}
642#[doc = "ADC"]
643pub mod adc0;
644#[doc = "ADC"]
645pub struct ADC1 {
646    _marker: PhantomData<*const ()>,
647}
648unsafe impl Send for ADC1 {}
649impl ADC1 {
650    #[doc = r"Pointer to the register block"]
651    pub const PTR: *const adc0::RegisterBlock = 0x4002_7000 as *const _;
652    #[doc = r"Return the pointer to the register block"]
653    #[inline(always)]
654    pub const fn ptr() -> *const adc0::RegisterBlock {
655        Self::PTR
656    }
657}
658impl Deref for ADC1 {
659    type Target = adc0::RegisterBlock;
660    #[inline(always)]
661    fn deref(&self) -> &Self::Target {
662        unsafe { &*Self::PTR }
663    }
664}
665impl core::fmt::Debug for ADC1 {
666    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
667        f.debug_struct("ADC1").finish()
668    }
669}
670#[doc = "ADC"]
671pub use adc0 as adc1;
672#[doc = "RTC"]
673pub struct RTC {
674    _marker: PhantomData<*const ()>,
675}
676unsafe impl Send for RTC {}
677impl RTC {
678    #[doc = r"Pointer to the register block"]
679    pub const PTR: *const rtc::RegisterBlock = 0x4003_d000 as *const _;
680    #[doc = r"Return the pointer to the register block"]
681    #[inline(always)]
682    pub const fn ptr() -> *const rtc::RegisterBlock {
683        Self::PTR
684    }
685}
686impl Deref for RTC {
687    type Target = rtc::RegisterBlock;
688    #[inline(always)]
689    fn deref(&self) -> &Self::Target {
690        unsafe { &*Self::PTR }
691    }
692}
693impl core::fmt::Debug for RTC {
694    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
695        f.debug_struct("RTC").finish()
696    }
697}
698#[doc = "RTC"]
699pub mod rtc;
700#[doc = "LPTMR"]
701pub struct LPTMR0 {
702    _marker: PhantomData<*const ()>,
703}
704unsafe impl Send for LPTMR0 {}
705impl LPTMR0 {
706    #[doc = r"Pointer to the register block"]
707    pub const PTR: *const lptmr0::RegisterBlock = 0x4004_0000 as *const _;
708    #[doc = r"Return the pointer to the register block"]
709    #[inline(always)]
710    pub const fn ptr() -> *const lptmr0::RegisterBlock {
711        Self::PTR
712    }
713}
714impl Deref for LPTMR0 {
715    type Target = lptmr0::RegisterBlock;
716    #[inline(always)]
717    fn deref(&self) -> &Self::Target {
718        unsafe { &*Self::PTR }
719    }
720}
721impl core::fmt::Debug for LPTMR0 {
722    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
723        f.debug_struct("LPTMR0").finish()
724    }
725}
726#[doc = "LPTMR"]
727pub mod lptmr0;
728#[doc = "SIM"]
729pub struct SIM {
730    _marker: PhantomData<*const ()>,
731}
732unsafe impl Send for SIM {}
733impl SIM {
734    #[doc = r"Pointer to the register block"]
735    pub const PTR: *const sim::RegisterBlock = 0x4004_8000 as *const _;
736    #[doc = r"Return the pointer to the register block"]
737    #[inline(always)]
738    pub const fn ptr() -> *const sim::RegisterBlock {
739        Self::PTR
740    }
741}
742impl Deref for SIM {
743    type Target = sim::RegisterBlock;
744    #[inline(always)]
745    fn deref(&self) -> &Self::Target {
746        unsafe { &*Self::PTR }
747    }
748}
749impl core::fmt::Debug for SIM {
750    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
751        f.debug_struct("SIM").finish()
752    }
753}
754#[doc = "SIM"]
755pub mod sim;
756#[doc = "Pin Control and Interrupts"]
757pub struct PORTA {
758    _marker: PhantomData<*const ()>,
759}
760unsafe impl Send for PORTA {}
761impl PORTA {
762    #[doc = r"Pointer to the register block"]
763    pub const PTR: *const porta::RegisterBlock = 0x4004_9000 as *const _;
764    #[doc = r"Return the pointer to the register block"]
765    #[inline(always)]
766    pub const fn ptr() -> *const porta::RegisterBlock {
767        Self::PTR
768    }
769}
770impl Deref for PORTA {
771    type Target = porta::RegisterBlock;
772    #[inline(always)]
773    fn deref(&self) -> &Self::Target {
774        unsafe { &*Self::PTR }
775    }
776}
777impl core::fmt::Debug for PORTA {
778    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
779        f.debug_struct("PORTA").finish()
780    }
781}
782#[doc = "Pin Control and Interrupts"]
783pub mod porta;
784#[doc = "Pin Control and Interrupts"]
785pub struct PORTB {
786    _marker: PhantomData<*const ()>,
787}
788unsafe impl Send for PORTB {}
789impl PORTB {
790    #[doc = r"Pointer to the register block"]
791    pub const PTR: *const porta::RegisterBlock = 0x4004_a000 as *const _;
792    #[doc = r"Return the pointer to the register block"]
793    #[inline(always)]
794    pub const fn ptr() -> *const porta::RegisterBlock {
795        Self::PTR
796    }
797}
798impl Deref for PORTB {
799    type Target = porta::RegisterBlock;
800    #[inline(always)]
801    fn deref(&self) -> &Self::Target {
802        unsafe { &*Self::PTR }
803    }
804}
805impl core::fmt::Debug for PORTB {
806    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
807        f.debug_struct("PORTB").finish()
808    }
809}
810#[doc = "Pin Control and Interrupts"]
811pub use porta as portb;
812#[doc = "Pin Control and Interrupts"]
813pub struct PORTC {
814    _marker: PhantomData<*const ()>,
815}
816unsafe impl Send for PORTC {}
817impl PORTC {
818    #[doc = r"Pointer to the register block"]
819    pub const PTR: *const porta::RegisterBlock = 0x4004_b000 as *const _;
820    #[doc = r"Return the pointer to the register block"]
821    #[inline(always)]
822    pub const fn ptr() -> *const porta::RegisterBlock {
823        Self::PTR
824    }
825}
826impl Deref for PORTC {
827    type Target = porta::RegisterBlock;
828    #[inline(always)]
829    fn deref(&self) -> &Self::Target {
830        unsafe { &*Self::PTR }
831    }
832}
833impl core::fmt::Debug for PORTC {
834    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
835        f.debug_struct("PORTC").finish()
836    }
837}
838#[doc = "Pin Control and Interrupts"]
839pub use porta as portc;
840#[doc = "Pin Control and Interrupts"]
841pub struct PORTD {
842    _marker: PhantomData<*const ()>,
843}
844unsafe impl Send for PORTD {}
845impl PORTD {
846    #[doc = r"Pointer to the register block"]
847    pub const PTR: *const porta::RegisterBlock = 0x4004_c000 as *const _;
848    #[doc = r"Return the pointer to the register block"]
849    #[inline(always)]
850    pub const fn ptr() -> *const porta::RegisterBlock {
851        Self::PTR
852    }
853}
854impl Deref for PORTD {
855    type Target = porta::RegisterBlock;
856    #[inline(always)]
857    fn deref(&self) -> &Self::Target {
858        unsafe { &*Self::PTR }
859    }
860}
861impl core::fmt::Debug for PORTD {
862    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
863        f.debug_struct("PORTD").finish()
864    }
865}
866#[doc = "Pin Control and Interrupts"]
867pub use porta as portd;
868#[doc = "Pin Control and Interrupts"]
869pub struct PORTE {
870    _marker: PhantomData<*const ()>,
871}
872unsafe impl Send for PORTE {}
873impl PORTE {
874    #[doc = r"Pointer to the register block"]
875    pub const PTR: *const porta::RegisterBlock = 0x4004_d000 as *const _;
876    #[doc = r"Return the pointer to the register block"]
877    #[inline(always)]
878    pub const fn ptr() -> *const porta::RegisterBlock {
879        Self::PTR
880    }
881}
882impl Deref for PORTE {
883    type Target = porta::RegisterBlock;
884    #[inline(always)]
885    fn deref(&self) -> &Self::Target {
886        unsafe { &*Self::PTR }
887    }
888}
889impl core::fmt::Debug for PORTE {
890    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
891        f.debug_struct("PORTE").finish()
892    }
893}
894#[doc = "Pin Control and Interrupts"]
895pub use porta as porte;
896#[doc = "WDOG"]
897pub struct WDOG {
898    _marker: PhantomData<*const ()>,
899}
900unsafe impl Send for WDOG {}
901impl WDOG {
902    #[doc = r"Pointer to the register block"]
903    pub const PTR: *const wdog::RegisterBlock = 0x4005_2000 as *const _;
904    #[doc = r"Return the pointer to the register block"]
905    #[inline(always)]
906    pub const fn ptr() -> *const wdog::RegisterBlock {
907        Self::PTR
908    }
909}
910impl Deref for WDOG {
911    type Target = wdog::RegisterBlock;
912    #[inline(always)]
913    fn deref(&self) -> &Self::Target {
914        unsafe { &*Self::PTR }
915    }
916}
917impl core::fmt::Debug for WDOG {
918    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
919        f.debug_struct("WDOG").finish()
920    }
921}
922#[doc = "WDOG"]
923pub mod wdog;
924#[doc = "FLEXIO"]
925pub struct FLEXIO {
926    _marker: PhantomData<*const ()>,
927}
928unsafe impl Send for FLEXIO {}
929impl FLEXIO {
930    #[doc = r"Pointer to the register block"]
931    pub const PTR: *const flexio::RegisterBlock = 0x4005_a000 as *const _;
932    #[doc = r"Return the pointer to the register block"]
933    #[inline(always)]
934    pub const fn ptr() -> *const flexio::RegisterBlock {
935        Self::PTR
936    }
937}
938impl Deref for FLEXIO {
939    type Target = flexio::RegisterBlock;
940    #[inline(always)]
941    fn deref(&self) -> &Self::Target {
942        unsafe { &*Self::PTR }
943    }
944}
945impl core::fmt::Debug for FLEXIO {
946    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
947        f.debug_struct("FLEXIO").finish()
948    }
949}
950#[doc = "FLEXIO"]
951pub mod flexio;
952#[doc = "EWM"]
953pub struct EWM {
954    _marker: PhantomData<*const ()>,
955}
956unsafe impl Send for EWM {}
957impl EWM {
958    #[doc = r"Pointer to the register block"]
959    pub const PTR: *const ewm::RegisterBlock = 0x4006_1000 as *const _;
960    #[doc = r"Return the pointer to the register block"]
961    #[inline(always)]
962    pub const fn ptr() -> *const ewm::RegisterBlock {
963        Self::PTR
964    }
965}
966impl Deref for EWM {
967    type Target = ewm::RegisterBlock;
968    #[inline(always)]
969    fn deref(&self) -> &Self::Target {
970        unsafe { &*Self::PTR }
971    }
972}
973impl core::fmt::Debug for EWM {
974    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
975        f.debug_struct("EWM").finish()
976    }
977}
978#[doc = "EWM"]
979pub mod ewm;
980#[doc = "TRGMUX"]
981pub struct TRGMUX {
982    _marker: PhantomData<*const ()>,
983}
984unsafe impl Send for TRGMUX {}
985impl TRGMUX {
986    #[doc = r"Pointer to the register block"]
987    pub const PTR: *const trgmux::RegisterBlock = 0x4006_3000 as *const _;
988    #[doc = r"Return the pointer to the register block"]
989    #[inline(always)]
990    pub const fn ptr() -> *const trgmux::RegisterBlock {
991        Self::PTR
992    }
993}
994impl Deref for TRGMUX {
995    type Target = trgmux::RegisterBlock;
996    #[inline(always)]
997    fn deref(&self) -> &Self::Target {
998        unsafe { &*Self::PTR }
999    }
1000}
1001impl core::fmt::Debug for TRGMUX {
1002    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1003        f.debug_struct("TRGMUX").finish()
1004    }
1005}
1006#[doc = "TRGMUX"]
1007pub mod trgmux;
1008#[doc = "System Clock Generator"]
1009pub struct SCG {
1010    _marker: PhantomData<*const ()>,
1011}
1012unsafe impl Send for SCG {}
1013impl SCG {
1014    #[doc = r"Pointer to the register block"]
1015    pub const PTR: *const scg::RegisterBlock = 0x4006_4000 as *const _;
1016    #[doc = r"Return the pointer to the register block"]
1017    #[inline(always)]
1018    pub const fn ptr() -> *const scg::RegisterBlock {
1019        Self::PTR
1020    }
1021}
1022impl Deref for SCG {
1023    type Target = scg::RegisterBlock;
1024    #[inline(always)]
1025    fn deref(&self) -> &Self::Target {
1026        unsafe { &*Self::PTR }
1027    }
1028}
1029impl core::fmt::Debug for SCG {
1030    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1031        f.debug_struct("SCG").finish()
1032    }
1033}
1034#[doc = "System Clock Generator"]
1035pub mod scg;
1036#[doc = "PCC"]
1037pub struct PCC {
1038    _marker: PhantomData<*const ()>,
1039}
1040unsafe impl Send for PCC {}
1041impl PCC {
1042    #[doc = r"Pointer to the register block"]
1043    pub const PTR: *const pcc::RegisterBlock = 0x4006_5000 as *const _;
1044    #[doc = r"Return the pointer to the register block"]
1045    #[inline(always)]
1046    pub const fn ptr() -> *const pcc::RegisterBlock {
1047        Self::PTR
1048    }
1049}
1050impl Deref for PCC {
1051    type Target = pcc::RegisterBlock;
1052    #[inline(always)]
1053    fn deref(&self) -> &Self::Target {
1054        unsafe { &*Self::PTR }
1055    }
1056}
1057impl core::fmt::Debug for PCC {
1058    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1059        f.debug_struct("PCC").finish()
1060    }
1061}
1062#[doc = "PCC"]
1063pub mod pcc;
1064#[doc = "LPI2C"]
1065pub struct LPI2C0 {
1066    _marker: PhantomData<*const ()>,
1067}
1068unsafe impl Send for LPI2C0 {}
1069impl LPI2C0 {
1070    #[doc = r"Pointer to the register block"]
1071    pub const PTR: *const lpi2c0::RegisterBlock = 0x4006_6000 as *const _;
1072    #[doc = r"Return the pointer to the register block"]
1073    #[inline(always)]
1074    pub const fn ptr() -> *const lpi2c0::RegisterBlock {
1075        Self::PTR
1076    }
1077}
1078impl Deref for LPI2C0 {
1079    type Target = lpi2c0::RegisterBlock;
1080    #[inline(always)]
1081    fn deref(&self) -> &Self::Target {
1082        unsafe { &*Self::PTR }
1083    }
1084}
1085impl core::fmt::Debug for LPI2C0 {
1086    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1087        f.debug_struct("LPI2C0").finish()
1088    }
1089}
1090#[doc = "LPI2C"]
1091pub mod lpi2c0;
1092#[doc = "LPUART"]
1093pub struct LPUART0 {
1094    _marker: PhantomData<*const ()>,
1095}
1096unsafe impl Send for LPUART0 {}
1097impl LPUART0 {
1098    #[doc = r"Pointer to the register block"]
1099    pub const PTR: *const lpuart0::RegisterBlock = 0x4006_a000 as *const _;
1100    #[doc = r"Return the pointer to the register block"]
1101    #[inline(always)]
1102    pub const fn ptr() -> *const lpuart0::RegisterBlock {
1103        Self::PTR
1104    }
1105}
1106impl Deref for LPUART0 {
1107    type Target = lpuart0::RegisterBlock;
1108    #[inline(always)]
1109    fn deref(&self) -> &Self::Target {
1110        unsafe { &*Self::PTR }
1111    }
1112}
1113impl core::fmt::Debug for LPUART0 {
1114    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1115        f.debug_struct("LPUART0").finish()
1116    }
1117}
1118#[doc = "LPUART"]
1119pub mod lpuart0;
1120#[doc = "LPUART"]
1121pub struct LPUART1 {
1122    _marker: PhantomData<*const ()>,
1123}
1124unsafe impl Send for LPUART1 {}
1125impl LPUART1 {
1126    #[doc = r"Pointer to the register block"]
1127    pub const PTR: *const lpuart0::RegisterBlock = 0x4006_b000 as *const _;
1128    #[doc = r"Return the pointer to the register block"]
1129    #[inline(always)]
1130    pub const fn ptr() -> *const lpuart0::RegisterBlock {
1131        Self::PTR
1132    }
1133}
1134impl Deref for LPUART1 {
1135    type Target = lpuart0::RegisterBlock;
1136    #[inline(always)]
1137    fn deref(&self) -> &Self::Target {
1138        unsafe { &*Self::PTR }
1139    }
1140}
1141impl core::fmt::Debug for LPUART1 {
1142    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1143        f.debug_struct("LPUART1").finish()
1144    }
1145}
1146#[doc = "LPUART"]
1147pub use lpuart0 as lpuart1;
1148#[doc = "LPUART"]
1149pub struct LPUART2 {
1150    _marker: PhantomData<*const ()>,
1151}
1152unsafe impl Send for LPUART2 {}
1153impl LPUART2 {
1154    #[doc = r"Pointer to the register block"]
1155    pub const PTR: *const lpuart0::RegisterBlock = 0x4006_c000 as *const _;
1156    #[doc = r"Return the pointer to the register block"]
1157    #[inline(always)]
1158    pub const fn ptr() -> *const lpuart0::RegisterBlock {
1159        Self::PTR
1160    }
1161}
1162impl Deref for LPUART2 {
1163    type Target = lpuart0::RegisterBlock;
1164    #[inline(always)]
1165    fn deref(&self) -> &Self::Target {
1166        unsafe { &*Self::PTR }
1167    }
1168}
1169impl core::fmt::Debug for LPUART2 {
1170    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1171        f.debug_struct("LPUART2").finish()
1172    }
1173}
1174#[doc = "LPUART"]
1175pub use lpuart0 as lpuart2;
1176#[doc = "High-Speed Comparator (CMP), Voltage Reference (VREF) Digital-to-Analog Converter (DAC), and Analog Mux (ANMUX)"]
1177pub struct CMP0 {
1178    _marker: PhantomData<*const ()>,
1179}
1180unsafe impl Send for CMP0 {}
1181impl CMP0 {
1182    #[doc = r"Pointer to the register block"]
1183    pub const PTR: *const cmp0::RegisterBlock = 0x4007_3000 as *const _;
1184    #[doc = r"Return the pointer to the register block"]
1185    #[inline(always)]
1186    pub const fn ptr() -> *const cmp0::RegisterBlock {
1187        Self::PTR
1188    }
1189}
1190impl Deref for CMP0 {
1191    type Target = cmp0::RegisterBlock;
1192    #[inline(always)]
1193    fn deref(&self) -> &Self::Target {
1194        unsafe { &*Self::PTR }
1195    }
1196}
1197impl core::fmt::Debug for CMP0 {
1198    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1199        f.debug_struct("CMP0").finish()
1200    }
1201}
1202#[doc = "High-Speed Comparator (CMP), Voltage Reference (VREF) Digital-to-Analog Converter (DAC), and Analog Mux (ANMUX)"]
1203pub mod cmp0;
1204#[doc = "PMC"]
1205pub struct PMC {
1206    _marker: PhantomData<*const ()>,
1207}
1208unsafe impl Send for PMC {}
1209impl PMC {
1210    #[doc = r"Pointer to the register block"]
1211    pub const PTR: *const pmc::RegisterBlock = 0x4007_d000 as *const _;
1212    #[doc = r"Return the pointer to the register block"]
1213    #[inline(always)]
1214    pub const fn ptr() -> *const pmc::RegisterBlock {
1215        Self::PTR
1216    }
1217}
1218impl Deref for PMC {
1219    type Target = pmc::RegisterBlock;
1220    #[inline(always)]
1221    fn deref(&self) -> &Self::Target {
1222        unsafe { &*Self::PTR }
1223    }
1224}
1225impl core::fmt::Debug for PMC {
1226    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1227        f.debug_struct("PMC").finish()
1228    }
1229}
1230#[doc = "PMC"]
1231pub mod pmc;
1232#[doc = "System Mode Controller"]
1233pub struct SMC {
1234    _marker: PhantomData<*const ()>,
1235}
1236unsafe impl Send for SMC {}
1237impl SMC {
1238    #[doc = r"Pointer to the register block"]
1239    pub const PTR: *const smc::RegisterBlock = 0x4007_e000 as *const _;
1240    #[doc = r"Return the pointer to the register block"]
1241    #[inline(always)]
1242    pub const fn ptr() -> *const smc::RegisterBlock {
1243        Self::PTR
1244    }
1245}
1246impl Deref for SMC {
1247    type Target = smc::RegisterBlock;
1248    #[inline(always)]
1249    fn deref(&self) -> &Self::Target {
1250        unsafe { &*Self::PTR }
1251    }
1252}
1253impl core::fmt::Debug for SMC {
1254    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1255        f.debug_struct("SMC").finish()
1256    }
1257}
1258#[doc = "System Mode Controller"]
1259pub mod smc;
1260#[doc = "Reset Control Module"]
1261pub struct RCM {
1262    _marker: PhantomData<*const ()>,
1263}
1264unsafe impl Send for RCM {}
1265impl RCM {
1266    #[doc = r"Pointer to the register block"]
1267    pub const PTR: *const rcm::RegisterBlock = 0x4007_f000 as *const _;
1268    #[doc = r"Return the pointer to the register block"]
1269    #[inline(always)]
1270    pub const fn ptr() -> *const rcm::RegisterBlock {
1271        Self::PTR
1272    }
1273}
1274impl Deref for RCM {
1275    type Target = rcm::RegisterBlock;
1276    #[inline(always)]
1277    fn deref(&self) -> &Self::Target {
1278        unsafe { &*Self::PTR }
1279    }
1280}
1281impl core::fmt::Debug for RCM {
1282    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1283        f.debug_struct("RCM").finish()
1284    }
1285}
1286#[doc = "Reset Control Module"]
1287pub mod rcm;
1288#[doc = "GPIO"]
1289pub struct PTA {
1290    _marker: PhantomData<*const ()>,
1291}
1292unsafe impl Send for PTA {}
1293impl PTA {
1294    #[doc = r"Pointer to the register block"]
1295    pub const PTR: *const pta::RegisterBlock = 0x400f_f000 as *const _;
1296    #[doc = r"Return the pointer to the register block"]
1297    #[inline(always)]
1298    pub const fn ptr() -> *const pta::RegisterBlock {
1299        Self::PTR
1300    }
1301}
1302impl Deref for PTA {
1303    type Target = pta::RegisterBlock;
1304    #[inline(always)]
1305    fn deref(&self) -> &Self::Target {
1306        unsafe { &*Self::PTR }
1307    }
1308}
1309impl core::fmt::Debug for PTA {
1310    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1311        f.debug_struct("PTA").finish()
1312    }
1313}
1314#[doc = "GPIO"]
1315pub mod pta;
1316#[doc = "GPIO"]
1317pub struct PTB {
1318    _marker: PhantomData<*const ()>,
1319}
1320unsafe impl Send for PTB {}
1321impl PTB {
1322    #[doc = r"Pointer to the register block"]
1323    pub const PTR: *const pta::RegisterBlock = 0x400f_f040 as *const _;
1324    #[doc = r"Return the pointer to the register block"]
1325    #[inline(always)]
1326    pub const fn ptr() -> *const pta::RegisterBlock {
1327        Self::PTR
1328    }
1329}
1330impl Deref for PTB {
1331    type Target = pta::RegisterBlock;
1332    #[inline(always)]
1333    fn deref(&self) -> &Self::Target {
1334        unsafe { &*Self::PTR }
1335    }
1336}
1337impl core::fmt::Debug for PTB {
1338    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1339        f.debug_struct("PTB").finish()
1340    }
1341}
1342#[doc = "GPIO"]
1343pub use pta as ptb;
1344#[doc = "GPIO"]
1345pub struct PTC {
1346    _marker: PhantomData<*const ()>,
1347}
1348unsafe impl Send for PTC {}
1349impl PTC {
1350    #[doc = r"Pointer to the register block"]
1351    pub const PTR: *const pta::RegisterBlock = 0x400f_f080 as *const _;
1352    #[doc = r"Return the pointer to the register block"]
1353    #[inline(always)]
1354    pub const fn ptr() -> *const pta::RegisterBlock {
1355        Self::PTR
1356    }
1357}
1358impl Deref for PTC {
1359    type Target = pta::RegisterBlock;
1360    #[inline(always)]
1361    fn deref(&self) -> &Self::Target {
1362        unsafe { &*Self::PTR }
1363    }
1364}
1365impl core::fmt::Debug for PTC {
1366    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1367        f.debug_struct("PTC").finish()
1368    }
1369}
1370#[doc = "GPIO"]
1371pub use pta as ptc;
1372#[doc = "GPIO"]
1373pub struct PTD {
1374    _marker: PhantomData<*const ()>,
1375}
1376unsafe impl Send for PTD {}
1377impl PTD {
1378    #[doc = r"Pointer to the register block"]
1379    pub const PTR: *const pta::RegisterBlock = 0x400f_f0c0 as *const _;
1380    #[doc = r"Return the pointer to the register block"]
1381    #[inline(always)]
1382    pub const fn ptr() -> *const pta::RegisterBlock {
1383        Self::PTR
1384    }
1385}
1386impl Deref for PTD {
1387    type Target = pta::RegisterBlock;
1388    #[inline(always)]
1389    fn deref(&self) -> &Self::Target {
1390        unsafe { &*Self::PTR }
1391    }
1392}
1393impl core::fmt::Debug for PTD {
1394    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1395        f.debug_struct("PTD").finish()
1396    }
1397}
1398#[doc = "GPIO"]
1399pub use pta as ptd;
1400#[doc = "GPIO"]
1401pub struct PTE {
1402    _marker: PhantomData<*const ()>,
1403}
1404unsafe impl Send for PTE {}
1405impl PTE {
1406    #[doc = r"Pointer to the register block"]
1407    pub const PTR: *const pta::RegisterBlock = 0x400f_f100 as *const _;
1408    #[doc = r"Return the pointer to the register block"]
1409    #[inline(always)]
1410    pub const fn ptr() -> *const pta::RegisterBlock {
1411        Self::PTR
1412    }
1413}
1414impl Deref for PTE {
1415    type Target = pta::RegisterBlock;
1416    #[inline(always)]
1417    fn deref(&self) -> &Self::Target {
1418        unsafe { &*Self::PTR }
1419    }
1420}
1421impl core::fmt::Debug for PTE {
1422    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1423        f.debug_struct("PTE").finish()
1424    }
1425}
1426#[doc = "GPIO"]
1427pub use pta as pte;
1428#[doc = "Core Platform Miscellaneous Control Module"]
1429pub struct MCM {
1430    _marker: PhantomData<*const ()>,
1431}
1432unsafe impl Send for MCM {}
1433impl MCM {
1434    #[doc = r"Pointer to the register block"]
1435    pub const PTR: *const mcm::RegisterBlock = 0xe008_0000 as *const _;
1436    #[doc = r"Return the pointer to the register block"]
1437    #[inline(always)]
1438    pub const fn ptr() -> *const mcm::RegisterBlock {
1439        Self::PTR
1440    }
1441}
1442impl Deref for MCM {
1443    type Target = mcm::RegisterBlock;
1444    #[inline(always)]
1445    fn deref(&self) -> &Self::Target {
1446        unsafe { &*Self::PTR }
1447    }
1448}
1449impl core::fmt::Debug for MCM {
1450    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1451        f.debug_struct("MCM").finish()
1452    }
1453}
1454#[doc = "Core Platform Miscellaneous Control Module"]
1455pub mod mcm;
1456#[doc = "LMEM"]
1457pub struct LMEM {
1458    _marker: PhantomData<*const ()>,
1459}
1460unsafe impl Send for LMEM {}
1461impl LMEM {
1462    #[doc = r"Pointer to the register block"]
1463    pub const PTR: *const lmem::RegisterBlock = 0xe008_2000 as *const _;
1464    #[doc = r"Return the pointer to the register block"]
1465    #[inline(always)]
1466    pub const fn ptr() -> *const lmem::RegisterBlock {
1467        Self::PTR
1468    }
1469}
1470impl Deref for LMEM {
1471    type Target = lmem::RegisterBlock;
1472    #[inline(always)]
1473    fn deref(&self) -> &Self::Target {
1474        unsafe { &*Self::PTR }
1475    }
1476}
1477impl core::fmt::Debug for LMEM {
1478    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1479        f.debug_struct("LMEM").finish()
1480    }
1481}
1482#[doc = "LMEM"]
1483pub mod lmem;
1484#[no_mangle]
1485static mut DEVICE_PERIPHERALS: bool = false;
1486#[doc = r"All the peripherals"]
1487#[allow(non_snake_case)]
1488pub struct Peripherals {
1489    #[doc = "AIPS"]
1490    pub AIPS: AIPS,
1491    #[doc = "MSCM"]
1492    pub MSCM: MSCM,
1493    #[doc = "DMA"]
1494    pub DMA: DMA,
1495    #[doc = "ERM"]
1496    pub ERM: ERM,
1497    #[doc = "EIM"]
1498    pub EIM: EIM,
1499    #[doc = "FTFM"]
1500    pub FTFM: FTFM,
1501    #[doc = "DMAMUX"]
1502    pub DMAMUX: DMAMUX,
1503    #[doc = "CAN0"]
1504    pub CAN0: CAN0,
1505    #[doc = "CAN1"]
1506    pub CAN1: CAN1,
1507    #[doc = "LPSPI0"]
1508    pub LPSPI0: LPSPI0,
1509    #[doc = "LPSPI1"]
1510    pub LPSPI1: LPSPI1,
1511    #[doc = "LPSPI2"]
1512    pub LPSPI2: LPSPI2,
1513    #[doc = "CRC"]
1514    pub CRC: CRC,
1515    #[doc = "PDB0"]
1516    pub PDB0: PDB0,
1517    #[doc = "PDB1"]
1518    pub PDB1: PDB1,
1519    #[doc = "LPIT0"]
1520    pub LPIT0: LPIT0,
1521    #[doc = "FTM0"]
1522    pub FTM0: FTM0,
1523    #[doc = "FTM3"]
1524    pub FTM3: FTM3,
1525    #[doc = "FTM1"]
1526    pub FTM1: FTM1,
1527    #[doc = "FTM2"]
1528    pub FTM2: FTM2,
1529    #[doc = "ADC0"]
1530    pub ADC0: ADC0,
1531    #[doc = "ADC1"]
1532    pub ADC1: ADC1,
1533    #[doc = "RTC"]
1534    pub RTC: RTC,
1535    #[doc = "LPTMR0"]
1536    pub LPTMR0: LPTMR0,
1537    #[doc = "SIM"]
1538    pub SIM: SIM,
1539    #[doc = "PORTA"]
1540    pub PORTA: PORTA,
1541    #[doc = "PORTB"]
1542    pub PORTB: PORTB,
1543    #[doc = "PORTC"]
1544    pub PORTC: PORTC,
1545    #[doc = "PORTD"]
1546    pub PORTD: PORTD,
1547    #[doc = "PORTE"]
1548    pub PORTE: PORTE,
1549    #[doc = "WDOG"]
1550    pub WDOG: WDOG,
1551    #[doc = "FLEXIO"]
1552    pub FLEXIO: FLEXIO,
1553    #[doc = "EWM"]
1554    pub EWM: EWM,
1555    #[doc = "TRGMUX"]
1556    pub TRGMUX: TRGMUX,
1557    #[doc = "SCG"]
1558    pub SCG: SCG,
1559    #[doc = "PCC"]
1560    pub PCC: PCC,
1561    #[doc = "LPI2C0"]
1562    pub LPI2C0: LPI2C0,
1563    #[doc = "LPUART0"]
1564    pub LPUART0: LPUART0,
1565    #[doc = "LPUART1"]
1566    pub LPUART1: LPUART1,
1567    #[doc = "LPUART2"]
1568    pub LPUART2: LPUART2,
1569    #[doc = "CMP0"]
1570    pub CMP0: CMP0,
1571    #[doc = "PMC"]
1572    pub PMC: PMC,
1573    #[doc = "SMC"]
1574    pub SMC: SMC,
1575    #[doc = "RCM"]
1576    pub RCM: RCM,
1577    #[doc = "PTA"]
1578    pub PTA: PTA,
1579    #[doc = "PTB"]
1580    pub PTB: PTB,
1581    #[doc = "PTC"]
1582    pub PTC: PTC,
1583    #[doc = "PTD"]
1584    pub PTD: PTD,
1585    #[doc = "PTE"]
1586    pub PTE: PTE,
1587    #[doc = "MCM"]
1588    pub MCM: MCM,
1589    #[doc = "LMEM"]
1590    pub LMEM: LMEM,
1591}
1592impl Peripherals {
1593    #[doc = r"Returns all the peripherals *once*"]
1594    #[inline]
1595    pub fn take() -> Option<Self> {
1596        cortex_m::interrupt::free(|_| {
1597            if unsafe { DEVICE_PERIPHERALS } {
1598                None
1599            } else {
1600                Some(unsafe { Peripherals::steal() })
1601            }
1602        })
1603    }
1604    #[doc = r"Unchecked version of `Peripherals::take`"]
1605    #[inline]
1606    pub unsafe fn steal() -> Self {
1607        DEVICE_PERIPHERALS = true;
1608        Peripherals {
1609            AIPS: AIPS {
1610                _marker: PhantomData,
1611            },
1612            MSCM: MSCM {
1613                _marker: PhantomData,
1614            },
1615            DMA: DMA {
1616                _marker: PhantomData,
1617            },
1618            ERM: ERM {
1619                _marker: PhantomData,
1620            },
1621            EIM: EIM {
1622                _marker: PhantomData,
1623            },
1624            FTFM: FTFM {
1625                _marker: PhantomData,
1626            },
1627            DMAMUX: DMAMUX {
1628                _marker: PhantomData,
1629            },
1630            CAN0: CAN0 {
1631                _marker: PhantomData,
1632            },
1633            CAN1: CAN1 {
1634                _marker: PhantomData,
1635            },
1636            LPSPI0: LPSPI0 {
1637                _marker: PhantomData,
1638            },
1639            LPSPI1: LPSPI1 {
1640                _marker: PhantomData,
1641            },
1642            LPSPI2: LPSPI2 {
1643                _marker: PhantomData,
1644            },
1645            CRC: CRC {
1646                _marker: PhantomData,
1647            },
1648            PDB0: PDB0 {
1649                _marker: PhantomData,
1650            },
1651            PDB1: PDB1 {
1652                _marker: PhantomData,
1653            },
1654            LPIT0: LPIT0 {
1655                _marker: PhantomData,
1656            },
1657            FTM0: FTM0 {
1658                _marker: PhantomData,
1659            },
1660            FTM3: FTM3 {
1661                _marker: PhantomData,
1662            },
1663            FTM1: FTM1 {
1664                _marker: PhantomData,
1665            },
1666            FTM2: FTM2 {
1667                _marker: PhantomData,
1668            },
1669            ADC0: ADC0 {
1670                _marker: PhantomData,
1671            },
1672            ADC1: ADC1 {
1673                _marker: PhantomData,
1674            },
1675            RTC: RTC {
1676                _marker: PhantomData,
1677            },
1678            LPTMR0: LPTMR0 {
1679                _marker: PhantomData,
1680            },
1681            SIM: SIM {
1682                _marker: PhantomData,
1683            },
1684            PORTA: PORTA {
1685                _marker: PhantomData,
1686            },
1687            PORTB: PORTB {
1688                _marker: PhantomData,
1689            },
1690            PORTC: PORTC {
1691                _marker: PhantomData,
1692            },
1693            PORTD: PORTD {
1694                _marker: PhantomData,
1695            },
1696            PORTE: PORTE {
1697                _marker: PhantomData,
1698            },
1699            WDOG: WDOG {
1700                _marker: PhantomData,
1701            },
1702            FLEXIO: FLEXIO {
1703                _marker: PhantomData,
1704            },
1705            EWM: EWM {
1706                _marker: PhantomData,
1707            },
1708            TRGMUX: TRGMUX {
1709                _marker: PhantomData,
1710            },
1711            SCG: SCG {
1712                _marker: PhantomData,
1713            },
1714            PCC: PCC {
1715                _marker: PhantomData,
1716            },
1717            LPI2C0: LPI2C0 {
1718                _marker: PhantomData,
1719            },
1720            LPUART0: LPUART0 {
1721                _marker: PhantomData,
1722            },
1723            LPUART1: LPUART1 {
1724                _marker: PhantomData,
1725            },
1726            LPUART2: LPUART2 {
1727                _marker: PhantomData,
1728            },
1729            CMP0: CMP0 {
1730                _marker: PhantomData,
1731            },
1732            PMC: PMC {
1733                _marker: PhantomData,
1734            },
1735            SMC: SMC {
1736                _marker: PhantomData,
1737            },
1738            RCM: RCM {
1739                _marker: PhantomData,
1740            },
1741            PTA: PTA {
1742                _marker: PhantomData,
1743            },
1744            PTB: PTB {
1745                _marker: PhantomData,
1746            },
1747            PTC: PTC {
1748                _marker: PhantomData,
1749            },
1750            PTD: PTD {
1751                _marker: PhantomData,
1752            },
1753            PTE: PTE {
1754                _marker: PhantomData,
1755            },
1756            MCM: MCM {
1757                _marker: PhantomData,
1758            },
1759            LMEM: LMEM {
1760                _marker: PhantomData,
1761            },
1762        }
1763    }
1764}
s32k142w_pac/lib.rs

s32k142w_pac/
lib.rs
