1#![doc = "Peripheral access API for MIMXRT595S_CM33 microcontrollers (generated using svd2rust v0.28.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.28.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(dead_code)]
4#![deny(improper_ctypes)]
5#![deny(missing_docs)]
6#![deny(no_mangle_generic_items)]
7#![deny(non_shorthand_field_patterns)]
8#![deny(overflowing_literals)]
9#![deny(path_statements)]
10#![deny(patterns_in_fns_without_body)]
11#![deny(unconditional_recursion)]
12#![deny(unused_allocation)]
13#![deny(unused_comparisons)]
14#![deny(unused_parens)]
15#![deny(while_true)]
16#![allow(non_camel_case_types)]
17#![allow(non_snake_case)]
18#![no_std]
19use core::marker::PhantomData;
20use core::ops::Deref;
21#[doc = r"Number available in the NVIC for configuring priority"]
22pub const NVIC_PRIO_BITS: u8 = 3;
23#[cfg(feature = "rt")]
24pub use self::Interrupt as interrupt;
25pub use cortex_m::peripheral::Peripherals as CorePeripherals;
26pub use cortex_m::peripheral::{CBP, CPUID, DCB, DWT, FPB, FPU, ITM, MPU, NVIC, SCB, SYST, TPIU};
27#[cfg(feature = "rt")]
28pub use cortex_m_rt::interrupt;
29#[allow(unused_imports)]
30use generic::*;
31#[doc = r"Common register and bit access and modify traits"]
32pub mod generic;
33#[cfg(feature = "rt")]
34extern "C" {
35 fn WDT0();
36 fn DMA0();
37 fn GPIO_INTA();
38 fn GPIO_INTB();
39 fn PIN_INT0();
40 fn PIN_INT1();
41 fn PIN_INT2();
42 fn PIN_INT3();
43 fn UTICK0();
44 fn MRT0();
45 fn CTIMER0();
46 fn CTIMER1();
47 fn SCT0();
48 fn CTIMER3();
49 fn FLEXCOMM0();
50 fn FLEXCOMM1();
51 fn FLEXCOMM2();
52 fn FLEXCOMM3();
53 fn FLEXCOMM4();
54 fn FLEXCOMM5();
55 fn FLEXCOMM14();
56 fn FLEXCOMM15();
57 fn ADC0();
58 fn ACMP();
59 fn DMIC0();
60 fn HYPERVISOR();
61 fn SECURE_VIOLATION();
62 fn HWVAD0();
63 fn RNG();
64 fn RTC();
65 fn DSP_TIE_EXPSTATE1();
66 fn MU_A();
67 fn PIN_INT4();
68 fn PIN_INT5();
69 fn PIN_INT6();
70 fn PIN_INT7();
71 fn CTIMER2();
72 fn CTIMER4();
73 fn OS_EVENT();
74 fn FLEXSPI0_FLEXSPI1();
75 fn FLEXCOMM6();
76 fn FLEXCOMM7();
77 fn USDHC0();
78 fn USDHC1();
79 fn SGPIO_INTA();
80 fn SGPIO_INTB();
81 fn I3C0();
82 fn USB0();
83 fn USB0_NEEDCLK();
84 fn WDT1();
85 fn USB_PHYDCD();
86 fn DMA1();
87 fn PUF();
88 fn POWERQUAD();
89 fn CASPER();
90 fn PMU_PMIC();
91 fn HASHCRYPT();
92 fn FLEXCOMM8();
93 fn FLEXCOMM9();
94 fn FLEXCOMM10();
95 fn FLEXCOMM11();
96 fn FLEXCOMM12();
97 fn FLEXCOMM13();
98 fn FLEXCOMM16();
99 fn I3C1();
100 fn FLEXIO();
101 fn LCDIF();
102 fn MIPI();
103}
104#[doc(hidden)]
105pub union Vector {
106 _handler: unsafe extern "C" fn(),
107 _reserved: u32,
108}
109#[cfg(feature = "rt")]
110#[doc(hidden)]
111#[link_section = ".vector_table.interrupts"]
112#[no_mangle]
113pub static __INTERRUPTS: [Vector; 72] = [
114 Vector { _handler: WDT0 },
115 Vector { _handler: DMA0 },
116 Vector {
117 _handler: GPIO_INTA,
118 },
119 Vector {
120 _handler: GPIO_INTB,
121 },
122 Vector { _handler: PIN_INT0 },
123 Vector { _handler: PIN_INT1 },
124 Vector { _handler: PIN_INT2 },
125 Vector { _handler: PIN_INT3 },
126 Vector { _handler: UTICK0 },
127 Vector { _handler: MRT0 },
128 Vector { _handler: CTIMER0 },
129 Vector { _handler: CTIMER1 },
130 Vector { _handler: SCT0 },
131 Vector { _handler: CTIMER3 },
132 Vector {
133 _handler: FLEXCOMM0,
134 },
135 Vector {
136 _handler: FLEXCOMM1,
137 },
138 Vector {
139 _handler: FLEXCOMM2,
140 },
141 Vector {
142 _handler: FLEXCOMM3,
143 },
144 Vector {
145 _handler: FLEXCOMM4,
146 },
147 Vector {
148 _handler: FLEXCOMM5,
149 },
150 Vector {
151 _handler: FLEXCOMM14,
152 },
153 Vector {
154 _handler: FLEXCOMM15,
155 },
156 Vector { _handler: ADC0 },
157 Vector { _reserved: 0 },
158 Vector { _handler: ACMP },
159 Vector { _handler: DMIC0 },
160 Vector { _reserved: 0 },
161 Vector {
162 _handler: HYPERVISOR,
163 },
164 Vector {
165 _handler: SECURE_VIOLATION,
166 },
167 Vector { _handler: HWVAD0 },
168 Vector { _reserved: 0 },
169 Vector { _handler: RNG },
170 Vector { _handler: RTC },
171 Vector {
172 _handler: DSP_TIE_EXPSTATE1,
173 },
174 Vector { _handler: MU_A },
175 Vector { _handler: PIN_INT4 },
176 Vector { _handler: PIN_INT5 },
177 Vector { _handler: PIN_INT6 },
178 Vector { _handler: PIN_INT7 },
179 Vector { _handler: CTIMER2 },
180 Vector { _handler: CTIMER4 },
181 Vector { _handler: OS_EVENT },
182 Vector {
183 _handler: FLEXSPI0_FLEXSPI1,
184 },
185 Vector {
186 _handler: FLEXCOMM6,
187 },
188 Vector {
189 _handler: FLEXCOMM7,
190 },
191 Vector { _handler: USDHC0 },
192 Vector { _handler: USDHC1 },
193 Vector {
194 _handler: SGPIO_INTA,
195 },
196 Vector {
197 _handler: SGPIO_INTB,
198 },
199 Vector { _handler: I3C0 },
200 Vector { _handler: USB0 },
201 Vector {
202 _handler: USB0_NEEDCLK,
203 },
204 Vector { _handler: WDT1 },
205 Vector {
206 _handler: USB_PHYDCD,
207 },
208 Vector { _handler: DMA1 },
209 Vector { _handler: PUF },
210 Vector {
211 _handler: POWERQUAD,
212 },
213 Vector { _handler: CASPER },
214 Vector { _handler: PMU_PMIC },
215 Vector {
216 _handler: HASHCRYPT,
217 },
218 Vector {
219 _handler: FLEXCOMM8,
220 },
221 Vector {
222 _handler: FLEXCOMM9,
223 },
224 Vector {
225 _handler: FLEXCOMM10,
226 },
227 Vector {
228 _handler: FLEXCOMM11,
229 },
230 Vector {
231 _handler: FLEXCOMM12,
232 },
233 Vector {
234 _handler: FLEXCOMM13,
235 },
236 Vector {
237 _handler: FLEXCOMM16,
238 },
239 Vector { _handler: I3C1 },
240 Vector { _handler: FLEXIO },
241 Vector { _handler: LCDIF },
242 Vector { _reserved: 0 },
243 Vector { _handler: MIPI },
244];
245#[doc = r"Enumeration of all the interrupts."]
246#[derive(Copy, Clone, Debug, PartialEq, Eq)]
247#[repr(u16)]
248pub enum Interrupt {
249 #[doc = "0 - WDT0"]
250 WDT0 = 0,
251 #[doc = "1 - DMA0"]
252 DMA0 = 1,
253 #[doc = "2 - GPIO_INTA"]
254 GPIO_INTA = 2,
255 #[doc = "3 - GPIO_INTB"]
256 GPIO_INTB = 3,
257 #[doc = "4 - PIN_INT0"]
258 PIN_INT0 = 4,
259 #[doc = "5 - PIN_INT1"]
260 PIN_INT1 = 5,
261 #[doc = "6 - PIN_INT2"]
262 PIN_INT2 = 6,
263 #[doc = "7 - PIN_INT3"]
264 PIN_INT3 = 7,
265 #[doc = "8 - UTICK0"]
266 UTICK0 = 8,
267 #[doc = "9 - MRT0"]
268 MRT0 = 9,
269 #[doc = "10 - CTIMER0"]
270 CTIMER0 = 10,
271 #[doc = "11 - CTIMER1"]
272 CTIMER1 = 11,
273 #[doc = "12 - SCT0"]
274 SCT0 = 12,
275 #[doc = "13 - CTIMER3"]
276 CTIMER3 = 13,
277 #[doc = "14 - FLEXCOMM0"]
278 FLEXCOMM0 = 14,
279 #[doc = "15 - FLEXCOMM1"]
280 FLEXCOMM1 = 15,
281 #[doc = "16 - FLEXCOMM2"]
282 FLEXCOMM2 = 16,
283 #[doc = "17 - FLEXCOMM3"]
284 FLEXCOMM3 = 17,
285 #[doc = "18 - FLEXCOMM4"]
286 FLEXCOMM4 = 18,
287 #[doc = "19 - FLEXCOMM5"]
288 FLEXCOMM5 = 19,
289 #[doc = "20 - FLEXCOMM14"]
290 FLEXCOMM14 = 20,
291 #[doc = "21 - FLEXCOMM15"]
292 FLEXCOMM15 = 21,
293 #[doc = "22 - ADC0"]
294 ADC0 = 22,
295 #[doc = "24 - ACMP"]
296 ACMP = 24,
297 #[doc = "25 - DMIC0"]
298 DMIC0 = 25,
299 #[doc = "27 - HYPERVISOR"]
300 HYPERVISOR = 27,
301 #[doc = "28 - SECURE_VIOLATION"]
302 SECURE_VIOLATION = 28,
303 #[doc = "29 - HWVAD0"]
304 HWVAD0 = 29,
305 #[doc = "31 - RNG"]
306 RNG = 31,
307 #[doc = "32 - RTC"]
308 RTC = 32,
309 #[doc = "33 - DSP_TIE_EXPSTATE1"]
310 DSP_TIE_EXPSTATE1 = 33,
311 #[doc = "34 - MU_A"]
312 MU_A = 34,
313 #[doc = "35 - PIN_INT4"]
314 PIN_INT4 = 35,
315 #[doc = "36 - PIN_INT5"]
316 PIN_INT5 = 36,
317 #[doc = "37 - PIN_INT6"]
318 PIN_INT6 = 37,
319 #[doc = "38 - PIN_INT7"]
320 PIN_INT7 = 38,
321 #[doc = "39 - CTIMER2"]
322 CTIMER2 = 39,
323 #[doc = "40 - CTIMER4"]
324 CTIMER4 = 40,
325 #[doc = "41 - OS_EVENT"]
326 OS_EVENT = 41,
327 #[doc = "42 - FLEXSPI0_FLEXSPI1"]
328 FLEXSPI0_FLEXSPI1 = 42,
329 #[doc = "43 - FLEXCOMM6"]
330 FLEXCOMM6 = 43,
331 #[doc = "44 - FLEXCOMM7"]
332 FLEXCOMM7 = 44,
333 #[doc = "45 - USDHC0"]
334 USDHC0 = 45,
335 #[doc = "46 - USDHC1"]
336 USDHC1 = 46,
337 #[doc = "47 - SGPIO_INTA"]
338 SGPIO_INTA = 47,
339 #[doc = "48 - SGPIO_INTB"]
340 SGPIO_INTB = 48,
341 #[doc = "49 - I3C0"]
342 I3C0 = 49,
343 #[doc = "50 - USB0"]
344 USB0 = 50,
345 #[doc = "51 - USB0_NEEDCLK"]
346 USB0_NEEDCLK = 51,
347 #[doc = "52 - WDT1"]
348 WDT1 = 52,
349 #[doc = "53 - USB_PHYDCD"]
350 USB_PHYDCD = 53,
351 #[doc = "54 - DMA1"]
352 DMA1 = 54,
353 #[doc = "55 - PUF"]
354 PUF = 55,
355 #[doc = "56 - POWERQUAD"]
356 POWERQUAD = 56,
357 #[doc = "57 - CASPER"]
358 CASPER = 57,
359 #[doc = "58 - PMU_PMIC"]
360 PMU_PMIC = 58,
361 #[doc = "59 - HASHCRYPT"]
362 HASHCRYPT = 59,
363 #[doc = "60 - FLEXCOMM8"]
364 FLEXCOMM8 = 60,
365 #[doc = "61 - FLEXCOMM9"]
366 FLEXCOMM9 = 61,
367 #[doc = "62 - FLEXCOMM10"]
368 FLEXCOMM10 = 62,
369 #[doc = "63 - FLEXCOMM11"]
370 FLEXCOMM11 = 63,
371 #[doc = "64 - FLEXCOMM12"]
372 FLEXCOMM12 = 64,
373 #[doc = "65 - FLEXCOMM13"]
374 FLEXCOMM13 = 65,
375 #[doc = "66 - FLEXCOMM16"]
376 FLEXCOMM16 = 66,
377 #[doc = "67 - I3C1"]
378 I3C1 = 67,
379 #[doc = "68 - FLEXIO"]
380 FLEXIO = 68,
381 #[doc = "69 - LCDIF"]
382 LCDIF = 69,
383 #[doc = "71 - MIPI"]
384 MIPI = 71,
385}
386unsafe impl cortex_m::interrupt::InterruptNumber for Interrupt {
387 #[inline(always)]
388 fn number(self) -> u16 {
389 self as u16
390 }
391}
392#[doc = "Reset Controller 0"]
393pub struct RSTCTL0 {
394 _marker: PhantomData<*const ()>,
395}
396unsafe impl Send for RSTCTL0 {}
397impl RSTCTL0 {
398 #[doc = r"Pointer to the register block"]
399 pub const PTR: *const rstctl0::RegisterBlock = 0x4000_0000 as *const _;
400 #[doc = r"Return the pointer to the register block"]
401 #[inline(always)]
402 pub const fn ptr() -> *const rstctl0::RegisterBlock {
403 Self::PTR
404 }
405}
406impl Deref for RSTCTL0 {
407 type Target = rstctl0::RegisterBlock;
408 #[inline(always)]
409 fn deref(&self) -> &Self::Target {
410 unsafe { &*Self::PTR }
411 }
412}
413impl core::fmt::Debug for RSTCTL0 {
414 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
415 f.debug_struct("RSTCTL0").finish()
416 }
417}
418#[doc = "Reset Controller 0"]
419pub mod rstctl0;
420#[doc = "Clock Controller 0"]
421pub struct CLKCTL0 {
422 _marker: PhantomData<*const ()>,
423}
424unsafe impl Send for CLKCTL0 {}
425impl CLKCTL0 {
426 #[doc = r"Pointer to the register block"]
427 pub const PTR: *const clkctl0::RegisterBlock = 0x4000_1000 as *const _;
428 #[doc = r"Return the pointer to the register block"]
429 #[inline(always)]
430 pub const fn ptr() -> *const clkctl0::RegisterBlock {
431 Self::PTR
432 }
433}
434impl Deref for CLKCTL0 {
435 type Target = clkctl0::RegisterBlock;
436 #[inline(always)]
437 fn deref(&self) -> &Self::Target {
438 unsafe { &*Self::PTR }
439 }
440}
441impl core::fmt::Debug for CLKCTL0 {
442 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
443 f.debug_struct("CLKCTL0").finish()
444 }
445}
446#[doc = "Clock Controller 0"]
447pub mod clkctl0;
448#[doc = "SYSCTL0"]
449pub struct SYSCTL0 {
450 _marker: PhantomData<*const ()>,
451}
452unsafe impl Send for SYSCTL0 {}
453impl SYSCTL0 {
454 #[doc = r"Pointer to the register block"]
455 pub const PTR: *const sysctl0::RegisterBlock = 0x4000_2000 as *const _;
456 #[doc = r"Return the pointer to the register block"]
457 #[inline(always)]
458 pub const fn ptr() -> *const sysctl0::RegisterBlock {
459 Self::PTR
460 }
461}
462impl Deref for SYSCTL0 {
463 type Target = sysctl0::RegisterBlock;
464 #[inline(always)]
465 fn deref(&self) -> &Self::Target {
466 unsafe { &*Self::PTR }
467 }
468}
469impl core::fmt::Debug for SYSCTL0 {
470 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
471 f.debug_struct("SYSCTL0").finish()
472 }
473}
474#[doc = "SYSCTL0"]
475pub mod sysctl0;
476#[doc = "IOPCTL"]
477pub struct IOPCTL {
478 _marker: PhantomData<*const ()>,
479}
480unsafe impl Send for IOPCTL {}
481impl IOPCTL {
482 #[doc = r"Pointer to the register block"]
483 pub const PTR: *const iopctl::RegisterBlock = 0x4000_4000 as *const _;
484 #[doc = r"Return the pointer to the register block"]
485 #[inline(always)]
486 pub const fn ptr() -> *const iopctl::RegisterBlock {
487 Self::PTR
488 }
489}
490impl Deref for IOPCTL {
491 type Target = iopctl::RegisterBlock;
492 #[inline(always)]
493 fn deref(&self) -> &Self::Target {
494 unsafe { &*Self::PTR }
495 }
496}
497impl core::fmt::Debug for IOPCTL {
498 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
499 f.debug_struct("IOPCTL").finish()
500 }
501}
502#[doc = "IOPCTL"]
503pub mod iopctl;
504#[doc = "PUF Controller"]
505pub struct PUF {
506 _marker: PhantomData<*const ()>,
507}
508unsafe impl Send for PUF {}
509impl PUF {
510 #[doc = r"Pointer to the register block"]
511 pub const PTR: *const puf::RegisterBlock = 0x4000_6000 as *const _;
512 #[doc = r"Return the pointer to the register block"]
513 #[inline(always)]
514 pub const fn ptr() -> *const puf::RegisterBlock {
515 Self::PTR
516 }
517}
518impl Deref for PUF {
519 type Target = puf::RegisterBlock;
520 #[inline(always)]
521 fn deref(&self) -> &Self::Target {
522 unsafe { &*Self::PTR }
523 }
524}
525impl core::fmt::Debug for PUF {
526 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
527 f.debug_struct("PUF").finish()
528 }
529}
530#[doc = "PUF Controller"]
531pub mod puf;
532#[doc = "WWDT"]
533pub struct WWDT0 {
534 _marker: PhantomData<*const ()>,
535}
536unsafe impl Send for WWDT0 {}
537impl WWDT0 {
538 #[doc = r"Pointer to the register block"]
539 pub const PTR: *const wwdt0::RegisterBlock = 0x4000_e000 as *const _;
540 #[doc = r"Return the pointer to the register block"]
541 #[inline(always)]
542 pub const fn ptr() -> *const wwdt0::RegisterBlock {
543 Self::PTR
544 }
545}
546impl Deref for WWDT0 {
547 type Target = wwdt0::RegisterBlock;
548 #[inline(always)]
549 fn deref(&self) -> &Self::Target {
550 unsafe { &*Self::PTR }
551 }
552}
553impl core::fmt::Debug for WWDT0 {
554 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
555 f.debug_struct("WWDT0").finish()
556 }
557}
558#[doc = "WWDT"]
559pub mod wwdt0;
560#[doc = "WWDT"]
561pub struct WWDT1 {
562 _marker: PhantomData<*const ()>,
563}
564unsafe impl Send for WWDT1 {}
565impl WWDT1 {
566 #[doc = r"Pointer to the register block"]
567 pub const PTR: *const wwdt0::RegisterBlock = 0x4002_e000 as *const _;
568 #[doc = r"Return the pointer to the register block"]
569 #[inline(always)]
570 pub const fn ptr() -> *const wwdt0::RegisterBlock {
571 Self::PTR
572 }
573}
574impl Deref for WWDT1 {
575 type Target = wwdt0::RegisterBlock;
576 #[inline(always)]
577 fn deref(&self) -> &Self::Target {
578 unsafe { &*Self::PTR }
579 }
580}
581impl core::fmt::Debug for WWDT1 {
582 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
583 f.debug_struct("WWDT1").finish()
584 }
585}
586#[doc = "WWDT"]
587pub use self::wwdt0 as wwdt1;
588#[doc = "UTICK"]
589pub struct UTICK0 {
590 _marker: PhantomData<*const ()>,
591}
592unsafe impl Send for UTICK0 {}
593impl UTICK0 {
594 #[doc = r"Pointer to the register block"]
595 pub const PTR: *const utick0::RegisterBlock = 0x4000_f000 as *const _;
596 #[doc = r"Return the pointer to the register block"]
597 #[inline(always)]
598 pub const fn ptr() -> *const utick0::RegisterBlock {
599 Self::PTR
600 }
601}
602impl Deref for UTICK0 {
603 type Target = utick0::RegisterBlock;
604 #[inline(always)]
605 fn deref(&self) -> &Self::Target {
606 unsafe { &*Self::PTR }
607 }
608}
609impl core::fmt::Debug for UTICK0 {
610 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
611 f.debug_struct("UTICK0").finish()
612 }
613}
614#[doc = "UTICK"]
615pub mod utick0;
616#[doc = "Reset Controller 1"]
617pub struct RSTCTL1 {
618 _marker: PhantomData<*const ()>,
619}
620unsafe impl Send for RSTCTL1 {}
621impl RSTCTL1 {
622 #[doc = r"Pointer to the register block"]
623 pub const PTR: *const rstctl1::RegisterBlock = 0x4002_0000 as *const _;
624 #[doc = r"Return the pointer to the register block"]
625 #[inline(always)]
626 pub const fn ptr() -> *const rstctl1::RegisterBlock {
627 Self::PTR
628 }
629}
630impl Deref for RSTCTL1 {
631 type Target = rstctl1::RegisterBlock;
632 #[inline(always)]
633 fn deref(&self) -> &Self::Target {
634 unsafe { &*Self::PTR }
635 }
636}
637impl core::fmt::Debug for RSTCTL1 {
638 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
639 f.debug_struct("RSTCTL1").finish()
640 }
641}
642#[doc = "Reset Controller 1"]
643pub mod rstctl1;
644#[doc = "Clock Controller 1"]
645pub struct CLKCTL1 {
646 _marker: PhantomData<*const ()>,
647}
648unsafe impl Send for CLKCTL1 {}
649impl CLKCTL1 {
650 #[doc = r"Pointer to the register block"]
651 pub const PTR: *const clkctl1::RegisterBlock = 0x4002_1000 as *const _;
652 #[doc = r"Return the pointer to the register block"]
653 #[inline(always)]
654 pub const fn ptr() -> *const clkctl1::RegisterBlock {
655 Self::PTR
656 }
657}
658impl Deref for CLKCTL1 {
659 type Target = clkctl1::RegisterBlock;
660 #[inline(always)]
661 fn deref(&self) -> &Self::Target {
662 unsafe { &*Self::PTR }
663 }
664}
665impl core::fmt::Debug for CLKCTL1 {
666 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
667 f.debug_struct("CLKCTL1").finish()
668 }
669}
670#[doc = "Clock Controller 1"]
671pub mod clkctl1;
672#[doc = "SYSCTL1"]
673pub struct SYSCTL1 {
674 _marker: PhantomData<*const ()>,
675}
676unsafe impl Send for SYSCTL1 {}
677impl SYSCTL1 {
678 #[doc = r"Pointer to the register block"]
679 pub const PTR: *const sysctl1::RegisterBlock = 0x4002_2000 as *const _;
680 #[doc = r"Return the pointer to the register block"]
681 #[inline(always)]
682 pub const fn ptr() -> *const sysctl1::RegisterBlock {
683 Self::PTR
684 }
685}
686impl Deref for SYSCTL1 {
687 type Target = sysctl1::RegisterBlock;
688 #[inline(always)]
689 fn deref(&self) -> &Self::Target {
690 unsafe { &*Self::PTR }
691 }
692}
693impl core::fmt::Debug for SYSCTL1 {
694 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
695 f.debug_struct("SYSCTL1").finish()
696 }
697}
698#[doc = "SYSCTL1"]
699pub mod sysctl1;
700#[doc = "Pin Interrupts and Pattern Match"]
701pub struct PINT {
702 _marker: PhantomData<*const ()>,
703}
704unsafe impl Send for PINT {}
705impl PINT {
706 #[doc = r"Pointer to the register block"]
707 pub const PTR: *const pint::RegisterBlock = 0x4002_5000 as *const _;
708 #[doc = r"Return the pointer to the register block"]
709 #[inline(always)]
710 pub const fn ptr() -> *const pint::RegisterBlock {
711 Self::PTR
712 }
713}
714impl Deref for PINT {
715 type Target = pint::RegisterBlock;
716 #[inline(always)]
717 fn deref(&self) -> &Self::Target {
718 unsafe { &*Self::PTR }
719 }
720}
721impl core::fmt::Debug for PINT {
722 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
723 f.debug_struct("PINT").finish()
724 }
725}
726#[doc = "Pin Interrupts and Pattern Match"]
727pub mod pint;
728#[doc = "INPUTMUX"]
729pub struct INPUTMUX {
730 _marker: PhantomData<*const ()>,
731}
732unsafe impl Send for INPUTMUX {}
733impl INPUTMUX {
734 #[doc = r"Pointer to the register block"]
735 pub const PTR: *const inputmux::RegisterBlock = 0x4002_6000 as *const _;
736 #[doc = r"Return the pointer to the register block"]
737 #[inline(always)]
738 pub const fn ptr() -> *const inputmux::RegisterBlock {
739 Self::PTR
740 }
741}
742impl Deref for INPUTMUX {
743 type Target = inputmux::RegisterBlock;
744 #[inline(always)]
745 fn deref(&self) -> &Self::Target {
746 unsafe { &*Self::PTR }
747 }
748}
749impl core::fmt::Debug for INPUTMUX {
750 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
751 f.debug_struct("INPUTMUX").finish()
752 }
753}
754#[doc = "INPUTMUX"]
755pub mod inputmux;
756#[doc = "Counter/Timer"]
757pub struct CTIMER0 {
758 _marker: PhantomData<*const ()>,
759}
760unsafe impl Send for CTIMER0 {}
761impl CTIMER0 {
762 #[doc = r"Pointer to the register block"]
763 pub const PTR: *const ctimer0::RegisterBlock = 0x4002_8000 as *const _;
764 #[doc = r"Return the pointer to the register block"]
765 #[inline(always)]
766 pub const fn ptr() -> *const ctimer0::RegisterBlock {
767 Self::PTR
768 }
769}
770impl Deref for CTIMER0 {
771 type Target = ctimer0::RegisterBlock;
772 #[inline(always)]
773 fn deref(&self) -> &Self::Target {
774 unsafe { &*Self::PTR }
775 }
776}
777impl core::fmt::Debug for CTIMER0 {
778 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
779 f.debug_struct("CTIMER0").finish()
780 }
781}
782#[doc = "Counter/Timer"]
783pub mod ctimer0;
784#[doc = "Counter/Timer"]
785pub struct CTIMER1 {
786 _marker: PhantomData<*const ()>,
787}
788unsafe impl Send for CTIMER1 {}
789impl CTIMER1 {
790 #[doc = r"Pointer to the register block"]
791 pub const PTR: *const ctimer0::RegisterBlock = 0x4002_9000 as *const _;
792 #[doc = r"Return the pointer to the register block"]
793 #[inline(always)]
794 pub const fn ptr() -> *const ctimer0::RegisterBlock {
795 Self::PTR
796 }
797}
798impl Deref for CTIMER1 {
799 type Target = ctimer0::RegisterBlock;
800 #[inline(always)]
801 fn deref(&self) -> &Self::Target {
802 unsafe { &*Self::PTR }
803 }
804}
805impl core::fmt::Debug for CTIMER1 {
806 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
807 f.debug_struct("CTIMER1").finish()
808 }
809}
810#[doc = "Counter/Timer"]
811pub use self::ctimer0 as ctimer1;
812#[doc = "Counter/Timer"]
813pub struct CTIMER2 {
814 _marker: PhantomData<*const ()>,
815}
816unsafe impl Send for CTIMER2 {}
817impl CTIMER2 {
818 #[doc = r"Pointer to the register block"]
819 pub const PTR: *const ctimer0::RegisterBlock = 0x4002_a000 as *const _;
820 #[doc = r"Return the pointer to the register block"]
821 #[inline(always)]
822 pub const fn ptr() -> *const ctimer0::RegisterBlock {
823 Self::PTR
824 }
825}
826impl Deref for CTIMER2 {
827 type Target = ctimer0::RegisterBlock;
828 #[inline(always)]
829 fn deref(&self) -> &Self::Target {
830 unsafe { &*Self::PTR }
831 }
832}
833impl core::fmt::Debug for CTIMER2 {
834 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
835 f.debug_struct("CTIMER2").finish()
836 }
837}
838#[doc = "Counter/Timer"]
839pub use self::ctimer0 as ctimer2;
840#[doc = "Counter/Timer"]
841pub struct CTIMER3 {
842 _marker: PhantomData<*const ()>,
843}
844unsafe impl Send for CTIMER3 {}
845impl CTIMER3 {
846 #[doc = r"Pointer to the register block"]
847 pub const PTR: *const ctimer0::RegisterBlock = 0x4002_b000 as *const _;
848 #[doc = r"Return the pointer to the register block"]
849 #[inline(always)]
850 pub const fn ptr() -> *const ctimer0::RegisterBlock {
851 Self::PTR
852 }
853}
854impl Deref for CTIMER3 {
855 type Target = ctimer0::RegisterBlock;
856 #[inline(always)]
857 fn deref(&self) -> &Self::Target {
858 unsafe { &*Self::PTR }
859 }
860}
861impl core::fmt::Debug for CTIMER3 {
862 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
863 f.debug_struct("CTIMER3").finish()
864 }
865}
866#[doc = "Counter/Timer"]
867pub use self::ctimer0 as ctimer3;
868#[doc = "Counter/Timer"]
869pub struct CTIMER4 {
870 _marker: PhantomData<*const ()>,
871}
872unsafe impl Send for CTIMER4 {}
873impl CTIMER4 {
874 #[doc = r"Pointer to the register block"]
875 pub const PTR: *const ctimer0::RegisterBlock = 0x4002_c000 as *const _;
876 #[doc = r"Return the pointer to the register block"]
877 #[inline(always)]
878 pub const fn ptr() -> *const ctimer0::RegisterBlock {
879 Self::PTR
880 }
881}
882impl Deref for CTIMER4 {
883 type Target = ctimer0::RegisterBlock;
884 #[inline(always)]
885 fn deref(&self) -> &Self::Target {
886 unsafe { &*Self::PTR }
887 }
888}
889impl core::fmt::Debug for CTIMER4 {
890 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
891 f.debug_struct("CTIMER4").finish()
892 }
893}
894#[doc = "Counter/Timer"]
895pub use self::ctimer0 as ctimer4;
896#[doc = "Multi-Rate Timer (MRT)"]
897pub struct MRT0 {
898 _marker: PhantomData<*const ()>,
899}
900unsafe impl Send for MRT0 {}
901impl MRT0 {
902 #[doc = r"Pointer to the register block"]
903 pub const PTR: *const mrt0::RegisterBlock = 0x4002_d000 as *const _;
904 #[doc = r"Return the pointer to the register block"]
905 #[inline(always)]
906 pub const fn ptr() -> *const mrt0::RegisterBlock {
907 Self::PTR
908 }
909}
910impl Deref for MRT0 {
911 type Target = mrt0::RegisterBlock;
912 #[inline(always)]
913 fn deref(&self) -> &Self::Target {
914 unsafe { &*Self::PTR }
915 }
916}
917impl core::fmt::Debug for MRT0 {
918 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
919 f.debug_struct("MRT0").finish()
920 }
921}
922#[doc = "Multi-Rate Timer (MRT)"]
923pub mod mrt0;
924#[doc = "Frequency Measurement"]
925pub struct FREQME {
926 _marker: PhantomData<*const ()>,
927}
928unsafe impl Send for FREQME {}
929impl FREQME {
930 #[doc = r"Pointer to the register block"]
931 pub const PTR: *const freqme::RegisterBlock = 0x4002_f000 as *const _;
932 #[doc = r"Return the pointer to the register block"]
933 #[inline(always)]
934 pub const fn ptr() -> *const freqme::RegisterBlock {
935 Self::PTR
936 }
937}
938impl Deref for FREQME {
939 type Target = freqme::RegisterBlock;
940 #[inline(always)]
941 fn deref(&self) -> &Self::Target {
942 unsafe { &*Self::PTR }
943 }
944}
945impl core::fmt::Debug for FREQME {
946 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
947 f.debug_struct("FREQME").finish()
948 }
949}
950#[doc = "Frequency Measurement"]
951pub mod freqme;
952#[doc = "RTC"]
953pub struct RTC {
954 _marker: PhantomData<*const ()>,
955}
956unsafe impl Send for RTC {}
957impl RTC {
958 #[doc = r"Pointer to the register block"]
959 pub const PTR: *const rtc::RegisterBlock = 0x4003_0000 as *const _;
960 #[doc = r"Return the pointer to the register block"]
961 #[inline(always)]
962 pub const fn ptr() -> *const rtc::RegisterBlock {
963 Self::PTR
964 }
965}
966impl Deref for RTC {
967 type Target = rtc::RegisterBlock;
968 #[inline(always)]
969 fn deref(&self) -> &Self::Target {
970 unsafe { &*Self::PTR }
971 }
972}
973impl core::fmt::Debug for RTC {
974 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
975 f.debug_struct("RTC").finish()
976 }
977}
978#[doc = "RTC"]
979pub mod rtc;
980#[doc = "MIPI DSI Host"]
981pub struct MIPI_DSI_HOST {
982 _marker: PhantomData<*const ()>,
983}
984unsafe impl Send for MIPI_DSI_HOST {}
985impl MIPI_DSI_HOST {
986 #[doc = r"Pointer to the register block"]
987 pub const PTR: *const mipi_dsi_host::RegisterBlock = 0x4003_1000 as *const _;
988 #[doc = r"Return the pointer to the register block"]
989 #[inline(always)]
990 pub const fn ptr() -> *const mipi_dsi_host::RegisterBlock {
991 Self::PTR
992 }
993}
994impl Deref for MIPI_DSI_HOST {
995 type Target = mipi_dsi_host::RegisterBlock;
996 #[inline(always)]
997 fn deref(&self) -> &Self::Target {
998 unsafe { &*Self::PTR }
999 }
1000}
1001impl core::fmt::Debug for MIPI_DSI_HOST {
1002 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1003 f.debug_struct("MIPI_DSI_HOST").finish()
1004 }
1005}
1006#[doc = "MIPI DSI Host"]
1007pub mod mipi_dsi_host;
1008#[doc = "FLEXIO"]
1009pub struct FLEXIO0 {
1010 _marker: PhantomData<*const ()>,
1011}
1012unsafe impl Send for FLEXIO0 {}
1013impl FLEXIO0 {
1014 #[doc = r"Pointer to the register block"]
1015 pub const PTR: *const flexio0::RegisterBlock = 0x4003_2000 as *const _;
1016 #[doc = r"Return the pointer to the register block"]
1017 #[inline(always)]
1018 pub const fn ptr() -> *const flexio0::RegisterBlock {
1019 Self::PTR
1020 }
1021}
1022impl Deref for FLEXIO0 {
1023 type Target = flexio0::RegisterBlock;
1024 #[inline(always)]
1025 fn deref(&self) -> &Self::Target {
1026 unsafe { &*Self::PTR }
1027 }
1028}
1029impl core::fmt::Debug for FLEXIO0 {
1030 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1031 f.debug_struct("FLEXIO0").finish()
1032 }
1033}
1034#[doc = "FLEXIO"]
1035pub mod flexio0;
1036#[doc = "CACHE64"]
1037pub struct CACHE64_CTRL0 {
1038 _marker: PhantomData<*const ()>,
1039}
1040unsafe impl Send for CACHE64_CTRL0 {}
1041impl CACHE64_CTRL0 {
1042 #[doc = r"Pointer to the register block"]
1043 pub const PTR: *const cache64_ctrl0::RegisterBlock = 0x4003_3000 as *const _;
1044 #[doc = r"Return the pointer to the register block"]
1045 #[inline(always)]
1046 pub const fn ptr() -> *const cache64_ctrl0::RegisterBlock {
1047 Self::PTR
1048 }
1049}
1050impl Deref for CACHE64_CTRL0 {
1051 type Target = cache64_ctrl0::RegisterBlock;
1052 #[inline(always)]
1053 fn deref(&self) -> &Self::Target {
1054 unsafe { &*Self::PTR }
1055 }
1056}
1057impl core::fmt::Debug for CACHE64_CTRL0 {
1058 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1059 f.debug_struct("CACHE64_CTRL0").finish()
1060 }
1061}
1062#[doc = "CACHE64"]
1063pub mod cache64_ctrl0;
1064#[doc = "CACHE64"]
1065pub struct CACHE64_CTRL1 {
1066 _marker: PhantomData<*const ()>,
1067}
1068unsafe impl Send for CACHE64_CTRL1 {}
1069impl CACHE64_CTRL1 {
1070 #[doc = r"Pointer to the register block"]
1071 pub const PTR: *const cache64_ctrl0::RegisterBlock = 0x4003_4000 as *const _;
1072 #[doc = r"Return the pointer to the register block"]
1073 #[inline(always)]
1074 pub const fn ptr() -> *const cache64_ctrl0::RegisterBlock {
1075 Self::PTR
1076 }
1077}
1078impl Deref for CACHE64_CTRL1 {
1079 type Target = cache64_ctrl0::RegisterBlock;
1080 #[inline(always)]
1081 fn deref(&self) -> &Self::Target {
1082 unsafe { &*Self::PTR }
1083 }
1084}
1085impl core::fmt::Debug for CACHE64_CTRL1 {
1086 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1087 f.debug_struct("CACHE64_CTRL1").finish()
1088 }
1089}
1090#[doc = "CACHE64"]
1091pub use self::cache64_ctrl0 as cache64_ctrl1;
1092#[doc = "CACHE64_POLSEL"]
1093pub struct CACHE64_POLSEL0 {
1094 _marker: PhantomData<*const ()>,
1095}
1096unsafe impl Send for CACHE64_POLSEL0 {}
1097impl CACHE64_POLSEL0 {
1098 #[doc = r"Pointer to the register block"]
1099 pub const PTR: *const cache64_polsel0::RegisterBlock = 0x4003_3000 as *const _;
1100 #[doc = r"Return the pointer to the register block"]
1101 #[inline(always)]
1102 pub const fn ptr() -> *const cache64_polsel0::RegisterBlock {
1103 Self::PTR
1104 }
1105}
1106impl Deref for CACHE64_POLSEL0 {
1107 type Target = cache64_polsel0::RegisterBlock;
1108 #[inline(always)]
1109 fn deref(&self) -> &Self::Target {
1110 unsafe { &*Self::PTR }
1111 }
1112}
1113impl core::fmt::Debug for CACHE64_POLSEL0 {
1114 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1115 f.debug_struct("CACHE64_POLSEL0").finish()
1116 }
1117}
1118#[doc = "CACHE64_POLSEL"]
1119pub mod cache64_polsel0;
1120#[doc = "CACHE64_POLSEL"]
1121pub struct CACHE64_POLSEL1 {
1122 _marker: PhantomData<*const ()>,
1123}
1124unsafe impl Send for CACHE64_POLSEL1 {}
1125impl CACHE64_POLSEL1 {
1126 #[doc = r"Pointer to the register block"]
1127 pub const PTR: *const cache64_polsel0::RegisterBlock = 0x4003_4000 as *const _;
1128 #[doc = r"Return the pointer to the register block"]
1129 #[inline(always)]
1130 pub const fn ptr() -> *const cache64_polsel0::RegisterBlock {
1131 Self::PTR
1132 }
1133}
1134impl Deref for CACHE64_POLSEL1 {
1135 type Target = cache64_polsel0::RegisterBlock;
1136 #[inline(always)]
1137 fn deref(&self) -> &Self::Target {
1138 unsafe { &*Self::PTR }
1139 }
1140}
1141impl core::fmt::Debug for CACHE64_POLSEL1 {
1142 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1143 f.debug_struct("CACHE64_POLSEL1").finish()
1144 }
1145}
1146#[doc = "CACHE64_POLSEL"]
1147pub use self::cache64_polsel0 as cache64_polsel1;
1148#[doc = "I3C"]
1149pub struct I3C0 {
1150 _marker: PhantomData<*const ()>,
1151}
1152unsafe impl Send for I3C0 {}
1153impl I3C0 {
1154 #[doc = r"Pointer to the register block"]
1155 pub const PTR: *const i3c0::RegisterBlock = 0x4003_6000 as *const _;
1156 #[doc = r"Return the pointer to the register block"]
1157 #[inline(always)]
1158 pub const fn ptr() -> *const i3c0::RegisterBlock {
1159 Self::PTR
1160 }
1161}
1162impl Deref for I3C0 {
1163 type Target = i3c0::RegisterBlock;
1164 #[inline(always)]
1165 fn deref(&self) -> &Self::Target {
1166 unsafe { &*Self::PTR }
1167 }
1168}
1169impl core::fmt::Debug for I3C0 {
1170 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1171 f.debug_struct("I3C0").finish()
1172 }
1173}
1174#[doc = "I3C"]
1175pub mod i3c0;
1176#[doc = "I3C"]
1177pub struct I3C1 {
1178 _marker: PhantomData<*const ()>,
1179}
1180unsafe impl Send for I3C1 {}
1181impl I3C1 {
1182 #[doc = r"Pointer to the register block"]
1183 pub const PTR: *const i3c0::RegisterBlock = 0x4003_7000 as *const _;
1184 #[doc = r"Return the pointer to the register block"]
1185 #[inline(always)]
1186 pub const fn ptr() -> *const i3c0::RegisterBlock {
1187 Self::PTR
1188 }
1189}
1190impl Deref for I3C1 {
1191 type Target = i3c0::RegisterBlock;
1192 #[inline(always)]
1193 fn deref(&self) -> &Self::Target {
1194 unsafe { &*Self::PTR }
1195 }
1196}
1197impl core::fmt::Debug for I3C1 {
1198 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1199 f.debug_struct("I3C1").finish()
1200 }
1201}
1202#[doc = "I3C"]
1203pub use self::i3c0 as i3c1;
1204#[doc = "GPIO General Purpose I/O (GPIO)"]
1205pub struct GPIO {
1206 _marker: PhantomData<*const ()>,
1207}
1208unsafe impl Send for GPIO {}
1209impl GPIO {
1210 #[doc = r"Pointer to the register block"]
1211 pub const PTR: *const gpio::RegisterBlock = 0x4010_0000 as *const _;
1212 #[doc = r"Return the pointer to the register block"]
1213 #[inline(always)]
1214 pub const fn ptr() -> *const gpio::RegisterBlock {
1215 Self::PTR
1216 }
1217}
1218impl Deref for GPIO {
1219 type Target = gpio::RegisterBlock;
1220 #[inline(always)]
1221 fn deref(&self) -> &Self::Target {
1222 unsafe { &*Self::PTR }
1223 }
1224}
1225impl core::fmt::Debug for GPIO {
1226 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1227 f.debug_struct("GPIO").finish()
1228 }
1229}
1230#[doc = "GPIO General Purpose I/O (GPIO)"]
1231pub mod gpio;
1232#[doc = "DMA0 controller"]
1233pub struct DMA0 {
1234 _marker: PhantomData<*const ()>,
1235}
1236unsafe impl Send for DMA0 {}
1237impl DMA0 {
1238 #[doc = r"Pointer to the register block"]
1239 pub const PTR: *const dma0::RegisterBlock = 0x4010_4000 as *const _;
1240 #[doc = r"Return the pointer to the register block"]
1241 #[inline(always)]
1242 pub const fn ptr() -> *const dma0::RegisterBlock {
1243 Self::PTR
1244 }
1245}
1246impl Deref for DMA0 {
1247 type Target = dma0::RegisterBlock;
1248 #[inline(always)]
1249 fn deref(&self) -> &Self::Target {
1250 unsafe { &*Self::PTR }
1251 }
1252}
1253impl core::fmt::Debug for DMA0 {
1254 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1255 f.debug_struct("DMA0").finish()
1256 }
1257}
1258#[doc = "DMA0 controller"]
1259pub mod dma0;
1260#[doc = "DMA1 controller"]
1261pub struct DMA1 {
1262 _marker: PhantomData<*const ()>,
1263}
1264unsafe impl Send for DMA1 {}
1265impl DMA1 {
1266 #[doc = r"Pointer to the register block"]
1267 pub const PTR: *const dma0::RegisterBlock = 0x4010_5000 as *const _;
1268 #[doc = r"Return the pointer to the register block"]
1269 #[inline(always)]
1270 pub const fn ptr() -> *const dma0::RegisterBlock {
1271 Self::PTR
1272 }
1273}
1274impl Deref for DMA1 {
1275 type Target = dma0::RegisterBlock;
1276 #[inline(always)]
1277 fn deref(&self) -> &Self::Target {
1278 unsafe { &*Self::PTR }
1279 }
1280}
1281impl core::fmt::Debug for DMA1 {
1282 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1283 f.debug_struct("DMA1").finish()
1284 }
1285}
1286#[doc = "DMA1 controller"]
1287pub use self::dma0 as dma1;
1288#[doc = "Flexcomm"]
1289pub struct FLEXCOMM0 {
1290 _marker: PhantomData<*const ()>,
1291}
1292unsafe impl Send for FLEXCOMM0 {}
1293impl FLEXCOMM0 {
1294 #[doc = r"Pointer to the register block"]
1295 pub const PTR: *const flexcomm0::RegisterBlock = 0x4010_6000 as *const _;
1296 #[doc = r"Return the pointer to the register block"]
1297 #[inline(always)]
1298 pub const fn ptr() -> *const flexcomm0::RegisterBlock {
1299 Self::PTR
1300 }
1301}
1302impl Deref for FLEXCOMM0 {
1303 type Target = flexcomm0::RegisterBlock;
1304 #[inline(always)]
1305 fn deref(&self) -> &Self::Target {
1306 unsafe { &*Self::PTR }
1307 }
1308}
1309impl core::fmt::Debug for FLEXCOMM0 {
1310 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1311 f.debug_struct("FLEXCOMM0").finish()
1312 }
1313}
1314#[doc = "Flexcomm"]
1315pub mod flexcomm0;
1316#[doc = "Flexcomm"]
1317pub struct FLEXCOMM1 {
1318 _marker: PhantomData<*const ()>,
1319}
1320unsafe impl Send for FLEXCOMM1 {}
1321impl FLEXCOMM1 {
1322 #[doc = r"Pointer to the register block"]
1323 pub const PTR: *const flexcomm0::RegisterBlock = 0x4010_7000 as *const _;
1324 #[doc = r"Return the pointer to the register block"]
1325 #[inline(always)]
1326 pub const fn ptr() -> *const flexcomm0::RegisterBlock {
1327 Self::PTR
1328 }
1329}
1330impl Deref for FLEXCOMM1 {
1331 type Target = flexcomm0::RegisterBlock;
1332 #[inline(always)]
1333 fn deref(&self) -> &Self::Target {
1334 unsafe { &*Self::PTR }
1335 }
1336}
1337impl core::fmt::Debug for FLEXCOMM1 {
1338 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1339 f.debug_struct("FLEXCOMM1").finish()
1340 }
1341}
1342#[doc = "Flexcomm"]
1343pub use self::flexcomm0 as flexcomm1;
1344#[doc = "Flexcomm"]
1345pub struct FLEXCOMM2 {
1346 _marker: PhantomData<*const ()>,
1347}
1348unsafe impl Send for FLEXCOMM2 {}
1349impl FLEXCOMM2 {
1350 #[doc = r"Pointer to the register block"]
1351 pub const PTR: *const flexcomm0::RegisterBlock = 0x4010_8000 as *const _;
1352 #[doc = r"Return the pointer to the register block"]
1353 #[inline(always)]
1354 pub const fn ptr() -> *const flexcomm0::RegisterBlock {
1355 Self::PTR
1356 }
1357}
1358impl Deref for FLEXCOMM2 {
1359 type Target = flexcomm0::RegisterBlock;
1360 #[inline(always)]
1361 fn deref(&self) -> &Self::Target {
1362 unsafe { &*Self::PTR }
1363 }
1364}
1365impl core::fmt::Debug for FLEXCOMM2 {
1366 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1367 f.debug_struct("FLEXCOMM2").finish()
1368 }
1369}
1370#[doc = "Flexcomm"]
1371pub use self::flexcomm0 as flexcomm2;
1372#[doc = "Flexcomm"]
1373pub struct FLEXCOMM3 {
1374 _marker: PhantomData<*const ()>,
1375}
1376unsafe impl Send for FLEXCOMM3 {}
1377impl FLEXCOMM3 {
1378 #[doc = r"Pointer to the register block"]
1379 pub const PTR: *const flexcomm0::RegisterBlock = 0x4010_9000 as *const _;
1380 #[doc = r"Return the pointer to the register block"]
1381 #[inline(always)]
1382 pub const fn ptr() -> *const flexcomm0::RegisterBlock {
1383 Self::PTR
1384 }
1385}
1386impl Deref for FLEXCOMM3 {
1387 type Target = flexcomm0::RegisterBlock;
1388 #[inline(always)]
1389 fn deref(&self) -> &Self::Target {
1390 unsafe { &*Self::PTR }
1391 }
1392}
1393impl core::fmt::Debug for FLEXCOMM3 {
1394 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1395 f.debug_struct("FLEXCOMM3").finish()
1396 }
1397}
1398#[doc = "Flexcomm"]
1399pub use self::flexcomm0 as flexcomm3;
1400#[doc = "Flexcomm"]
1401pub struct FLEXCOMM4 {
1402 _marker: PhantomData<*const ()>,
1403}
1404unsafe impl Send for FLEXCOMM4 {}
1405impl FLEXCOMM4 {
1406 #[doc = r"Pointer to the register block"]
1407 pub const PTR: *const flexcomm0::RegisterBlock = 0x4012_2000 as *const _;
1408 #[doc = r"Return the pointer to the register block"]
1409 #[inline(always)]
1410 pub const fn ptr() -> *const flexcomm0::RegisterBlock {
1411 Self::PTR
1412 }
1413}
1414impl Deref for FLEXCOMM4 {
1415 type Target = flexcomm0::RegisterBlock;
1416 #[inline(always)]
1417 fn deref(&self) -> &Self::Target {
1418 unsafe { &*Self::PTR }
1419 }
1420}
1421impl core::fmt::Debug for FLEXCOMM4 {
1422 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1423 f.debug_struct("FLEXCOMM4").finish()
1424 }
1425}
1426#[doc = "Flexcomm"]
1427pub use self::flexcomm0 as flexcomm4;
1428#[doc = "Flexcomm"]
1429pub struct FLEXCOMM5 {
1430 _marker: PhantomData<*const ()>,
1431}
1432unsafe impl Send for FLEXCOMM5 {}
1433impl FLEXCOMM5 {
1434 #[doc = r"Pointer to the register block"]
1435 pub const PTR: *const flexcomm0::RegisterBlock = 0x4012_3000 as *const _;
1436 #[doc = r"Return the pointer to the register block"]
1437 #[inline(always)]
1438 pub const fn ptr() -> *const flexcomm0::RegisterBlock {
1439 Self::PTR
1440 }
1441}
1442impl Deref for FLEXCOMM5 {
1443 type Target = flexcomm0::RegisterBlock;
1444 #[inline(always)]
1445 fn deref(&self) -> &Self::Target {
1446 unsafe { &*Self::PTR }
1447 }
1448}
1449impl core::fmt::Debug for FLEXCOMM5 {
1450 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1451 f.debug_struct("FLEXCOMM5").finish()
1452 }
1453}
1454#[doc = "Flexcomm"]
1455pub use self::flexcomm0 as flexcomm5;
1456#[doc = "Flexcomm"]
1457pub struct FLEXCOMM6 {
1458 _marker: PhantomData<*const ()>,
1459}
1460unsafe impl Send for FLEXCOMM6 {}
1461impl FLEXCOMM6 {
1462 #[doc = r"Pointer to the register block"]
1463 pub const PTR: *const flexcomm0::RegisterBlock = 0x4012_4000 as *const _;
1464 #[doc = r"Return the pointer to the register block"]
1465 #[inline(always)]
1466 pub const fn ptr() -> *const flexcomm0::RegisterBlock {
1467 Self::PTR
1468 }
1469}
1470impl Deref for FLEXCOMM6 {
1471 type Target = flexcomm0::RegisterBlock;
1472 #[inline(always)]
1473 fn deref(&self) -> &Self::Target {
1474 unsafe { &*Self::PTR }
1475 }
1476}
1477impl core::fmt::Debug for FLEXCOMM6 {
1478 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1479 f.debug_struct("FLEXCOMM6").finish()
1480 }
1481}
1482#[doc = "Flexcomm"]
1483pub use self::flexcomm0 as flexcomm6;
1484#[doc = "Flexcomm"]
1485pub struct FLEXCOMM7 {
1486 _marker: PhantomData<*const ()>,
1487}
1488unsafe impl Send for FLEXCOMM7 {}
1489impl FLEXCOMM7 {
1490 #[doc = r"Pointer to the register block"]
1491 pub const PTR: *const flexcomm0::RegisterBlock = 0x4012_5000 as *const _;
1492 #[doc = r"Return the pointer to the register block"]
1493 #[inline(always)]
1494 pub const fn ptr() -> *const flexcomm0::RegisterBlock {
1495 Self::PTR
1496 }
1497}
1498impl Deref for FLEXCOMM7 {
1499 type Target = flexcomm0::RegisterBlock;
1500 #[inline(always)]
1501 fn deref(&self) -> &Self::Target {
1502 unsafe { &*Self::PTR }
1503 }
1504}
1505impl core::fmt::Debug for FLEXCOMM7 {
1506 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1507 f.debug_struct("FLEXCOMM7").finish()
1508 }
1509}
1510#[doc = "Flexcomm"]
1511pub use self::flexcomm0 as flexcomm7;
1512#[doc = "Flexcomm"]
1513pub struct FLEXCOMM14 {
1514 _marker: PhantomData<*const ()>,
1515}
1516unsafe impl Send for FLEXCOMM14 {}
1517impl FLEXCOMM14 {
1518 #[doc = r"Pointer to the register block"]
1519 pub const PTR: *const flexcomm0::RegisterBlock = 0x4012_6000 as *const _;
1520 #[doc = r"Return the pointer to the register block"]
1521 #[inline(always)]
1522 pub const fn ptr() -> *const flexcomm0::RegisterBlock {
1523 Self::PTR
1524 }
1525}
1526impl Deref for FLEXCOMM14 {
1527 type Target = flexcomm0::RegisterBlock;
1528 #[inline(always)]
1529 fn deref(&self) -> &Self::Target {
1530 unsafe { &*Self::PTR }
1531 }
1532}
1533impl core::fmt::Debug for FLEXCOMM14 {
1534 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1535 f.debug_struct("FLEXCOMM14").finish()
1536 }
1537}
1538#[doc = "Flexcomm"]
1539pub use self::flexcomm0 as flexcomm14;
1540#[doc = "Flexcomm"]
1541pub struct FLEXCOMM15 {
1542 _marker: PhantomData<*const ()>,
1543}
1544unsafe impl Send for FLEXCOMM15 {}
1545impl FLEXCOMM15 {
1546 #[doc = r"Pointer to the register block"]
1547 pub const PTR: *const flexcomm0::RegisterBlock = 0x4012_7000 as *const _;
1548 #[doc = r"Return the pointer to the register block"]
1549 #[inline(always)]
1550 pub const fn ptr() -> *const flexcomm0::RegisterBlock {
1551 Self::PTR
1552 }
1553}
1554impl Deref for FLEXCOMM15 {
1555 type Target = flexcomm0::RegisterBlock;
1556 #[inline(always)]
1557 fn deref(&self) -> &Self::Target {
1558 unsafe { &*Self::PTR }
1559 }
1560}
1561impl core::fmt::Debug for FLEXCOMM15 {
1562 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1563 f.debug_struct("FLEXCOMM15").finish()
1564 }
1565}
1566#[doc = "Flexcomm"]
1567pub use self::flexcomm0 as flexcomm15;
1568#[doc = "Flexcomm"]
1569pub struct FLEXCOMM16 {
1570 _marker: PhantomData<*const ()>,
1571}
1572unsafe impl Send for FLEXCOMM16 {}
1573impl FLEXCOMM16 {
1574 #[doc = r"Pointer to the register block"]
1575 pub const PTR: *const flexcomm0::RegisterBlock = 0x4012_8000 as *const _;
1576 #[doc = r"Return the pointer to the register block"]
1577 #[inline(always)]
1578 pub const fn ptr() -> *const flexcomm0::RegisterBlock {
1579 Self::PTR
1580 }
1581}
1582impl Deref for FLEXCOMM16 {
1583 type Target = flexcomm0::RegisterBlock;
1584 #[inline(always)]
1585 fn deref(&self) -> &Self::Target {
1586 unsafe { &*Self::PTR }
1587 }
1588}
1589impl core::fmt::Debug for FLEXCOMM16 {
1590 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1591 f.debug_struct("FLEXCOMM16").finish()
1592 }
1593}
1594#[doc = "Flexcomm"]
1595pub use self::flexcomm0 as flexcomm16;
1596#[doc = "Flexcomm"]
1597pub struct FLEXCOMM8 {
1598 _marker: PhantomData<*const ()>,
1599}
1600unsafe impl Send for FLEXCOMM8 {}
1601impl FLEXCOMM8 {
1602 #[doc = r"Pointer to the register block"]
1603 pub const PTR: *const flexcomm0::RegisterBlock = 0x4020_9000 as *const _;
1604 #[doc = r"Return the pointer to the register block"]
1605 #[inline(always)]
1606 pub const fn ptr() -> *const flexcomm0::RegisterBlock {
1607 Self::PTR
1608 }
1609}
1610impl Deref for FLEXCOMM8 {
1611 type Target = flexcomm0::RegisterBlock;
1612 #[inline(always)]
1613 fn deref(&self) -> &Self::Target {
1614 unsafe { &*Self::PTR }
1615 }
1616}
1617impl core::fmt::Debug for FLEXCOMM8 {
1618 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1619 f.debug_struct("FLEXCOMM8").finish()
1620 }
1621}
1622#[doc = "Flexcomm"]
1623pub use self::flexcomm0 as flexcomm8;
1624#[doc = "Flexcomm"]
1625pub struct FLEXCOMM9 {
1626 _marker: PhantomData<*const ()>,
1627}
1628unsafe impl Send for FLEXCOMM9 {}
1629impl FLEXCOMM9 {
1630 #[doc = r"Pointer to the register block"]
1631 pub const PTR: *const flexcomm0::RegisterBlock = 0x4020_a000 as *const _;
1632 #[doc = r"Return the pointer to the register block"]
1633 #[inline(always)]
1634 pub const fn ptr() -> *const flexcomm0::RegisterBlock {
1635 Self::PTR
1636 }
1637}
1638impl Deref for FLEXCOMM9 {
1639 type Target = flexcomm0::RegisterBlock;
1640 #[inline(always)]
1641 fn deref(&self) -> &Self::Target {
1642 unsafe { &*Self::PTR }
1643 }
1644}
1645impl core::fmt::Debug for FLEXCOMM9 {
1646 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1647 f.debug_struct("FLEXCOMM9").finish()
1648 }
1649}
1650#[doc = "Flexcomm"]
1651pub use self::flexcomm0 as flexcomm9;
1652#[doc = "Flexcomm"]
1653pub struct FLEXCOMM10 {
1654 _marker: PhantomData<*const ()>,
1655}
1656unsafe impl Send for FLEXCOMM10 {}
1657impl FLEXCOMM10 {
1658 #[doc = r"Pointer to the register block"]
1659 pub const PTR: *const flexcomm0::RegisterBlock = 0x4020_b000 as *const _;
1660 #[doc = r"Return the pointer to the register block"]
1661 #[inline(always)]
1662 pub const fn ptr() -> *const flexcomm0::RegisterBlock {
1663 Self::PTR
1664 }
1665}
1666impl Deref for FLEXCOMM10 {
1667 type Target = flexcomm0::RegisterBlock;
1668 #[inline(always)]
1669 fn deref(&self) -> &Self::Target {
1670 unsafe { &*Self::PTR }
1671 }
1672}
1673impl core::fmt::Debug for FLEXCOMM10 {
1674 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1675 f.debug_struct("FLEXCOMM10").finish()
1676 }
1677}
1678#[doc = "Flexcomm"]
1679pub use self::flexcomm0 as flexcomm10;
1680#[doc = "Flexcomm"]
1681pub struct FLEXCOMM11 {
1682 _marker: PhantomData<*const ()>,
1683}
1684unsafe impl Send for FLEXCOMM11 {}
1685impl FLEXCOMM11 {
1686 #[doc = r"Pointer to the register block"]
1687 pub const PTR: *const flexcomm0::RegisterBlock = 0x4020_c000 as *const _;
1688 #[doc = r"Return the pointer to the register block"]
1689 #[inline(always)]
1690 pub const fn ptr() -> *const flexcomm0::RegisterBlock {
1691 Self::PTR
1692 }
1693}
1694impl Deref for FLEXCOMM11 {
1695 type Target = flexcomm0::RegisterBlock;
1696 #[inline(always)]
1697 fn deref(&self) -> &Self::Target {
1698 unsafe { &*Self::PTR }
1699 }
1700}
1701impl core::fmt::Debug for FLEXCOMM11 {
1702 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1703 f.debug_struct("FLEXCOMM11").finish()
1704 }
1705}
1706#[doc = "Flexcomm"]
1707pub use self::flexcomm0 as flexcomm11;
1708#[doc = "Flexcomm"]
1709pub struct FLEXCOMM12 {
1710 _marker: PhantomData<*const ()>,
1711}
1712unsafe impl Send for FLEXCOMM12 {}
1713impl FLEXCOMM12 {
1714 #[doc = r"Pointer to the register block"]
1715 pub const PTR: *const flexcomm0::RegisterBlock = 0x4020_d000 as *const _;
1716 #[doc = r"Return the pointer to the register block"]
1717 #[inline(always)]
1718 pub const fn ptr() -> *const flexcomm0::RegisterBlock {
1719 Self::PTR
1720 }
1721}
1722impl Deref for FLEXCOMM12 {
1723 type Target = flexcomm0::RegisterBlock;
1724 #[inline(always)]
1725 fn deref(&self) -> &Self::Target {
1726 unsafe { &*Self::PTR }
1727 }
1728}
1729impl core::fmt::Debug for FLEXCOMM12 {
1730 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1731 f.debug_struct("FLEXCOMM12").finish()
1732 }
1733}
1734#[doc = "Flexcomm"]
1735pub use self::flexcomm0 as flexcomm12;
1736#[doc = "Flexcomm"]
1737pub struct FLEXCOMM13 {
1738 _marker: PhantomData<*const ()>,
1739}
1740unsafe impl Send for FLEXCOMM13 {}
1741impl FLEXCOMM13 {
1742 #[doc = r"Pointer to the register block"]
1743 pub const PTR: *const flexcomm0::RegisterBlock = 0x4020_e000 as *const _;
1744 #[doc = r"Return the pointer to the register block"]
1745 #[inline(always)]
1746 pub const fn ptr() -> *const flexcomm0::RegisterBlock {
1747 Self::PTR
1748 }
1749}
1750impl Deref for FLEXCOMM13 {
1751 type Target = flexcomm0::RegisterBlock;
1752 #[inline(always)]
1753 fn deref(&self) -> &Self::Target {
1754 unsafe { &*Self::PTR }
1755 }
1756}
1757impl core::fmt::Debug for FLEXCOMM13 {
1758 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1759 f.debug_struct("FLEXCOMM13").finish()
1760 }
1761}
1762#[doc = "Flexcomm"]
1763pub use self::flexcomm0 as flexcomm13;
1764#[doc = "I2C Bus Interface"]
1765pub struct I2C0 {
1766 _marker: PhantomData<*const ()>,
1767}
1768unsafe impl Send for I2C0 {}
1769impl I2C0 {
1770 #[doc = r"Pointer to the register block"]
1771 pub const PTR: *const i2c0::RegisterBlock = 0x4010_6000 as *const _;
1772 #[doc = r"Return the pointer to the register block"]
1773 #[inline(always)]
1774 pub const fn ptr() -> *const i2c0::RegisterBlock {
1775 Self::PTR
1776 }
1777}
1778impl Deref for I2C0 {
1779 type Target = i2c0::RegisterBlock;
1780 #[inline(always)]
1781 fn deref(&self) -> &Self::Target {
1782 unsafe { &*Self::PTR }
1783 }
1784}
1785impl core::fmt::Debug for I2C0 {
1786 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1787 f.debug_struct("I2C0").finish()
1788 }
1789}
1790#[doc = "I2C Bus Interface"]
1791pub mod i2c0;
1792#[doc = "I2C Bus Interface"]
1793pub struct I2C1 {
1794 _marker: PhantomData<*const ()>,
1795}
1796unsafe impl Send for I2C1 {}
1797impl I2C1 {
1798 #[doc = r"Pointer to the register block"]
1799 pub const PTR: *const i2c0::RegisterBlock = 0x4010_7000 as *const _;
1800 #[doc = r"Return the pointer to the register block"]
1801 #[inline(always)]
1802 pub const fn ptr() -> *const i2c0::RegisterBlock {
1803 Self::PTR
1804 }
1805}
1806impl Deref for I2C1 {
1807 type Target = i2c0::RegisterBlock;
1808 #[inline(always)]
1809 fn deref(&self) -> &Self::Target {
1810 unsafe { &*Self::PTR }
1811 }
1812}
1813impl core::fmt::Debug for I2C1 {
1814 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1815 f.debug_struct("I2C1").finish()
1816 }
1817}
1818#[doc = "I2C Bus Interface"]
1819pub use self::i2c0 as i2c1;
1820#[doc = "I2C Bus Interface"]
1821pub struct I2C2 {
1822 _marker: PhantomData<*const ()>,
1823}
1824unsafe impl Send for I2C2 {}
1825impl I2C2 {
1826 #[doc = r"Pointer to the register block"]
1827 pub const PTR: *const i2c0::RegisterBlock = 0x4010_8000 as *const _;
1828 #[doc = r"Return the pointer to the register block"]
1829 #[inline(always)]
1830 pub const fn ptr() -> *const i2c0::RegisterBlock {
1831 Self::PTR
1832 }
1833}
1834impl Deref for I2C2 {
1835 type Target = i2c0::RegisterBlock;
1836 #[inline(always)]
1837 fn deref(&self) -> &Self::Target {
1838 unsafe { &*Self::PTR }
1839 }
1840}
1841impl core::fmt::Debug for I2C2 {
1842 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1843 f.debug_struct("I2C2").finish()
1844 }
1845}
1846#[doc = "I2C Bus Interface"]
1847pub use self::i2c0 as i2c2;
1848#[doc = "I2C Bus Interface"]
1849pub struct I2C3 {
1850 _marker: PhantomData<*const ()>,
1851}
1852unsafe impl Send for I2C3 {}
1853impl I2C3 {
1854 #[doc = r"Pointer to the register block"]
1855 pub const PTR: *const i2c0::RegisterBlock = 0x4010_9000 as *const _;
1856 #[doc = r"Return the pointer to the register block"]
1857 #[inline(always)]
1858 pub const fn ptr() -> *const i2c0::RegisterBlock {
1859 Self::PTR
1860 }
1861}
1862impl Deref for I2C3 {
1863 type Target = i2c0::RegisterBlock;
1864 #[inline(always)]
1865 fn deref(&self) -> &Self::Target {
1866 unsafe { &*Self::PTR }
1867 }
1868}
1869impl core::fmt::Debug for I2C3 {
1870 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1871 f.debug_struct("I2C3").finish()
1872 }
1873}
1874#[doc = "I2C Bus Interface"]
1875pub use self::i2c0 as i2c3;
1876#[doc = "I2C Bus Interface"]
1877pub struct I2C4 {
1878 _marker: PhantomData<*const ()>,
1879}
1880unsafe impl Send for I2C4 {}
1881impl I2C4 {
1882 #[doc = r"Pointer to the register block"]
1883 pub const PTR: *const i2c0::RegisterBlock = 0x4012_2000 as *const _;
1884 #[doc = r"Return the pointer to the register block"]
1885 #[inline(always)]
1886 pub const fn ptr() -> *const i2c0::RegisterBlock {
1887 Self::PTR
1888 }
1889}
1890impl Deref for I2C4 {
1891 type Target = i2c0::RegisterBlock;
1892 #[inline(always)]
1893 fn deref(&self) -> &Self::Target {
1894 unsafe { &*Self::PTR }
1895 }
1896}
1897impl core::fmt::Debug for I2C4 {
1898 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1899 f.debug_struct("I2C4").finish()
1900 }
1901}
1902#[doc = "I2C Bus Interface"]
1903pub use self::i2c0 as i2c4;
1904#[doc = "I2C Bus Interface"]
1905pub struct I2C5 {
1906 _marker: PhantomData<*const ()>,
1907}
1908unsafe impl Send for I2C5 {}
1909impl I2C5 {
1910 #[doc = r"Pointer to the register block"]
1911 pub const PTR: *const i2c0::RegisterBlock = 0x4012_3000 as *const _;
1912 #[doc = r"Return the pointer to the register block"]
1913 #[inline(always)]
1914 pub const fn ptr() -> *const i2c0::RegisterBlock {
1915 Self::PTR
1916 }
1917}
1918impl Deref for I2C5 {
1919 type Target = i2c0::RegisterBlock;
1920 #[inline(always)]
1921 fn deref(&self) -> &Self::Target {
1922 unsafe { &*Self::PTR }
1923 }
1924}
1925impl core::fmt::Debug for I2C5 {
1926 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1927 f.debug_struct("I2C5").finish()
1928 }
1929}
1930#[doc = "I2C Bus Interface"]
1931pub use self::i2c0 as i2c5;
1932#[doc = "I2C Bus Interface"]
1933pub struct I2C6 {
1934 _marker: PhantomData<*const ()>,
1935}
1936unsafe impl Send for I2C6 {}
1937impl I2C6 {
1938 #[doc = r"Pointer to the register block"]
1939 pub const PTR: *const i2c0::RegisterBlock = 0x4012_4000 as *const _;
1940 #[doc = r"Return the pointer to the register block"]
1941 #[inline(always)]
1942 pub const fn ptr() -> *const i2c0::RegisterBlock {
1943 Self::PTR
1944 }
1945}
1946impl Deref for I2C6 {
1947 type Target = i2c0::RegisterBlock;
1948 #[inline(always)]
1949 fn deref(&self) -> &Self::Target {
1950 unsafe { &*Self::PTR }
1951 }
1952}
1953impl core::fmt::Debug for I2C6 {
1954 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1955 f.debug_struct("I2C6").finish()
1956 }
1957}
1958#[doc = "I2C Bus Interface"]
1959pub use self::i2c0 as i2c6;
1960#[doc = "I2C Bus Interface"]
1961pub struct I2C7 {
1962 _marker: PhantomData<*const ()>,
1963}
1964unsafe impl Send for I2C7 {}
1965impl I2C7 {
1966 #[doc = r"Pointer to the register block"]
1967 pub const PTR: *const i2c0::RegisterBlock = 0x4012_5000 as *const _;
1968 #[doc = r"Return the pointer to the register block"]
1969 #[inline(always)]
1970 pub const fn ptr() -> *const i2c0::RegisterBlock {
1971 Self::PTR
1972 }
1973}
1974impl Deref for I2C7 {
1975 type Target = i2c0::RegisterBlock;
1976 #[inline(always)]
1977 fn deref(&self) -> &Self::Target {
1978 unsafe { &*Self::PTR }
1979 }
1980}
1981impl core::fmt::Debug for I2C7 {
1982 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1983 f.debug_struct("I2C7").finish()
1984 }
1985}
1986#[doc = "I2C Bus Interface"]
1987pub use self::i2c0 as i2c7;
1988#[doc = "I2C Bus Interface"]
1989pub struct I2C15 {
1990 _marker: PhantomData<*const ()>,
1991}
1992unsafe impl Send for I2C15 {}
1993impl I2C15 {
1994 #[doc = r"Pointer to the register block"]
1995 pub const PTR: *const i2c0::RegisterBlock = 0x4012_7000 as *const _;
1996 #[doc = r"Return the pointer to the register block"]
1997 #[inline(always)]
1998 pub const fn ptr() -> *const i2c0::RegisterBlock {
1999 Self::PTR
2000 }
2001}
2002impl Deref for I2C15 {
2003 type Target = i2c0::RegisterBlock;
2004 #[inline(always)]
2005 fn deref(&self) -> &Self::Target {
2006 unsafe { &*Self::PTR }
2007 }
2008}
2009impl core::fmt::Debug for I2C15 {
2010 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2011 f.debug_struct("I2C15").finish()
2012 }
2013}
2014#[doc = "I2C Bus Interface"]
2015pub use self::i2c0 as i2c15;
2016#[doc = "I2C Bus Interface"]
2017pub struct I2C8 {
2018 _marker: PhantomData<*const ()>,
2019}
2020unsafe impl Send for I2C8 {}
2021impl I2C8 {
2022 #[doc = r"Pointer to the register block"]
2023 pub const PTR: *const i2c0::RegisterBlock = 0x4020_9000 as *const _;
2024 #[doc = r"Return the pointer to the register block"]
2025 #[inline(always)]
2026 pub const fn ptr() -> *const i2c0::RegisterBlock {
2027 Self::PTR
2028 }
2029}
2030impl Deref for I2C8 {
2031 type Target = i2c0::RegisterBlock;
2032 #[inline(always)]
2033 fn deref(&self) -> &Self::Target {
2034 unsafe { &*Self::PTR }
2035 }
2036}
2037impl core::fmt::Debug for I2C8 {
2038 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2039 f.debug_struct("I2C8").finish()
2040 }
2041}
2042#[doc = "I2C Bus Interface"]
2043pub use self::i2c0 as i2c8;
2044#[doc = "I2C Bus Interface"]
2045pub struct I2C9 {
2046 _marker: PhantomData<*const ()>,
2047}
2048unsafe impl Send for I2C9 {}
2049impl I2C9 {
2050 #[doc = r"Pointer to the register block"]
2051 pub const PTR: *const i2c0::RegisterBlock = 0x4020_a000 as *const _;
2052 #[doc = r"Return the pointer to the register block"]
2053 #[inline(always)]
2054 pub const fn ptr() -> *const i2c0::RegisterBlock {
2055 Self::PTR
2056 }
2057}
2058impl Deref for I2C9 {
2059 type Target = i2c0::RegisterBlock;
2060 #[inline(always)]
2061 fn deref(&self) -> &Self::Target {
2062 unsafe { &*Self::PTR }
2063 }
2064}
2065impl core::fmt::Debug for I2C9 {
2066 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2067 f.debug_struct("I2C9").finish()
2068 }
2069}
2070#[doc = "I2C Bus Interface"]
2071pub use self::i2c0 as i2c9;
2072#[doc = "I2C Bus Interface"]
2073pub struct I2C10 {
2074 _marker: PhantomData<*const ()>,
2075}
2076unsafe impl Send for I2C10 {}
2077impl I2C10 {
2078 #[doc = r"Pointer to the register block"]
2079 pub const PTR: *const i2c0::RegisterBlock = 0x4020_b000 as *const _;
2080 #[doc = r"Return the pointer to the register block"]
2081 #[inline(always)]
2082 pub const fn ptr() -> *const i2c0::RegisterBlock {
2083 Self::PTR
2084 }
2085}
2086impl Deref for I2C10 {
2087 type Target = i2c0::RegisterBlock;
2088 #[inline(always)]
2089 fn deref(&self) -> &Self::Target {
2090 unsafe { &*Self::PTR }
2091 }
2092}
2093impl core::fmt::Debug for I2C10 {
2094 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2095 f.debug_struct("I2C10").finish()
2096 }
2097}
2098#[doc = "I2C Bus Interface"]
2099pub use self::i2c0 as i2c10;
2100#[doc = "I2C Bus Interface"]
2101pub struct I2C11 {
2102 _marker: PhantomData<*const ()>,
2103}
2104unsafe impl Send for I2C11 {}
2105impl I2C11 {
2106 #[doc = r"Pointer to the register block"]
2107 pub const PTR: *const i2c0::RegisterBlock = 0x4020_c000 as *const _;
2108 #[doc = r"Return the pointer to the register block"]
2109 #[inline(always)]
2110 pub const fn ptr() -> *const i2c0::RegisterBlock {
2111 Self::PTR
2112 }
2113}
2114impl Deref for I2C11 {
2115 type Target = i2c0::RegisterBlock;
2116 #[inline(always)]
2117 fn deref(&self) -> &Self::Target {
2118 unsafe { &*Self::PTR }
2119 }
2120}
2121impl core::fmt::Debug for I2C11 {
2122 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2123 f.debug_struct("I2C11").finish()
2124 }
2125}
2126#[doc = "I2C Bus Interface"]
2127pub use self::i2c0 as i2c11;
2128#[doc = "I2C Bus Interface"]
2129pub struct I2C12 {
2130 _marker: PhantomData<*const ()>,
2131}
2132unsafe impl Send for I2C12 {}
2133impl I2C12 {
2134 #[doc = r"Pointer to the register block"]
2135 pub const PTR: *const i2c0::RegisterBlock = 0x4020_d000 as *const _;
2136 #[doc = r"Return the pointer to the register block"]
2137 #[inline(always)]
2138 pub const fn ptr() -> *const i2c0::RegisterBlock {
2139 Self::PTR
2140 }
2141}
2142impl Deref for I2C12 {
2143 type Target = i2c0::RegisterBlock;
2144 #[inline(always)]
2145 fn deref(&self) -> &Self::Target {
2146 unsafe { &*Self::PTR }
2147 }
2148}
2149impl core::fmt::Debug for I2C12 {
2150 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2151 f.debug_struct("I2C12").finish()
2152 }
2153}
2154#[doc = "I2C Bus Interface"]
2155pub use self::i2c0 as i2c12;
2156#[doc = "I2C Bus Interface"]
2157pub struct I2C13 {
2158 _marker: PhantomData<*const ()>,
2159}
2160unsafe impl Send for I2C13 {}
2161impl I2C13 {
2162 #[doc = r"Pointer to the register block"]
2163 pub const PTR: *const i2c0::RegisterBlock = 0x4020_e000 as *const _;
2164 #[doc = r"Return the pointer to the register block"]
2165 #[inline(always)]
2166 pub const fn ptr() -> *const i2c0::RegisterBlock {
2167 Self::PTR
2168 }
2169}
2170impl Deref for I2C13 {
2171 type Target = i2c0::RegisterBlock;
2172 #[inline(always)]
2173 fn deref(&self) -> &Self::Target {
2174 unsafe { &*Self::PTR }
2175 }
2176}
2177impl core::fmt::Debug for I2C13 {
2178 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2179 f.debug_struct("I2C13").finish()
2180 }
2181}
2182#[doc = "I2C Bus Interface"]
2183pub use self::i2c0 as i2c13;
2184#[doc = "I2S Interface"]
2185pub struct I2S0 {
2186 _marker: PhantomData<*const ()>,
2187}
2188unsafe impl Send for I2S0 {}
2189impl I2S0 {
2190 #[doc = r"Pointer to the register block"]
2191 pub const PTR: *const i2s0::RegisterBlock = 0x4010_6000 as *const _;
2192 #[doc = r"Return the pointer to the register block"]
2193 #[inline(always)]
2194 pub const fn ptr() -> *const i2s0::RegisterBlock {
2195 Self::PTR
2196 }
2197}
2198impl Deref for I2S0 {
2199 type Target = i2s0::RegisterBlock;
2200 #[inline(always)]
2201 fn deref(&self) -> &Self::Target {
2202 unsafe { &*Self::PTR }
2203 }
2204}
2205impl core::fmt::Debug for I2S0 {
2206 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2207 f.debug_struct("I2S0").finish()
2208 }
2209}
2210#[doc = "I2S Interface"]
2211pub mod i2s0;
2212#[doc = "I2S Interface"]
2213pub struct I2S1 {
2214 _marker: PhantomData<*const ()>,
2215}
2216unsafe impl Send for I2S1 {}
2217impl I2S1 {
2218 #[doc = r"Pointer to the register block"]
2219 pub const PTR: *const i2s0::RegisterBlock = 0x4010_7000 as *const _;
2220 #[doc = r"Return the pointer to the register block"]
2221 #[inline(always)]
2222 pub const fn ptr() -> *const i2s0::RegisterBlock {
2223 Self::PTR
2224 }
2225}
2226impl Deref for I2S1 {
2227 type Target = i2s0::RegisterBlock;
2228 #[inline(always)]
2229 fn deref(&self) -> &Self::Target {
2230 unsafe { &*Self::PTR }
2231 }
2232}
2233impl core::fmt::Debug for I2S1 {
2234 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2235 f.debug_struct("I2S1").finish()
2236 }
2237}
2238#[doc = "I2S Interface"]
2239pub use self::i2s0 as i2s1;
2240#[doc = "I2S Interface"]
2241pub struct I2S2 {
2242 _marker: PhantomData<*const ()>,
2243}
2244unsafe impl Send for I2S2 {}
2245impl I2S2 {
2246 #[doc = r"Pointer to the register block"]
2247 pub const PTR: *const i2s0::RegisterBlock = 0x4010_8000 as *const _;
2248 #[doc = r"Return the pointer to the register block"]
2249 #[inline(always)]
2250 pub const fn ptr() -> *const i2s0::RegisterBlock {
2251 Self::PTR
2252 }
2253}
2254impl Deref for I2S2 {
2255 type Target = i2s0::RegisterBlock;
2256 #[inline(always)]
2257 fn deref(&self) -> &Self::Target {
2258 unsafe { &*Self::PTR }
2259 }
2260}
2261impl core::fmt::Debug for I2S2 {
2262 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2263 f.debug_struct("I2S2").finish()
2264 }
2265}
2266#[doc = "I2S Interface"]
2267pub use self::i2s0 as i2s2;
2268#[doc = "I2S Interface"]
2269pub struct I2S3 {
2270 _marker: PhantomData<*const ()>,
2271}
2272unsafe impl Send for I2S3 {}
2273impl I2S3 {
2274 #[doc = r"Pointer to the register block"]
2275 pub const PTR: *const i2s0::RegisterBlock = 0x4010_9000 as *const _;
2276 #[doc = r"Return the pointer to the register block"]
2277 #[inline(always)]
2278 pub const fn ptr() -> *const i2s0::RegisterBlock {
2279 Self::PTR
2280 }
2281}
2282impl Deref for I2S3 {
2283 type Target = i2s0::RegisterBlock;
2284 #[inline(always)]
2285 fn deref(&self) -> &Self::Target {
2286 unsafe { &*Self::PTR }
2287 }
2288}
2289impl core::fmt::Debug for I2S3 {
2290 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2291 f.debug_struct("I2S3").finish()
2292 }
2293}
2294#[doc = "I2S Interface"]
2295pub use self::i2s0 as i2s3;
2296#[doc = "I2S Interface"]
2297pub struct I2S4 {
2298 _marker: PhantomData<*const ()>,
2299}
2300unsafe impl Send for I2S4 {}
2301impl I2S4 {
2302 #[doc = r"Pointer to the register block"]
2303 pub const PTR: *const i2s0::RegisterBlock = 0x4012_2000 as *const _;
2304 #[doc = r"Return the pointer to the register block"]
2305 #[inline(always)]
2306 pub const fn ptr() -> *const i2s0::RegisterBlock {
2307 Self::PTR
2308 }
2309}
2310impl Deref for I2S4 {
2311 type Target = i2s0::RegisterBlock;
2312 #[inline(always)]
2313 fn deref(&self) -> &Self::Target {
2314 unsafe { &*Self::PTR }
2315 }
2316}
2317impl core::fmt::Debug for I2S4 {
2318 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2319 f.debug_struct("I2S4").finish()
2320 }
2321}
2322#[doc = "I2S Interface"]
2323pub use self::i2s0 as i2s4;
2324#[doc = "I2S Interface"]
2325pub struct I2S5 {
2326 _marker: PhantomData<*const ()>,
2327}
2328unsafe impl Send for I2S5 {}
2329impl I2S5 {
2330 #[doc = r"Pointer to the register block"]
2331 pub const PTR: *const i2s0::RegisterBlock = 0x4012_3000 as *const _;
2332 #[doc = r"Return the pointer to the register block"]
2333 #[inline(always)]
2334 pub const fn ptr() -> *const i2s0::RegisterBlock {
2335 Self::PTR
2336 }
2337}
2338impl Deref for I2S5 {
2339 type Target = i2s0::RegisterBlock;
2340 #[inline(always)]
2341 fn deref(&self) -> &Self::Target {
2342 unsafe { &*Self::PTR }
2343 }
2344}
2345impl core::fmt::Debug for I2S5 {
2346 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2347 f.debug_struct("I2S5").finish()
2348 }
2349}
2350#[doc = "I2S Interface"]
2351pub use self::i2s0 as i2s5;
2352#[doc = "I2S Interface"]
2353pub struct I2S6 {
2354 _marker: PhantomData<*const ()>,
2355}
2356unsafe impl Send for I2S6 {}
2357impl I2S6 {
2358 #[doc = r"Pointer to the register block"]
2359 pub const PTR: *const i2s0::RegisterBlock = 0x4012_4000 as *const _;
2360 #[doc = r"Return the pointer to the register block"]
2361 #[inline(always)]
2362 pub const fn ptr() -> *const i2s0::RegisterBlock {
2363 Self::PTR
2364 }
2365}
2366impl Deref for I2S6 {
2367 type Target = i2s0::RegisterBlock;
2368 #[inline(always)]
2369 fn deref(&self) -> &Self::Target {
2370 unsafe { &*Self::PTR }
2371 }
2372}
2373impl core::fmt::Debug for I2S6 {
2374 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2375 f.debug_struct("I2S6").finish()
2376 }
2377}
2378#[doc = "I2S Interface"]
2379pub use self::i2s0 as i2s6;
2380#[doc = "I2S Interface"]
2381pub struct I2S7 {
2382 _marker: PhantomData<*const ()>,
2383}
2384unsafe impl Send for I2S7 {}
2385impl I2S7 {
2386 #[doc = r"Pointer to the register block"]
2387 pub const PTR: *const i2s0::RegisterBlock = 0x4012_5000 as *const _;
2388 #[doc = r"Return the pointer to the register block"]
2389 #[inline(always)]
2390 pub const fn ptr() -> *const i2s0::RegisterBlock {
2391 Self::PTR
2392 }
2393}
2394impl Deref for I2S7 {
2395 type Target = i2s0::RegisterBlock;
2396 #[inline(always)]
2397 fn deref(&self) -> &Self::Target {
2398 unsafe { &*Self::PTR }
2399 }
2400}
2401impl core::fmt::Debug for I2S7 {
2402 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2403 f.debug_struct("I2S7").finish()
2404 }
2405}
2406#[doc = "I2S Interface"]
2407pub use self::i2s0 as i2s7;
2408#[doc = "I2S Interface"]
2409pub struct I2S8 {
2410 _marker: PhantomData<*const ()>,
2411}
2412unsafe impl Send for I2S8 {}
2413impl I2S8 {
2414 #[doc = r"Pointer to the register block"]
2415 pub const PTR: *const i2s0::RegisterBlock = 0x4020_9000 as *const _;
2416 #[doc = r"Return the pointer to the register block"]
2417 #[inline(always)]
2418 pub const fn ptr() -> *const i2s0::RegisterBlock {
2419 Self::PTR
2420 }
2421}
2422impl Deref for I2S8 {
2423 type Target = i2s0::RegisterBlock;
2424 #[inline(always)]
2425 fn deref(&self) -> &Self::Target {
2426 unsafe { &*Self::PTR }
2427 }
2428}
2429impl core::fmt::Debug for I2S8 {
2430 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2431 f.debug_struct("I2S8").finish()
2432 }
2433}
2434#[doc = "I2S Interface"]
2435pub use self::i2s0 as i2s8;
2436#[doc = "I2S Interface"]
2437pub struct I2S9 {
2438 _marker: PhantomData<*const ()>,
2439}
2440unsafe impl Send for I2S9 {}
2441impl I2S9 {
2442 #[doc = r"Pointer to the register block"]
2443 pub const PTR: *const i2s0::RegisterBlock = 0x4020_a000 as *const _;
2444 #[doc = r"Return the pointer to the register block"]
2445 #[inline(always)]
2446 pub const fn ptr() -> *const i2s0::RegisterBlock {
2447 Self::PTR
2448 }
2449}
2450impl Deref for I2S9 {
2451 type Target = i2s0::RegisterBlock;
2452 #[inline(always)]
2453 fn deref(&self) -> &Self::Target {
2454 unsafe { &*Self::PTR }
2455 }
2456}
2457impl core::fmt::Debug for I2S9 {
2458 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2459 f.debug_struct("I2S9").finish()
2460 }
2461}
2462#[doc = "I2S Interface"]
2463pub use self::i2s0 as i2s9;
2464#[doc = "I2S Interface"]
2465pub struct I2S10 {
2466 _marker: PhantomData<*const ()>,
2467}
2468unsafe impl Send for I2S10 {}
2469impl I2S10 {
2470 #[doc = r"Pointer to the register block"]
2471 pub const PTR: *const i2s0::RegisterBlock = 0x4020_b000 as *const _;
2472 #[doc = r"Return the pointer to the register block"]
2473 #[inline(always)]
2474 pub const fn ptr() -> *const i2s0::RegisterBlock {
2475 Self::PTR
2476 }
2477}
2478impl Deref for I2S10 {
2479 type Target = i2s0::RegisterBlock;
2480 #[inline(always)]
2481 fn deref(&self) -> &Self::Target {
2482 unsafe { &*Self::PTR }
2483 }
2484}
2485impl core::fmt::Debug for I2S10 {
2486 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2487 f.debug_struct("I2S10").finish()
2488 }
2489}
2490#[doc = "I2S Interface"]
2491pub use self::i2s0 as i2s10;
2492#[doc = "I2S Interface"]
2493pub struct I2S11 {
2494 _marker: PhantomData<*const ()>,
2495}
2496unsafe impl Send for I2S11 {}
2497impl I2S11 {
2498 #[doc = r"Pointer to the register block"]
2499 pub const PTR: *const i2s0::RegisterBlock = 0x4020_c000 as *const _;
2500 #[doc = r"Return the pointer to the register block"]
2501 #[inline(always)]
2502 pub const fn ptr() -> *const i2s0::RegisterBlock {
2503 Self::PTR
2504 }
2505}
2506impl Deref for I2S11 {
2507 type Target = i2s0::RegisterBlock;
2508 #[inline(always)]
2509 fn deref(&self) -> &Self::Target {
2510 unsafe { &*Self::PTR }
2511 }
2512}
2513impl core::fmt::Debug for I2S11 {
2514 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2515 f.debug_struct("I2S11").finish()
2516 }
2517}
2518#[doc = "I2S Interface"]
2519pub use self::i2s0 as i2s11;
2520#[doc = "I2S Interface"]
2521pub struct I2S12 {
2522 _marker: PhantomData<*const ()>,
2523}
2524unsafe impl Send for I2S12 {}
2525impl I2S12 {
2526 #[doc = r"Pointer to the register block"]
2527 pub const PTR: *const i2s0::RegisterBlock = 0x4020_d000 as *const _;
2528 #[doc = r"Return the pointer to the register block"]
2529 #[inline(always)]
2530 pub const fn ptr() -> *const i2s0::RegisterBlock {
2531 Self::PTR
2532 }
2533}
2534impl Deref for I2S12 {
2535 type Target = i2s0::RegisterBlock;
2536 #[inline(always)]
2537 fn deref(&self) -> &Self::Target {
2538 unsafe { &*Self::PTR }
2539 }
2540}
2541impl core::fmt::Debug for I2S12 {
2542 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2543 f.debug_struct("I2S12").finish()
2544 }
2545}
2546#[doc = "I2S Interface"]
2547pub use self::i2s0 as i2s12;
2548#[doc = "I2S Interface"]
2549pub struct I2S13 {
2550 _marker: PhantomData<*const ()>,
2551}
2552unsafe impl Send for I2S13 {}
2553impl I2S13 {
2554 #[doc = r"Pointer to the register block"]
2555 pub const PTR: *const i2s0::RegisterBlock = 0x4020_e000 as *const _;
2556 #[doc = r"Return the pointer to the register block"]
2557 #[inline(always)]
2558 pub const fn ptr() -> *const i2s0::RegisterBlock {
2559 Self::PTR
2560 }
2561}
2562impl Deref for I2S13 {
2563 type Target = i2s0::RegisterBlock;
2564 #[inline(always)]
2565 fn deref(&self) -> &Self::Target {
2566 unsafe { &*Self::PTR }
2567 }
2568}
2569impl core::fmt::Debug for I2S13 {
2570 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2571 f.debug_struct("I2S13").finish()
2572 }
2573}
2574#[doc = "I2S Interface"]
2575pub use self::i2s0 as i2s13;
2576#[doc = "Serial Peripheral Interfaces (SPI)"]
2577pub struct SPI0 {
2578 _marker: PhantomData<*const ()>,
2579}
2580unsafe impl Send for SPI0 {}
2581impl SPI0 {
2582 #[doc = r"Pointer to the register block"]
2583 pub const PTR: *const spi0::RegisterBlock = 0x4010_6000 as *const _;
2584 #[doc = r"Return the pointer to the register block"]
2585 #[inline(always)]
2586 pub const fn ptr() -> *const spi0::RegisterBlock {
2587 Self::PTR
2588 }
2589}
2590impl Deref for SPI0 {
2591 type Target = spi0::RegisterBlock;
2592 #[inline(always)]
2593 fn deref(&self) -> &Self::Target {
2594 unsafe { &*Self::PTR }
2595 }
2596}
2597impl core::fmt::Debug for SPI0 {
2598 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2599 f.debug_struct("SPI0").finish()
2600 }
2601}
2602#[doc = "Serial Peripheral Interfaces (SPI)"]
2603pub mod spi0;
2604#[doc = "Serial Peripheral Interfaces (SPI)"]
2605pub struct SPI1 {
2606 _marker: PhantomData<*const ()>,
2607}
2608unsafe impl Send for SPI1 {}
2609impl SPI1 {
2610 #[doc = r"Pointer to the register block"]
2611 pub const PTR: *const spi0::RegisterBlock = 0x4010_7000 as *const _;
2612 #[doc = r"Return the pointer to the register block"]
2613 #[inline(always)]
2614 pub const fn ptr() -> *const spi0::RegisterBlock {
2615 Self::PTR
2616 }
2617}
2618impl Deref for SPI1 {
2619 type Target = spi0::RegisterBlock;
2620 #[inline(always)]
2621 fn deref(&self) -> &Self::Target {
2622 unsafe { &*Self::PTR }
2623 }
2624}
2625impl core::fmt::Debug for SPI1 {
2626 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2627 f.debug_struct("SPI1").finish()
2628 }
2629}
2630#[doc = "Serial Peripheral Interfaces (SPI)"]
2631pub use self::spi0 as spi1;
2632#[doc = "Serial Peripheral Interfaces (SPI)"]
2633pub struct SPI2 {
2634 _marker: PhantomData<*const ()>,
2635}
2636unsafe impl Send for SPI2 {}
2637impl SPI2 {
2638 #[doc = r"Pointer to the register block"]
2639 pub const PTR: *const spi0::RegisterBlock = 0x4010_8000 as *const _;
2640 #[doc = r"Return the pointer to the register block"]
2641 #[inline(always)]
2642 pub const fn ptr() -> *const spi0::RegisterBlock {
2643 Self::PTR
2644 }
2645}
2646impl Deref for SPI2 {
2647 type Target = spi0::RegisterBlock;
2648 #[inline(always)]
2649 fn deref(&self) -> &Self::Target {
2650 unsafe { &*Self::PTR }
2651 }
2652}
2653impl core::fmt::Debug for SPI2 {
2654 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2655 f.debug_struct("SPI2").finish()
2656 }
2657}
2658#[doc = "Serial Peripheral Interfaces (SPI)"]
2659pub use self::spi0 as spi2;
2660#[doc = "Serial Peripheral Interfaces (SPI)"]
2661pub struct SPI3 {
2662 _marker: PhantomData<*const ()>,
2663}
2664unsafe impl Send for SPI3 {}
2665impl SPI3 {
2666 #[doc = r"Pointer to the register block"]
2667 pub const PTR: *const spi0::RegisterBlock = 0x4010_9000 as *const _;
2668 #[doc = r"Return the pointer to the register block"]
2669 #[inline(always)]
2670 pub const fn ptr() -> *const spi0::RegisterBlock {
2671 Self::PTR
2672 }
2673}
2674impl Deref for SPI3 {
2675 type Target = spi0::RegisterBlock;
2676 #[inline(always)]
2677 fn deref(&self) -> &Self::Target {
2678 unsafe { &*Self::PTR }
2679 }
2680}
2681impl core::fmt::Debug for SPI3 {
2682 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2683 f.debug_struct("SPI3").finish()
2684 }
2685}
2686#[doc = "Serial Peripheral Interfaces (SPI)"]
2687pub use self::spi0 as spi3;
2688#[doc = "Serial Peripheral Interfaces (SPI)"]
2689pub struct SPI4 {
2690 _marker: PhantomData<*const ()>,
2691}
2692unsafe impl Send for SPI4 {}
2693impl SPI4 {
2694 #[doc = r"Pointer to the register block"]
2695 pub const PTR: *const spi0::RegisterBlock = 0x4012_2000 as *const _;
2696 #[doc = r"Return the pointer to the register block"]
2697 #[inline(always)]
2698 pub const fn ptr() -> *const spi0::RegisterBlock {
2699 Self::PTR
2700 }
2701}
2702impl Deref for SPI4 {
2703 type Target = spi0::RegisterBlock;
2704 #[inline(always)]
2705 fn deref(&self) -> &Self::Target {
2706 unsafe { &*Self::PTR }
2707 }
2708}
2709impl core::fmt::Debug for SPI4 {
2710 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2711 f.debug_struct("SPI4").finish()
2712 }
2713}
2714#[doc = "Serial Peripheral Interfaces (SPI)"]
2715pub use self::spi0 as spi4;
2716#[doc = "Serial Peripheral Interfaces (SPI)"]
2717pub struct SPI5 {
2718 _marker: PhantomData<*const ()>,
2719}
2720unsafe impl Send for SPI5 {}
2721impl SPI5 {
2722 #[doc = r"Pointer to the register block"]
2723 pub const PTR: *const spi0::RegisterBlock = 0x4012_3000 as *const _;
2724 #[doc = r"Return the pointer to the register block"]
2725 #[inline(always)]
2726 pub const fn ptr() -> *const spi0::RegisterBlock {
2727 Self::PTR
2728 }
2729}
2730impl Deref for SPI5 {
2731 type Target = spi0::RegisterBlock;
2732 #[inline(always)]
2733 fn deref(&self) -> &Self::Target {
2734 unsafe { &*Self::PTR }
2735 }
2736}
2737impl core::fmt::Debug for SPI5 {
2738 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2739 f.debug_struct("SPI5").finish()
2740 }
2741}
2742#[doc = "Serial Peripheral Interfaces (SPI)"]
2743pub use self::spi0 as spi5;
2744#[doc = "Serial Peripheral Interfaces (SPI)"]
2745pub struct SPI6 {
2746 _marker: PhantomData<*const ()>,
2747}
2748unsafe impl Send for SPI6 {}
2749impl SPI6 {
2750 #[doc = r"Pointer to the register block"]
2751 pub const PTR: *const spi0::RegisterBlock = 0x4012_4000 as *const _;
2752 #[doc = r"Return the pointer to the register block"]
2753 #[inline(always)]
2754 pub const fn ptr() -> *const spi0::RegisterBlock {
2755 Self::PTR
2756 }
2757}
2758impl Deref for SPI6 {
2759 type Target = spi0::RegisterBlock;
2760 #[inline(always)]
2761 fn deref(&self) -> &Self::Target {
2762 unsafe { &*Self::PTR }
2763 }
2764}
2765impl core::fmt::Debug for SPI6 {
2766 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2767 f.debug_struct("SPI6").finish()
2768 }
2769}
2770#[doc = "Serial Peripheral Interfaces (SPI)"]
2771pub use self::spi0 as spi6;
2772#[doc = "Serial Peripheral Interfaces (SPI)"]
2773pub struct SPI7 {
2774 _marker: PhantomData<*const ()>,
2775}
2776unsafe impl Send for SPI7 {}
2777impl SPI7 {
2778 #[doc = r"Pointer to the register block"]
2779 pub const PTR: *const spi0::RegisterBlock = 0x4012_5000 as *const _;
2780 #[doc = r"Return the pointer to the register block"]
2781 #[inline(always)]
2782 pub const fn ptr() -> *const spi0::RegisterBlock {
2783 Self::PTR
2784 }
2785}
2786impl Deref for SPI7 {
2787 type Target = spi0::RegisterBlock;
2788 #[inline(always)]
2789 fn deref(&self) -> &Self::Target {
2790 unsafe { &*Self::PTR }
2791 }
2792}
2793impl core::fmt::Debug for SPI7 {
2794 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2795 f.debug_struct("SPI7").finish()
2796 }
2797}
2798#[doc = "Serial Peripheral Interfaces (SPI)"]
2799pub use self::spi0 as spi7;
2800#[doc = "Serial Peripheral Interfaces (SPI)"]
2801pub struct SPI14 {
2802 _marker: PhantomData<*const ()>,
2803}
2804unsafe impl Send for SPI14 {}
2805impl SPI14 {
2806 #[doc = r"Pointer to the register block"]
2807 pub const PTR: *const spi0::RegisterBlock = 0x4012_6000 as *const _;
2808 #[doc = r"Return the pointer to the register block"]
2809 #[inline(always)]
2810 pub const fn ptr() -> *const spi0::RegisterBlock {
2811 Self::PTR
2812 }
2813}
2814impl Deref for SPI14 {
2815 type Target = spi0::RegisterBlock;
2816 #[inline(always)]
2817 fn deref(&self) -> &Self::Target {
2818 unsafe { &*Self::PTR }
2819 }
2820}
2821impl core::fmt::Debug for SPI14 {
2822 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2823 f.debug_struct("SPI14").finish()
2824 }
2825}
2826#[doc = "Serial Peripheral Interfaces (SPI)"]
2827pub use self::spi0 as spi14;
2828#[doc = "Serial Peripheral Interfaces (SPI)"]
2829pub struct SPI16 {
2830 _marker: PhantomData<*const ()>,
2831}
2832unsafe impl Send for SPI16 {}
2833impl SPI16 {
2834 #[doc = r"Pointer to the register block"]
2835 pub const PTR: *const spi0::RegisterBlock = 0x4012_8000 as *const _;
2836 #[doc = r"Return the pointer to the register block"]
2837 #[inline(always)]
2838 pub const fn ptr() -> *const spi0::RegisterBlock {
2839 Self::PTR
2840 }
2841}
2842impl Deref for SPI16 {
2843 type Target = spi0::RegisterBlock;
2844 #[inline(always)]
2845 fn deref(&self) -> &Self::Target {
2846 unsafe { &*Self::PTR }
2847 }
2848}
2849impl core::fmt::Debug for SPI16 {
2850 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2851 f.debug_struct("SPI16").finish()
2852 }
2853}
2854#[doc = "Serial Peripheral Interfaces (SPI)"]
2855pub use self::spi0 as spi16;
2856#[doc = "Serial Peripheral Interfaces (SPI)"]
2857pub struct SPI8 {
2858 _marker: PhantomData<*const ()>,
2859}
2860unsafe impl Send for SPI8 {}
2861impl SPI8 {
2862 #[doc = r"Pointer to the register block"]
2863 pub const PTR: *const spi0::RegisterBlock = 0x4020_9000 as *const _;
2864 #[doc = r"Return the pointer to the register block"]
2865 #[inline(always)]
2866 pub const fn ptr() -> *const spi0::RegisterBlock {
2867 Self::PTR
2868 }
2869}
2870impl Deref for SPI8 {
2871 type Target = spi0::RegisterBlock;
2872 #[inline(always)]
2873 fn deref(&self) -> &Self::Target {
2874 unsafe { &*Self::PTR }
2875 }
2876}
2877impl core::fmt::Debug for SPI8 {
2878 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2879 f.debug_struct("SPI8").finish()
2880 }
2881}
2882#[doc = "Serial Peripheral Interfaces (SPI)"]
2883pub use self::spi0 as spi8;
2884#[doc = "Serial Peripheral Interfaces (SPI)"]
2885pub struct SPI9 {
2886 _marker: PhantomData<*const ()>,
2887}
2888unsafe impl Send for SPI9 {}
2889impl SPI9 {
2890 #[doc = r"Pointer to the register block"]
2891 pub const PTR: *const spi0::RegisterBlock = 0x4020_a000 as *const _;
2892 #[doc = r"Return the pointer to the register block"]
2893 #[inline(always)]
2894 pub const fn ptr() -> *const spi0::RegisterBlock {
2895 Self::PTR
2896 }
2897}
2898impl Deref for SPI9 {
2899 type Target = spi0::RegisterBlock;
2900 #[inline(always)]
2901 fn deref(&self) -> &Self::Target {
2902 unsafe { &*Self::PTR }
2903 }
2904}
2905impl core::fmt::Debug for SPI9 {
2906 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2907 f.debug_struct("SPI9").finish()
2908 }
2909}
2910#[doc = "Serial Peripheral Interfaces (SPI)"]
2911pub use self::spi0 as spi9;
2912#[doc = "Serial Peripheral Interfaces (SPI)"]
2913pub struct SPI10 {
2914 _marker: PhantomData<*const ()>,
2915}
2916unsafe impl Send for SPI10 {}
2917impl SPI10 {
2918 #[doc = r"Pointer to the register block"]
2919 pub const PTR: *const spi0::RegisterBlock = 0x4020_b000 as *const _;
2920 #[doc = r"Return the pointer to the register block"]
2921 #[inline(always)]
2922 pub const fn ptr() -> *const spi0::RegisterBlock {
2923 Self::PTR
2924 }
2925}
2926impl Deref for SPI10 {
2927 type Target = spi0::RegisterBlock;
2928 #[inline(always)]
2929 fn deref(&self) -> &Self::Target {
2930 unsafe { &*Self::PTR }
2931 }
2932}
2933impl core::fmt::Debug for SPI10 {
2934 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2935 f.debug_struct("SPI10").finish()
2936 }
2937}
2938#[doc = "Serial Peripheral Interfaces (SPI)"]
2939pub use self::spi0 as spi10;
2940#[doc = "Serial Peripheral Interfaces (SPI)"]
2941pub struct SPI11 {
2942 _marker: PhantomData<*const ()>,
2943}
2944unsafe impl Send for SPI11 {}
2945impl SPI11 {
2946 #[doc = r"Pointer to the register block"]
2947 pub const PTR: *const spi0::RegisterBlock = 0x4020_c000 as *const _;
2948 #[doc = r"Return the pointer to the register block"]
2949 #[inline(always)]
2950 pub const fn ptr() -> *const spi0::RegisterBlock {
2951 Self::PTR
2952 }
2953}
2954impl Deref for SPI11 {
2955 type Target = spi0::RegisterBlock;
2956 #[inline(always)]
2957 fn deref(&self) -> &Self::Target {
2958 unsafe { &*Self::PTR }
2959 }
2960}
2961impl core::fmt::Debug for SPI11 {
2962 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2963 f.debug_struct("SPI11").finish()
2964 }
2965}
2966#[doc = "Serial Peripheral Interfaces (SPI)"]
2967pub use self::spi0 as spi11;
2968#[doc = "Serial Peripheral Interfaces (SPI)"]
2969pub struct SPI12 {
2970 _marker: PhantomData<*const ()>,
2971}
2972unsafe impl Send for SPI12 {}
2973impl SPI12 {
2974 #[doc = r"Pointer to the register block"]
2975 pub const PTR: *const spi0::RegisterBlock = 0x4020_d000 as *const _;
2976 #[doc = r"Return the pointer to the register block"]
2977 #[inline(always)]
2978 pub const fn ptr() -> *const spi0::RegisterBlock {
2979 Self::PTR
2980 }
2981}
2982impl Deref for SPI12 {
2983 type Target = spi0::RegisterBlock;
2984 #[inline(always)]
2985 fn deref(&self) -> &Self::Target {
2986 unsafe { &*Self::PTR }
2987 }
2988}
2989impl core::fmt::Debug for SPI12 {
2990 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2991 f.debug_struct("SPI12").finish()
2992 }
2993}
2994#[doc = "Serial Peripheral Interfaces (SPI)"]
2995pub use self::spi0 as spi12;
2996#[doc = "Serial Peripheral Interfaces (SPI)"]
2997pub struct SPI13 {
2998 _marker: PhantomData<*const ()>,
2999}
3000unsafe impl Send for SPI13 {}
3001impl SPI13 {
3002 #[doc = r"Pointer to the register block"]
3003 pub const PTR: *const spi0::RegisterBlock = 0x4020_e000 as *const _;
3004 #[doc = r"Return the pointer to the register block"]
3005 #[inline(always)]
3006 pub const fn ptr() -> *const spi0::RegisterBlock {
3007 Self::PTR
3008 }
3009}
3010impl Deref for SPI13 {
3011 type Target = spi0::RegisterBlock;
3012 #[inline(always)]
3013 fn deref(&self) -> &Self::Target {
3014 unsafe { &*Self::PTR }
3015 }
3016}
3017impl core::fmt::Debug for SPI13 {
3018 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3019 f.debug_struct("SPI13").finish()
3020 }
3021}
3022#[doc = "Serial Peripheral Interfaces (SPI)"]
3023pub use self::spi0 as spi13;
3024#[doc = "Flexcomm USART"]
3025pub struct USART0 {
3026 _marker: PhantomData<*const ()>,
3027}
3028unsafe impl Send for USART0 {}
3029impl USART0 {
3030 #[doc = r"Pointer to the register block"]
3031 pub const PTR: *const usart0::RegisterBlock = 0x4010_6000 as *const _;
3032 #[doc = r"Return the pointer to the register block"]
3033 #[inline(always)]
3034 pub const fn ptr() -> *const usart0::RegisterBlock {
3035 Self::PTR
3036 }
3037}
3038impl Deref for USART0 {
3039 type Target = usart0::RegisterBlock;
3040 #[inline(always)]
3041 fn deref(&self) -> &Self::Target {
3042 unsafe { &*Self::PTR }
3043 }
3044}
3045impl core::fmt::Debug for USART0 {
3046 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3047 f.debug_struct("USART0").finish()
3048 }
3049}
3050#[doc = "Flexcomm USART"]
3051pub mod usart0;
3052#[doc = "Flexcomm USART"]
3053pub struct USART1 {
3054 _marker: PhantomData<*const ()>,
3055}
3056unsafe impl Send for USART1 {}
3057impl USART1 {
3058 #[doc = r"Pointer to the register block"]
3059 pub const PTR: *const usart0::RegisterBlock = 0x4010_7000 as *const _;
3060 #[doc = r"Return the pointer to the register block"]
3061 #[inline(always)]
3062 pub const fn ptr() -> *const usart0::RegisterBlock {
3063 Self::PTR
3064 }
3065}
3066impl Deref for USART1 {
3067 type Target = usart0::RegisterBlock;
3068 #[inline(always)]
3069 fn deref(&self) -> &Self::Target {
3070 unsafe { &*Self::PTR }
3071 }
3072}
3073impl core::fmt::Debug for USART1 {
3074 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3075 f.debug_struct("USART1").finish()
3076 }
3077}
3078#[doc = "Flexcomm USART"]
3079pub use self::usart0 as usart1;
3080#[doc = "Flexcomm USART"]
3081pub struct USART2 {
3082 _marker: PhantomData<*const ()>,
3083}
3084unsafe impl Send for USART2 {}
3085impl USART2 {
3086 #[doc = r"Pointer to the register block"]
3087 pub const PTR: *const usart0::RegisterBlock = 0x4010_8000 as *const _;
3088 #[doc = r"Return the pointer to the register block"]
3089 #[inline(always)]
3090 pub const fn ptr() -> *const usart0::RegisterBlock {
3091 Self::PTR
3092 }
3093}
3094impl Deref for USART2 {
3095 type Target = usart0::RegisterBlock;
3096 #[inline(always)]
3097 fn deref(&self) -> &Self::Target {
3098 unsafe { &*Self::PTR }
3099 }
3100}
3101impl core::fmt::Debug for USART2 {
3102 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3103 f.debug_struct("USART2").finish()
3104 }
3105}
3106#[doc = "Flexcomm USART"]
3107pub use self::usart0 as usart2;
3108#[doc = "Flexcomm USART"]
3109pub struct USART3 {
3110 _marker: PhantomData<*const ()>,
3111}
3112unsafe impl Send for USART3 {}
3113impl USART3 {
3114 #[doc = r"Pointer to the register block"]
3115 pub const PTR: *const usart0::RegisterBlock = 0x4010_9000 as *const _;
3116 #[doc = r"Return the pointer to the register block"]
3117 #[inline(always)]
3118 pub const fn ptr() -> *const usart0::RegisterBlock {
3119 Self::PTR
3120 }
3121}
3122impl Deref for USART3 {
3123 type Target = usart0::RegisterBlock;
3124 #[inline(always)]
3125 fn deref(&self) -> &Self::Target {
3126 unsafe { &*Self::PTR }
3127 }
3128}
3129impl core::fmt::Debug for USART3 {
3130 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3131 f.debug_struct("USART3").finish()
3132 }
3133}
3134#[doc = "Flexcomm USART"]
3135pub use self::usart0 as usart3;
3136#[doc = "Flexcomm USART"]
3137pub struct USART4 {
3138 _marker: PhantomData<*const ()>,
3139}
3140unsafe impl Send for USART4 {}
3141impl USART4 {
3142 #[doc = r"Pointer to the register block"]
3143 pub const PTR: *const usart0::RegisterBlock = 0x4012_2000 as *const _;
3144 #[doc = r"Return the pointer to the register block"]
3145 #[inline(always)]
3146 pub const fn ptr() -> *const usart0::RegisterBlock {
3147 Self::PTR
3148 }
3149}
3150impl Deref for USART4 {
3151 type Target = usart0::RegisterBlock;
3152 #[inline(always)]
3153 fn deref(&self) -> &Self::Target {
3154 unsafe { &*Self::PTR }
3155 }
3156}
3157impl core::fmt::Debug for USART4 {
3158 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3159 f.debug_struct("USART4").finish()
3160 }
3161}
3162#[doc = "Flexcomm USART"]
3163pub use self::usart0 as usart4;
3164#[doc = "Flexcomm USART"]
3165pub struct USART5 {
3166 _marker: PhantomData<*const ()>,
3167}
3168unsafe impl Send for USART5 {}
3169impl USART5 {
3170 #[doc = r"Pointer to the register block"]
3171 pub const PTR: *const usart0::RegisterBlock = 0x4012_3000 as *const _;
3172 #[doc = r"Return the pointer to the register block"]
3173 #[inline(always)]
3174 pub const fn ptr() -> *const usart0::RegisterBlock {
3175 Self::PTR
3176 }
3177}
3178impl Deref for USART5 {
3179 type Target = usart0::RegisterBlock;
3180 #[inline(always)]
3181 fn deref(&self) -> &Self::Target {
3182 unsafe { &*Self::PTR }
3183 }
3184}
3185impl core::fmt::Debug for USART5 {
3186 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3187 f.debug_struct("USART5").finish()
3188 }
3189}
3190#[doc = "Flexcomm USART"]
3191pub use self::usart0 as usart5;
3192#[doc = "Flexcomm USART"]
3193pub struct USART6 {
3194 _marker: PhantomData<*const ()>,
3195}
3196unsafe impl Send for USART6 {}
3197impl USART6 {
3198 #[doc = r"Pointer to the register block"]
3199 pub const PTR: *const usart0::RegisterBlock = 0x4012_4000 as *const _;
3200 #[doc = r"Return the pointer to the register block"]
3201 #[inline(always)]
3202 pub const fn ptr() -> *const usart0::RegisterBlock {
3203 Self::PTR
3204 }
3205}
3206impl Deref for USART6 {
3207 type Target = usart0::RegisterBlock;
3208 #[inline(always)]
3209 fn deref(&self) -> &Self::Target {
3210 unsafe { &*Self::PTR }
3211 }
3212}
3213impl core::fmt::Debug for USART6 {
3214 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3215 f.debug_struct("USART6").finish()
3216 }
3217}
3218#[doc = "Flexcomm USART"]
3219pub use self::usart0 as usart6;
3220#[doc = "Flexcomm USART"]
3221pub struct USART7 {
3222 _marker: PhantomData<*const ()>,
3223}
3224unsafe impl Send for USART7 {}
3225impl USART7 {
3226 #[doc = r"Pointer to the register block"]
3227 pub const PTR: *const usart0::RegisterBlock = 0x4012_5000 as *const _;
3228 #[doc = r"Return the pointer to the register block"]
3229 #[inline(always)]
3230 pub const fn ptr() -> *const usart0::RegisterBlock {
3231 Self::PTR
3232 }
3233}
3234impl Deref for USART7 {
3235 type Target = usart0::RegisterBlock;
3236 #[inline(always)]
3237 fn deref(&self) -> &Self::Target {
3238 unsafe { &*Self::PTR }
3239 }
3240}
3241impl core::fmt::Debug for USART7 {
3242 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3243 f.debug_struct("USART7").finish()
3244 }
3245}
3246#[doc = "Flexcomm USART"]
3247pub use self::usart0 as usart7;
3248#[doc = "Flexcomm USART"]
3249pub struct USART8 {
3250 _marker: PhantomData<*const ()>,
3251}
3252unsafe impl Send for USART8 {}
3253impl USART8 {
3254 #[doc = r"Pointer to the register block"]
3255 pub const PTR: *const usart0::RegisterBlock = 0x4020_9000 as *const _;
3256 #[doc = r"Return the pointer to the register block"]
3257 #[inline(always)]
3258 pub const fn ptr() -> *const usart0::RegisterBlock {
3259 Self::PTR
3260 }
3261}
3262impl Deref for USART8 {
3263 type Target = usart0::RegisterBlock;
3264 #[inline(always)]
3265 fn deref(&self) -> &Self::Target {
3266 unsafe { &*Self::PTR }
3267 }
3268}
3269impl core::fmt::Debug for USART8 {
3270 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3271 f.debug_struct("USART8").finish()
3272 }
3273}
3274#[doc = "Flexcomm USART"]
3275pub use self::usart0 as usart8;
3276#[doc = "Flexcomm USART"]
3277pub struct USART9 {
3278 _marker: PhantomData<*const ()>,
3279}
3280unsafe impl Send for USART9 {}
3281impl USART9 {
3282 #[doc = r"Pointer to the register block"]
3283 pub const PTR: *const usart0::RegisterBlock = 0x4020_a000 as *const _;
3284 #[doc = r"Return the pointer to the register block"]
3285 #[inline(always)]
3286 pub const fn ptr() -> *const usart0::RegisterBlock {
3287 Self::PTR
3288 }
3289}
3290impl Deref for USART9 {
3291 type Target = usart0::RegisterBlock;
3292 #[inline(always)]
3293 fn deref(&self) -> &Self::Target {
3294 unsafe { &*Self::PTR }
3295 }
3296}
3297impl core::fmt::Debug for USART9 {
3298 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3299 f.debug_struct("USART9").finish()
3300 }
3301}
3302#[doc = "Flexcomm USART"]
3303pub use self::usart0 as usart9;
3304#[doc = "Flexcomm USART"]
3305pub struct USART10 {
3306 _marker: PhantomData<*const ()>,
3307}
3308unsafe impl Send for USART10 {}
3309impl USART10 {
3310 #[doc = r"Pointer to the register block"]
3311 pub const PTR: *const usart0::RegisterBlock = 0x4020_b000 as *const _;
3312 #[doc = r"Return the pointer to the register block"]
3313 #[inline(always)]
3314 pub const fn ptr() -> *const usart0::RegisterBlock {
3315 Self::PTR
3316 }
3317}
3318impl Deref for USART10 {
3319 type Target = usart0::RegisterBlock;
3320 #[inline(always)]
3321 fn deref(&self) -> &Self::Target {
3322 unsafe { &*Self::PTR }
3323 }
3324}
3325impl core::fmt::Debug for USART10 {
3326 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3327 f.debug_struct("USART10").finish()
3328 }
3329}
3330#[doc = "Flexcomm USART"]
3331pub use self::usart0 as usart10;
3332#[doc = "Flexcomm USART"]
3333pub struct USART11 {
3334 _marker: PhantomData<*const ()>,
3335}
3336unsafe impl Send for USART11 {}
3337impl USART11 {
3338 #[doc = r"Pointer to the register block"]
3339 pub const PTR: *const usart0::RegisterBlock = 0x4020_c000 as *const _;
3340 #[doc = r"Return the pointer to the register block"]
3341 #[inline(always)]
3342 pub const fn ptr() -> *const usart0::RegisterBlock {
3343 Self::PTR
3344 }
3345}
3346impl Deref for USART11 {
3347 type Target = usart0::RegisterBlock;
3348 #[inline(always)]
3349 fn deref(&self) -> &Self::Target {
3350 unsafe { &*Self::PTR }
3351 }
3352}
3353impl core::fmt::Debug for USART11 {
3354 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3355 f.debug_struct("USART11").finish()
3356 }
3357}
3358#[doc = "Flexcomm USART"]
3359pub use self::usart0 as usart11;
3360#[doc = "Flexcomm USART"]
3361pub struct USART12 {
3362 _marker: PhantomData<*const ()>,
3363}
3364unsafe impl Send for USART12 {}
3365impl USART12 {
3366 #[doc = r"Pointer to the register block"]
3367 pub const PTR: *const usart0::RegisterBlock = 0x4020_d000 as *const _;
3368 #[doc = r"Return the pointer to the register block"]
3369 #[inline(always)]
3370 pub const fn ptr() -> *const usart0::RegisterBlock {
3371 Self::PTR
3372 }
3373}
3374impl Deref for USART12 {
3375 type Target = usart0::RegisterBlock;
3376 #[inline(always)]
3377 fn deref(&self) -> &Self::Target {
3378 unsafe { &*Self::PTR }
3379 }
3380}
3381impl core::fmt::Debug for USART12 {
3382 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3383 f.debug_struct("USART12").finish()
3384 }
3385}
3386#[doc = "Flexcomm USART"]
3387pub use self::usart0 as usart12;
3388#[doc = "Flexcomm USART"]
3389pub struct USART13 {
3390 _marker: PhantomData<*const ()>,
3391}
3392unsafe impl Send for USART13 {}
3393impl USART13 {
3394 #[doc = r"Pointer to the register block"]
3395 pub const PTR: *const usart0::RegisterBlock = 0x4020_e000 as *const _;
3396 #[doc = r"Return the pointer to the register block"]
3397 #[inline(always)]
3398 pub const fn ptr() -> *const usart0::RegisterBlock {
3399 Self::PTR
3400 }
3401}
3402impl Deref for USART13 {
3403 type Target = usart0::RegisterBlock;
3404 #[inline(always)]
3405 fn deref(&self) -> &Self::Target {
3406 unsafe { &*Self::PTR }
3407 }
3408}
3409impl core::fmt::Debug for USART13 {
3410 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3411 f.debug_struct("USART13").finish()
3412 }
3413}
3414#[doc = "Flexcomm USART"]
3415pub use self::usart0 as usart13;
3416#[doc = "Debug"]
3417pub struct DEBUGGER_MAILBOX {
3418 _marker: PhantomData<*const ()>,
3419}
3420unsafe impl Send for DEBUGGER_MAILBOX {}
3421impl DEBUGGER_MAILBOX {
3422 #[doc = r"Pointer to the register block"]
3423 pub const PTR: *const debugger_mailbox::RegisterBlock = 0x4010_f000 as *const _;
3424 #[doc = r"Return the pointer to the register block"]
3425 #[inline(always)]
3426 pub const fn ptr() -> *const debugger_mailbox::RegisterBlock {
3427 Self::PTR
3428 }
3429}
3430impl Deref for DEBUGGER_MAILBOX {
3431 type Target = debugger_mailbox::RegisterBlock;
3432 #[inline(always)]
3433 fn deref(&self) -> &Self::Target {
3434 unsafe { &*Self::PTR }
3435 }
3436}
3437impl core::fmt::Debug for DEBUGGER_MAILBOX {
3438 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3439 f.debug_struct("DEBUGGER_MAILBOX").finish()
3440 }
3441}
3442#[doc = "Debug"]
3443pub mod debugger_mailbox;
3444#[doc = "MUA"]
3445pub struct MUA {
3446 _marker: PhantomData<*const ()>,
3447}
3448unsafe impl Send for MUA {}
3449impl MUA {
3450 #[doc = r"Pointer to the register block"]
3451 pub const PTR: *const mua::RegisterBlock = 0x4011_0000 as *const _;
3452 #[doc = r"Return the pointer to the register block"]
3453 #[inline(always)]
3454 pub const fn ptr() -> *const mua::RegisterBlock {
3455 Self::PTR
3456 }
3457}
3458impl Deref for MUA {
3459 type Target = mua::RegisterBlock;
3460 #[inline(always)]
3461 fn deref(&self) -> &Self::Target {
3462 unsafe { &*Self::PTR }
3463 }
3464}
3465impl core::fmt::Debug for MUA {
3466 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3467 f.debug_struct("MUA").finish()
3468 }
3469}
3470#[doc = "MUA"]
3471pub mod mua;
3472#[doc = "SEMA42"]
3473pub struct SEMA42 {
3474 _marker: PhantomData<*const ()>,
3475}
3476unsafe impl Send for SEMA42 {}
3477impl SEMA42 {
3478 #[doc = r"Pointer to the register block"]
3479 pub const PTR: *const sema42::RegisterBlock = 0x4011_2000 as *const _;
3480 #[doc = r"Return the pointer to the register block"]
3481 #[inline(always)]
3482 pub const fn ptr() -> *const sema42::RegisterBlock {
3483 Self::PTR
3484 }
3485}
3486impl Deref for SEMA42 {
3487 type Target = sema42::RegisterBlock;
3488 #[inline(always)]
3489 fn deref(&self) -> &Self::Target {
3490 unsafe { &*Self::PTR }
3491 }
3492}
3493impl core::fmt::Debug for SEMA42 {
3494 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3495 f.debug_struct("SEMA42").finish()
3496 }
3497}
3498#[doc = "SEMA42"]
3499pub mod sema42;
3500#[doc = "OSTIMER"]
3501pub struct OSTIMER0 {
3502 _marker: PhantomData<*const ()>,
3503}
3504unsafe impl Send for OSTIMER0 {}
3505impl OSTIMER0 {
3506 #[doc = r"Pointer to the register block"]
3507 pub const PTR: *const ostimer0::RegisterBlock = 0x4011_3000 as *const _;
3508 #[doc = r"Return the pointer to the register block"]
3509 #[inline(always)]
3510 pub const fn ptr() -> *const ostimer0::RegisterBlock {
3511 Self::PTR
3512 }
3513}
3514impl Deref for OSTIMER0 {
3515 type Target = ostimer0::RegisterBlock;
3516 #[inline(always)]
3517 fn deref(&self) -> &Self::Target {
3518 unsafe { &*Self::PTR }
3519 }
3520}
3521impl core::fmt::Debug for OSTIMER0 {
3522 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3523 f.debug_struct("OSTIMER0").finish()
3524 }
3525}
3526#[doc = "OSTIMER"]
3527pub mod ostimer0;
3528#[doc = "CRC"]
3529pub struct CRC_ENGINE {
3530 _marker: PhantomData<*const ()>,
3531}
3532unsafe impl Send for CRC_ENGINE {}
3533impl CRC_ENGINE {
3534 #[doc = r"Pointer to the register block"]
3535 pub const PTR: *const crc_engine::RegisterBlock = 0x4012_0000 as *const _;
3536 #[doc = r"Return the pointer to the register block"]
3537 #[inline(always)]
3538 pub const fn ptr() -> *const crc_engine::RegisterBlock {
3539 Self::PTR
3540 }
3541}
3542impl Deref for CRC_ENGINE {
3543 type Target = crc_engine::RegisterBlock;
3544 #[inline(always)]
3545 fn deref(&self) -> &Self::Target {
3546 unsafe { &*Self::PTR }
3547 }
3548}
3549impl core::fmt::Debug for CRC_ENGINE {
3550 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3551 f.debug_struct("CRC_ENGINE").finish()
3552 }
3553}
3554#[doc = "CRC"]
3555pub mod crc_engine;
3556#[doc = "DMIC"]
3557pub struct DMIC0 {
3558 _marker: PhantomData<*const ()>,
3559}
3560unsafe impl Send for DMIC0 {}
3561impl DMIC0 {
3562 #[doc = r"Pointer to the register block"]
3563 pub const PTR: *const dmic0::RegisterBlock = 0x4012_1000 as *const _;
3564 #[doc = r"Return the pointer to the register block"]
3565 #[inline(always)]
3566 pub const fn ptr() -> *const dmic0::RegisterBlock {
3567 Self::PTR
3568 }
3569}
3570impl Deref for DMIC0 {
3571 type Target = dmic0::RegisterBlock;
3572 #[inline(always)]
3573 fn deref(&self) -> &Self::Target {
3574 unsafe { &*Self::PTR }
3575 }
3576}
3577impl core::fmt::Debug for DMIC0 {
3578 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3579 f.debug_struct("DMIC0").finish()
3580 }
3581}
3582#[doc = "DMIC"]
3583pub mod dmic0;
3584#[doc = "OCOTP Controller"]
3585pub struct OCOTP0 {
3586 _marker: PhantomData<*const ()>,
3587}
3588unsafe impl Send for OCOTP0 {}
3589impl OCOTP0 {
3590 #[doc = r"Pointer to the register block"]
3591 pub const PTR: *const ocotp0::RegisterBlock = 0x4013_0000 as *const _;
3592 #[doc = r"Return the pointer to the register block"]
3593 #[inline(always)]
3594 pub const fn ptr() -> *const ocotp0::RegisterBlock {
3595 Self::PTR
3596 }
3597}
3598impl Deref for OCOTP0 {
3599 type Target = ocotp0::RegisterBlock;
3600 #[inline(always)]
3601 fn deref(&self) -> &Self::Target {
3602 unsafe { &*Self::PTR }
3603 }
3604}
3605impl core::fmt::Debug for OCOTP0 {
3606 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3607 f.debug_struct("OCOTP0").finish()
3608 }
3609}
3610#[doc = "OCOTP Controller"]
3611pub mod ocotp0;
3612#[doc = "FlexSPI"]
3613pub struct FLEXSPI0 {
3614 _marker: PhantomData<*const ()>,
3615}
3616unsafe impl Send for FLEXSPI0 {}
3617impl FLEXSPI0 {
3618 #[doc = r"Pointer to the register block"]
3619 pub const PTR: *const flexspi0::RegisterBlock = 0x4013_4000 as *const _;
3620 #[doc = r"Return the pointer to the register block"]
3621 #[inline(always)]
3622 pub const fn ptr() -> *const flexspi0::RegisterBlock {
3623 Self::PTR
3624 }
3625}
3626impl Deref for FLEXSPI0 {
3627 type Target = flexspi0::RegisterBlock;
3628 #[inline(always)]
3629 fn deref(&self) -> &Self::Target {
3630 unsafe { &*Self::PTR }
3631 }
3632}
3633impl core::fmt::Debug for FLEXSPI0 {
3634 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3635 f.debug_struct("FLEXSPI0").finish()
3636 }
3637}
3638#[doc = "FlexSPI"]
3639pub mod flexspi0;
3640#[doc = "OTFAD"]
3641pub struct OTFAD0 {
3642 _marker: PhantomData<*const ()>,
3643}
3644unsafe impl Send for OTFAD0 {}
3645impl OTFAD0 {
3646 #[doc = r"Pointer to the register block"]
3647 pub const PTR: *const otfad0::RegisterBlock = 0x4013_4000 as *const _;
3648 #[doc = r"Return the pointer to the register block"]
3649 #[inline(always)]
3650 pub const fn ptr() -> *const otfad0::RegisterBlock {
3651 Self::PTR
3652 }
3653}
3654impl Deref for OTFAD0 {
3655 type Target = otfad0::RegisterBlock;
3656 #[inline(always)]
3657 fn deref(&self) -> &Self::Target {
3658 unsafe { &*Self::PTR }
3659 }
3660}
3661impl core::fmt::Debug for OTFAD0 {
3662 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3663 f.debug_struct("OTFAD0").finish()
3664 }
3665}
3666#[doc = "OTFAD"]
3667pub mod otfad0;
3668#[doc = "Power Management"]
3669pub struct PMC {
3670 _marker: PhantomData<*const ()>,
3671}
3672unsafe impl Send for PMC {}
3673impl PMC {
3674 #[doc = r"Pointer to the register block"]
3675 pub const PTR: *const pmc::RegisterBlock = 0x4013_5000 as *const _;
3676 #[doc = r"Return the pointer to the register block"]
3677 #[inline(always)]
3678 pub const fn ptr() -> *const pmc::RegisterBlock {
3679 Self::PTR
3680 }
3681}
3682impl Deref for PMC {
3683 type Target = pmc::RegisterBlock;
3684 #[inline(always)]
3685 fn deref(&self) -> &Self::Target {
3686 unsafe { &*Self::PTR }
3687 }
3688}
3689impl core::fmt::Debug for PMC {
3690 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3691 f.debug_struct("PMC").finish()
3692 }
3693}
3694#[doc = "Power Management"]
3695pub mod pmc;
3696#[doc = "uSDHC"]
3697pub struct USDHC0 {
3698 _marker: PhantomData<*const ()>,
3699}
3700unsafe impl Send for USDHC0 {}
3701impl USDHC0 {
3702 #[doc = r"Pointer to the register block"]
3703 pub const PTR: *const usdhc0::RegisterBlock = 0x4013_6000 as *const _;
3704 #[doc = r"Return the pointer to the register block"]
3705 #[inline(always)]
3706 pub const fn ptr() -> *const usdhc0::RegisterBlock {
3707 Self::PTR
3708 }
3709}
3710impl Deref for USDHC0 {
3711 type Target = usdhc0::RegisterBlock;
3712 #[inline(always)]
3713 fn deref(&self) -> &Self::Target {
3714 unsafe { &*Self::PTR }
3715 }
3716}
3717impl core::fmt::Debug for USDHC0 {
3718 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3719 f.debug_struct("USDHC0").finish()
3720 }
3721}
3722#[doc = "uSDHC"]
3723pub mod usdhc0;
3724#[doc = "uSDHC"]
3725pub struct USDHC1 {
3726 _marker: PhantomData<*const ()>,
3727}
3728unsafe impl Send for USDHC1 {}
3729impl USDHC1 {
3730 #[doc = r"Pointer to the register block"]
3731 pub const PTR: *const usdhc1::RegisterBlock = 0x4013_7000 as *const _;
3732 #[doc = r"Return the pointer to the register block"]
3733 #[inline(always)]
3734 pub const fn ptr() -> *const usdhc1::RegisterBlock {
3735 Self::PTR
3736 }
3737}
3738impl Deref for USDHC1 {
3739 type Target = usdhc1::RegisterBlock;
3740 #[inline(always)]
3741 fn deref(&self) -> &Self::Target {
3742 unsafe { &*Self::PTR }
3743 }
3744}
3745impl core::fmt::Debug for USDHC1 {
3746 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3747 f.debug_struct("USDHC1").finish()
3748 }
3749}
3750#[doc = "uSDHC"]
3751pub mod usdhc1;
3752#[doc = "TRNG"]
3753pub struct TRNG {
3754 _marker: PhantomData<*const ()>,
3755}
3756unsafe impl Send for TRNG {}
3757impl TRNG {
3758 #[doc = r"Pointer to the register block"]
3759 pub const PTR: *const trng::RegisterBlock = 0x4013_8000 as *const _;
3760 #[doc = r"Return the pointer to the register block"]
3761 #[inline(always)]
3762 pub const fn ptr() -> *const trng::RegisterBlock {
3763 Self::PTR
3764 }
3765}
3766impl Deref for TRNG {
3767 type Target = trng::RegisterBlock;
3768 #[inline(always)]
3769 fn deref(&self) -> &Self::Target {
3770 unsafe { &*Self::PTR }
3771 }
3772}
3773impl core::fmt::Debug for TRNG {
3774 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3775 f.debug_struct("TRNG").finish()
3776 }
3777}
3778#[doc = "TRNG"]
3779pub mod trng;
3780#[doc = "CMP"]
3781pub struct ACMP0 {
3782 _marker: PhantomData<*const ()>,
3783}
3784unsafe impl Send for ACMP0 {}
3785impl ACMP0 {
3786 #[doc = r"Pointer to the register block"]
3787 pub const PTR: *const acmp0::RegisterBlock = 0x4013_9000 as *const _;
3788 #[doc = r"Return the pointer to the register block"]
3789 #[inline(always)]
3790 pub const fn ptr() -> *const acmp0::RegisterBlock {
3791 Self::PTR
3792 }
3793}
3794impl Deref for ACMP0 {
3795 type Target = acmp0::RegisterBlock;
3796 #[inline(always)]
3797 fn deref(&self) -> &Self::Target {
3798 unsafe { &*Self::PTR }
3799 }
3800}
3801impl core::fmt::Debug for ACMP0 {
3802 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3803 f.debug_struct("ACMP0").finish()
3804 }
3805}
3806#[doc = "CMP"]
3807pub mod acmp0;
3808#[doc = "ADC"]
3809pub struct ADC0 {
3810 _marker: PhantomData<*const ()>,
3811}
3812unsafe impl Send for ADC0 {}
3813impl ADC0 {
3814 #[doc = r"Pointer to the register block"]
3815 pub const PTR: *const adc0::RegisterBlock = 0x4013_a000 as *const _;
3816 #[doc = r"Return the pointer to the register block"]
3817 #[inline(always)]
3818 pub const fn ptr() -> *const adc0::RegisterBlock {
3819 Self::PTR
3820 }
3821}
3822impl Deref for ADC0 {
3823 type Target = adc0::RegisterBlock;
3824 #[inline(always)]
3825 fn deref(&self) -> &Self::Target {
3826 unsafe { &*Self::PTR }
3827 }
3828}
3829impl core::fmt::Debug for ADC0 {
3830 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3831 f.debug_struct("ADC0").finish()
3832 }
3833}
3834#[doc = "ADC"]
3835pub mod adc0;
3836#[doc = "USB2.0 HS PHY"]
3837pub struct USBPHY {
3838 _marker: PhantomData<*const ()>,
3839}
3840unsafe impl Send for USBPHY {}
3841impl USBPHY {
3842 #[doc = r"Pointer to the register block"]
3843 pub const PTR: *const usbphy::RegisterBlock = 0x4013_b000 as *const _;
3844 #[doc = r"Return the pointer to the register block"]
3845 #[inline(always)]
3846 pub const fn ptr() -> *const usbphy::RegisterBlock {
3847 Self::PTR
3848 }
3849}
3850impl Deref for USBPHY {
3851 type Target = usbphy::RegisterBlock;
3852 #[inline(always)]
3853 fn deref(&self) -> &Self::Target {
3854 unsafe { &*Self::PTR }
3855 }
3856}
3857impl core::fmt::Debug for USBPHY {
3858 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3859 f.debug_struct("USBPHY").finish()
3860 }
3861}
3862#[doc = "USB2.0 HS PHY"]
3863pub mod usbphy;
3864#[doc = "USBDCD"]
3865pub struct USBHSDCD {
3866 _marker: PhantomData<*const ()>,
3867}
3868unsafe impl Send for USBHSDCD {}
3869impl USBHSDCD {
3870 #[doc = r"Pointer to the register block"]
3871 pub const PTR: *const usbhsdcd::RegisterBlock = 0x4013_b800 as *const _;
3872 #[doc = r"Return the pointer to the register block"]
3873 #[inline(always)]
3874 pub const fn ptr() -> *const usbhsdcd::RegisterBlock {
3875 Self::PTR
3876 }
3877}
3878impl Deref for USBHSDCD {
3879 type Target = usbhsdcd::RegisterBlock;
3880 #[inline(always)]
3881 fn deref(&self) -> &Self::Target {
3882 unsafe { &*Self::PTR }
3883 }
3884}
3885impl core::fmt::Debug for USBHSDCD {
3886 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3887 f.debug_struct("USBHSDCD").finish()
3888 }
3889}
3890#[doc = "USBDCD"]
3891pub mod usbhsdcd;
3892#[doc = "FlexSPI"]
3893pub struct FLEXSPI1 {
3894 _marker: PhantomData<*const ()>,
3895}
3896unsafe impl Send for FLEXSPI1 {}
3897impl FLEXSPI1 {
3898 #[doc = r"Pointer to the register block"]
3899 pub const PTR: *const flexspi1::RegisterBlock = 0x4013_c000 as *const _;
3900 #[doc = r"Return the pointer to the register block"]
3901 #[inline(always)]
3902 pub const fn ptr() -> *const flexspi1::RegisterBlock {
3903 Self::PTR
3904 }
3905}
3906impl Deref for FLEXSPI1 {
3907 type Target = flexspi1::RegisterBlock;
3908 #[inline(always)]
3909 fn deref(&self) -> &Self::Target {
3910 unsafe { &*Self::PTR }
3911 }
3912}
3913impl core::fmt::Debug for FLEXSPI1 {
3914 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3915 f.debug_struct("FLEXSPI1").finish()
3916 }
3917}
3918#[doc = "FlexSPI"]
3919pub mod flexspi1;
3920#[doc = "USB2.0 HS Device Controller"]
3921pub struct USBHSD {
3922 _marker: PhantomData<*const ()>,
3923}
3924unsafe impl Send for USBHSD {}
3925impl USBHSD {
3926 #[doc = r"Pointer to the register block"]
3927 pub const PTR: *const usbhsd::RegisterBlock = 0x4014_4000 as *const _;
3928 #[doc = r"Return the pointer to the register block"]
3929 #[inline(always)]
3930 pub const fn ptr() -> *const usbhsd::RegisterBlock {
3931 Self::PTR
3932 }
3933}
3934impl Deref for USBHSD {
3935 type Target = usbhsd::RegisterBlock;
3936 #[inline(always)]
3937 fn deref(&self) -> &Self::Target {
3938 unsafe { &*Self::PTR }
3939 }
3940}
3941impl core::fmt::Debug for USBHSD {
3942 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3943 f.debug_struct("USBHSD").finish()
3944 }
3945}
3946#[doc = "USB2.0 HS Device Controller"]
3947pub mod usbhsd;
3948#[doc = "USB2.0 HS Host Controller"]
3949pub struct USBHSH {
3950 _marker: PhantomData<*const ()>,
3951}
3952unsafe impl Send for USBHSH {}
3953impl USBHSH {
3954 #[doc = r"Pointer to the register block"]
3955 pub const PTR: *const usbhsh::RegisterBlock = 0x4014_5000 as *const _;
3956 #[doc = r"Return the pointer to the register block"]
3957 #[inline(always)]
3958 pub const fn ptr() -> *const usbhsh::RegisterBlock {
3959 Self::PTR
3960 }
3961}
3962impl Deref for USBHSH {
3963 type Target = usbhsh::RegisterBlock;
3964 #[inline(always)]
3965 fn deref(&self) -> &Self::Target {
3966 unsafe { &*Self::PTR }
3967 }
3968}
3969impl core::fmt::Debug for USBHSH {
3970 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3971 f.debug_struct("USBHSH").finish()
3972 }
3973}
3974#[doc = "USB2.0 HS Host Controller"]
3975pub mod usbhsh;
3976#[doc = "SCTimer"]
3977pub struct SCT0 {
3978 _marker: PhantomData<*const ()>,
3979}
3980unsafe impl Send for SCT0 {}
3981impl SCT0 {
3982 #[doc = r"Pointer to the register block"]
3983 pub const PTR: *const sct0::RegisterBlock = 0x4014_6000 as *const _;
3984 #[doc = r"Return the pointer to the register block"]
3985 #[inline(always)]
3986 pub const fn ptr() -> *const sct0::RegisterBlock {
3987 Self::PTR
3988 }
3989}
3990impl Deref for SCT0 {
3991 type Target = sct0::RegisterBlock;
3992 #[inline(always)]
3993 fn deref(&self) -> &Self::Target {
3994 unsafe { &*Self::PTR }
3995 }
3996}
3997impl core::fmt::Debug for SCT0 {
3998 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3999 f.debug_struct("SCT0").finish()
4000 }
4001}
4002#[doc = "SCTimer"]
4003pub mod sct0;
4004#[doc = "AHBSC"]
4005pub struct AHB_SECURE_CTRL {
4006 _marker: PhantomData<*const ()>,
4007}
4008unsafe impl Send for AHB_SECURE_CTRL {}
4009impl AHB_SECURE_CTRL {
4010 #[doc = r"Pointer to the register block"]
4011 pub const PTR: *const ahb_secure_ctrl::RegisterBlock = 0x4014_8000 as *const _;
4012 #[doc = r"Return the pointer to the register block"]
4013 #[inline(always)]
4014 pub const fn ptr() -> *const ahb_secure_ctrl::RegisterBlock {
4015 Self::PTR
4016 }
4017}
4018impl Deref for AHB_SECURE_CTRL {
4019 type Target = ahb_secure_ctrl::RegisterBlock;
4020 #[inline(always)]
4021 fn deref(&self) -> &Self::Target {
4022 unsafe { &*Self::PTR }
4023 }
4024}
4025impl core::fmt::Debug for AHB_SECURE_CTRL {
4026 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4027 f.debug_struct("AHB_SECURE_CTRL").finish()
4028 }
4029}
4030#[doc = "AHBSC"]
4031pub mod ahb_secure_ctrl;
4032#[doc = "PowerQuad"]
4033pub struct POWERQUAD {
4034 _marker: PhantomData<*const ()>,
4035}
4036unsafe impl Send for POWERQUAD {}
4037impl POWERQUAD {
4038 #[doc = r"Pointer to the register block"]
4039 pub const PTR: *const powerquad::RegisterBlock = 0x4020_0000 as *const _;
4040 #[doc = r"Return the pointer to the register block"]
4041 #[inline(always)]
4042 pub const fn ptr() -> *const powerquad::RegisterBlock {
4043 Self::PTR
4044 }
4045}
4046impl Deref for POWERQUAD {
4047 type Target = powerquad::RegisterBlock;
4048 #[inline(always)]
4049 fn deref(&self) -> &Self::Target {
4050 unsafe { &*Self::PTR }
4051 }
4052}
4053impl core::fmt::Debug for POWERQUAD {
4054 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4055 f.debug_struct("POWERQUAD").finish()
4056 }
4057}
4058#[doc = "PowerQuad"]
4059pub mod powerquad;
4060#[doc = "CASPER"]
4061pub struct CASPER {
4062 _marker: PhantomData<*const ()>,
4063}
4064unsafe impl Send for CASPER {}
4065impl CASPER {
4066 #[doc = r"Pointer to the register block"]
4067 pub const PTR: *const casper::RegisterBlock = 0x4020_1000 as *const _;
4068 #[doc = r"Return the pointer to the register block"]
4069 #[inline(always)]
4070 pub const fn ptr() -> *const casper::RegisterBlock {
4071 Self::PTR
4072 }
4073}
4074impl Deref for CASPER {
4075 type Target = casper::RegisterBlock;
4076 #[inline(always)]
4077 fn deref(&self) -> &Self::Target {
4078 unsafe { &*Self::PTR }
4079 }
4080}
4081impl core::fmt::Debug for CASPER {
4082 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4083 f.debug_struct("CASPER").finish()
4084 }
4085}
4086#[doc = "CASPER"]
4087pub mod casper;
4088#[doc = "SECGPIO General Purpose I/O (GPIO)"]
4089pub struct SECGPIO {
4090 _marker: PhantomData<*const ()>,
4091}
4092unsafe impl Send for SECGPIO {}
4093impl SECGPIO {
4094 #[doc = r"Pointer to the register block"]
4095 pub const PTR: *const secgpio::RegisterBlock = 0x4020_4000 as *const _;
4096 #[doc = r"Return the pointer to the register block"]
4097 #[inline(always)]
4098 pub const fn ptr() -> *const secgpio::RegisterBlock {
4099 Self::PTR
4100 }
4101}
4102impl Deref for SECGPIO {
4103 type Target = secgpio::RegisterBlock;
4104 #[inline(always)]
4105 fn deref(&self) -> &Self::Target {
4106 unsafe { &*Self::PTR }
4107 }
4108}
4109impl core::fmt::Debug for SECGPIO {
4110 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4111 f.debug_struct("SECGPIO").finish()
4112 }
4113}
4114#[doc = "SECGPIO General Purpose I/O (GPIO)"]
4115pub mod secgpio;
4116#[doc = "HASHCRYPT"]
4117pub struct HASHCRYPT {
4118 _marker: PhantomData<*const ()>,
4119}
4120unsafe impl Send for HASHCRYPT {}
4121impl HASHCRYPT {
4122 #[doc = r"Pointer to the register block"]
4123 pub const PTR: *const hashcrypt::RegisterBlock = 0x4020_8000 as *const _;
4124 #[doc = r"Return the pointer to the register block"]
4125 #[inline(always)]
4126 pub const fn ptr() -> *const hashcrypt::RegisterBlock {
4127 Self::PTR
4128 }
4129}
4130impl Deref for HASHCRYPT {
4131 type Target = hashcrypt::RegisterBlock;
4132 #[inline(always)]
4133 fn deref(&self) -> &Self::Target {
4134 unsafe { &*Self::PTR }
4135 }
4136}
4137impl core::fmt::Debug for HASHCRYPT {
4138 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4139 f.debug_struct("HASHCRYPT").finish()
4140 }
4141}
4142#[doc = "HASHCRYPT"]
4143pub mod hashcrypt;
4144#[doc = "LCDIF"]
4145pub struct LCDIF {
4146 _marker: PhantomData<*const ()>,
4147}
4148unsafe impl Send for LCDIF {}
4149impl LCDIF {
4150 #[doc = r"Pointer to the register block"]
4151 pub const PTR: *const lcdif::RegisterBlock = 0x4021_0000 as *const _;
4152 #[doc = r"Return the pointer to the register block"]
4153 #[inline(always)]
4154 pub const fn ptr() -> *const lcdif::RegisterBlock {
4155 Self::PTR
4156 }
4157}
4158impl Deref for LCDIF {
4159 type Target = lcdif::RegisterBlock;
4160 #[inline(always)]
4161 fn deref(&self) -> &Self::Target {
4162 unsafe { &*Self::PTR }
4163 }
4164}
4165impl core::fmt::Debug for LCDIF {
4166 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4167 f.debug_struct("LCDIF").finish()
4168 }
4169}
4170#[doc = "LCDIF"]
4171pub mod lcdif;
4172#[doc = "AXI SWITCH AMIB"]
4173pub struct AXI_SWITCH_AMIB {
4174 _marker: PhantomData<*const ()>,
4175}
4176unsafe impl Send for AXI_SWITCH_AMIB {}
4177impl AXI_SWITCH_AMIB {
4178 #[doc = r"Pointer to the register block"]
4179 pub const PTR: *const axi_switch_amib::RegisterBlock = 0x4028_2000 as *const _;
4180 #[doc = r"Return the pointer to the register block"]
4181 #[inline(always)]
4182 pub const fn ptr() -> *const axi_switch_amib::RegisterBlock {
4183 Self::PTR
4184 }
4185}
4186impl Deref for AXI_SWITCH_AMIB {
4187 type Target = axi_switch_amib::RegisterBlock;
4188 #[inline(always)]
4189 fn deref(&self) -> &Self::Target {
4190 unsafe { &*Self::PTR }
4191 }
4192}
4193impl core::fmt::Debug for AXI_SWITCH_AMIB {
4194 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4195 f.debug_struct("AXI_SWITCH_AMIB").finish()
4196 }
4197}
4198#[doc = "AXI SWITCH AMIB"]
4199pub mod axi_switch_amib;
4200#[doc = "AXI SWITCH ASIB"]
4201pub struct AXI_SWITCH_ASIB {
4202 _marker: PhantomData<*const ()>,
4203}
4204unsafe impl Send for AXI_SWITCH_ASIB {}
4205impl AXI_SWITCH_ASIB {
4206 #[doc = r"Pointer to the register block"]
4207 pub const PTR: *const axi_switch_asib::RegisterBlock = 0x402c_2000 as *const _;
4208 #[doc = r"Return the pointer to the register block"]
4209 #[inline(always)]
4210 pub const fn ptr() -> *const axi_switch_asib::RegisterBlock {
4211 Self::PTR
4212 }
4213}
4214impl Deref for AXI_SWITCH_ASIB {
4215 type Target = axi_switch_asib::RegisterBlock;
4216 #[inline(always)]
4217 fn deref(&self) -> &Self::Target {
4218 unsafe { &*Self::PTR }
4219 }
4220}
4221impl core::fmt::Debug for AXI_SWITCH_ASIB {
4222 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4223 f.debug_struct("AXI_SWITCH_ASIB").finish()
4224 }
4225}
4226#[doc = "AXI SWITCH ASIB"]
4227pub mod axi_switch_asib;
4228#[doc = "no description available"]
4229pub struct SCN_SCB {
4230 _marker: PhantomData<*const ()>,
4231}
4232unsafe impl Send for SCN_SCB {}
4233impl SCN_SCB {
4234 #[doc = r"Pointer to the register block"]
4235 pub const PTR: *const scn_scb::RegisterBlock = 0xe000_e000 as *const _;
4236 #[doc = r"Return the pointer to the register block"]
4237 #[inline(always)]
4238 pub const fn ptr() -> *const scn_scb::RegisterBlock {
4239 Self::PTR
4240 }
4241}
4242impl Deref for SCN_SCB {
4243 type Target = scn_scb::RegisterBlock;
4244 #[inline(always)]
4245 fn deref(&self) -> &Self::Target {
4246 unsafe { &*Self::PTR }
4247 }
4248}
4249impl core::fmt::Debug for SCN_SCB {
4250 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4251 f.debug_struct("SCN_SCB").finish()
4252 }
4253}
4254#[doc = "no description available"]
4255pub mod scn_scb;
4256#[doc = "no description available"]
4257pub struct SAU {
4258 _marker: PhantomData<*const ()>,
4259}
4260unsafe impl Send for SAU {}
4261impl SAU {
4262 #[doc = r"Pointer to the register block"]
4263 pub const PTR: *const sau::RegisterBlock = 0xe000_edd0 as *const _;
4264 #[doc = r"Return the pointer to the register block"]
4265 #[inline(always)]
4266 pub const fn ptr() -> *const sau::RegisterBlock {
4267 Self::PTR
4268 }
4269}
4270impl Deref for SAU {
4271 type Target = sau::RegisterBlock;
4272 #[inline(always)]
4273 fn deref(&self) -> &Self::Target {
4274 unsafe { &*Self::PTR }
4275 }
4276}
4277impl core::fmt::Debug for SAU {
4278 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4279 f.debug_struct("SAU").finish()
4280 }
4281}
4282#[doc = "no description available"]
4283pub mod sau;
4284#[no_mangle]
4285static mut DEVICE_PERIPHERALS: bool = false;
4286#[doc = r" All the peripherals."]
4287#[allow(non_snake_case)]
4288pub struct Peripherals {
4289 #[doc = "RSTCTL0"]
4290 pub RSTCTL0: RSTCTL0,
4291 #[doc = "CLKCTL0"]
4292 pub CLKCTL0: CLKCTL0,
4293 #[doc = "SYSCTL0"]
4294 pub SYSCTL0: SYSCTL0,
4295 #[doc = "IOPCTL"]
4296 pub IOPCTL: IOPCTL,
4297 #[doc = "PUF"]
4298 pub PUF: PUF,
4299 #[doc = "WWDT0"]
4300 pub WWDT0: WWDT0,
4301 #[doc = "WWDT1"]
4302 pub WWDT1: WWDT1,
4303 #[doc = "UTICK0"]
4304 pub UTICK0: UTICK0,
4305 #[doc = "RSTCTL1"]
4306 pub RSTCTL1: RSTCTL1,
4307 #[doc = "CLKCTL1"]
4308 pub CLKCTL1: CLKCTL1,
4309 #[doc = "SYSCTL1"]
4310 pub SYSCTL1: SYSCTL1,
4311 #[doc = "PINT"]
4312 pub PINT: PINT,
4313 #[doc = "INPUTMUX"]
4314 pub INPUTMUX: INPUTMUX,
4315 #[doc = "CTIMER0"]
4316 pub CTIMER0: CTIMER0,
4317 #[doc = "CTIMER1"]
4318 pub CTIMER1: CTIMER1,
4319 #[doc = "CTIMER2"]
4320 pub CTIMER2: CTIMER2,
4321 #[doc = "CTIMER3"]
4322 pub CTIMER3: CTIMER3,
4323 #[doc = "CTIMER4"]
4324 pub CTIMER4: CTIMER4,
4325 #[doc = "MRT0"]
4326 pub MRT0: MRT0,
4327 #[doc = "FREQME"]
4328 pub FREQME: FREQME,
4329 #[doc = "RTC"]
4330 pub RTC: RTC,
4331 #[doc = "MIPI_DSI_HOST"]
4332 pub MIPI_DSI_HOST: MIPI_DSI_HOST,
4333 #[doc = "FLEXIO0"]
4334 pub FLEXIO0: FLEXIO0,
4335 #[doc = "CACHE64_CTRL0"]
4336 pub CACHE64_CTRL0: CACHE64_CTRL0,
4337 #[doc = "CACHE64_CTRL1"]
4338 pub CACHE64_CTRL1: CACHE64_CTRL1,
4339 #[doc = "CACHE64_POLSEL0"]
4340 pub CACHE64_POLSEL0: CACHE64_POLSEL0,
4341 #[doc = "CACHE64_POLSEL1"]
4342 pub CACHE64_POLSEL1: CACHE64_POLSEL1,
4343 #[doc = "I3C0"]
4344 pub I3C0: I3C0,
4345 #[doc = "I3C1"]
4346 pub I3C1: I3C1,
4347 #[doc = "GPIO"]
4348 pub GPIO: GPIO,
4349 #[doc = "DMA0"]
4350 pub DMA0: DMA0,
4351 #[doc = "DMA1"]
4352 pub DMA1: DMA1,
4353 #[doc = "FLEXCOMM0"]
4354 pub FLEXCOMM0: FLEXCOMM0,
4355 #[doc = "FLEXCOMM1"]
4356 pub FLEXCOMM1: FLEXCOMM1,
4357 #[doc = "FLEXCOMM2"]
4358 pub FLEXCOMM2: FLEXCOMM2,
4359 #[doc = "FLEXCOMM3"]
4360 pub FLEXCOMM3: FLEXCOMM3,
4361 #[doc = "FLEXCOMM4"]
4362 pub FLEXCOMM4: FLEXCOMM4,
4363 #[doc = "FLEXCOMM5"]
4364 pub FLEXCOMM5: FLEXCOMM5,
4365 #[doc = "FLEXCOMM6"]
4366 pub FLEXCOMM6: FLEXCOMM6,
4367 #[doc = "FLEXCOMM7"]
4368 pub FLEXCOMM7: FLEXCOMM7,
4369 #[doc = "FLEXCOMM14"]
4370 pub FLEXCOMM14: FLEXCOMM14,
4371 #[doc = "FLEXCOMM15"]
4372 pub FLEXCOMM15: FLEXCOMM15,
4373 #[doc = "FLEXCOMM16"]
4374 pub FLEXCOMM16: FLEXCOMM16,
4375 #[doc = "FLEXCOMM8"]
4376 pub FLEXCOMM8: FLEXCOMM8,
4377 #[doc = "FLEXCOMM9"]
4378 pub FLEXCOMM9: FLEXCOMM9,
4379 #[doc = "FLEXCOMM10"]
4380 pub FLEXCOMM10: FLEXCOMM10,
4381 #[doc = "FLEXCOMM11"]
4382 pub FLEXCOMM11: FLEXCOMM11,
4383 #[doc = "FLEXCOMM12"]
4384 pub FLEXCOMM12: FLEXCOMM12,
4385 #[doc = "FLEXCOMM13"]
4386 pub FLEXCOMM13: FLEXCOMM13,
4387 #[doc = "I2C0"]
4388 pub I2C0: I2C0,
4389 #[doc = "I2C1"]
4390 pub I2C1: I2C1,
4391 #[doc = "I2C2"]
4392 pub I2C2: I2C2,
4393 #[doc = "I2C3"]
4394 pub I2C3: I2C3,
4395 #[doc = "I2C4"]
4396 pub I2C4: I2C4,
4397 #[doc = "I2C5"]
4398 pub I2C5: I2C5,
4399 #[doc = "I2C6"]
4400 pub I2C6: I2C6,
4401 #[doc = "I2C7"]
4402 pub I2C7: I2C7,
4403 #[doc = "I2C15"]
4404 pub I2C15: I2C15,
4405 #[doc = "I2C8"]
4406 pub I2C8: I2C8,
4407 #[doc = "I2C9"]
4408 pub I2C9: I2C9,
4409 #[doc = "I2C10"]
4410 pub I2C10: I2C10,
4411 #[doc = "I2C11"]
4412 pub I2C11: I2C11,
4413 #[doc = "I2C12"]
4414 pub I2C12: I2C12,
4415 #[doc = "I2C13"]
4416 pub I2C13: I2C13,
4417 #[doc = "I2S0"]
4418 pub I2S0: I2S0,
4419 #[doc = "I2S1"]
4420 pub I2S1: I2S1,
4421 #[doc = "I2S2"]
4422 pub I2S2: I2S2,
4423 #[doc = "I2S3"]
4424 pub I2S3: I2S3,
4425 #[doc = "I2S4"]
4426 pub I2S4: I2S4,
4427 #[doc = "I2S5"]
4428 pub I2S5: I2S5,
4429 #[doc = "I2S6"]
4430 pub I2S6: I2S6,
4431 #[doc = "I2S7"]
4432 pub I2S7: I2S7,
4433 #[doc = "I2S8"]
4434 pub I2S8: I2S8,
4435 #[doc = "I2S9"]
4436 pub I2S9: I2S9,
4437 #[doc = "I2S10"]
4438 pub I2S10: I2S10,
4439 #[doc = "I2S11"]
4440 pub I2S11: I2S11,
4441 #[doc = "I2S12"]
4442 pub I2S12: I2S12,
4443 #[doc = "I2S13"]
4444 pub I2S13: I2S13,
4445 #[doc = "SPI0"]
4446 pub SPI0: SPI0,
4447 #[doc = "SPI1"]
4448 pub SPI1: SPI1,
4449 #[doc = "SPI2"]
4450 pub SPI2: SPI2,
4451 #[doc = "SPI3"]
4452 pub SPI3: SPI3,
4453 #[doc = "SPI4"]
4454 pub SPI4: SPI4,
4455 #[doc = "SPI5"]
4456 pub SPI5: SPI5,
4457 #[doc = "SPI6"]
4458 pub SPI6: SPI6,
4459 #[doc = "SPI7"]
4460 pub SPI7: SPI7,
4461 #[doc = "SPI14"]
4462 pub SPI14: SPI14,
4463 #[doc = "SPI16"]
4464 pub SPI16: SPI16,
4465 #[doc = "SPI8"]
4466 pub SPI8: SPI8,
4467 #[doc = "SPI9"]
4468 pub SPI9: SPI9,
4469 #[doc = "SPI10"]
4470 pub SPI10: SPI10,
4471 #[doc = "SPI11"]
4472 pub SPI11: SPI11,
4473 #[doc = "SPI12"]
4474 pub SPI12: SPI12,
4475 #[doc = "SPI13"]
4476 pub SPI13: SPI13,
4477 #[doc = "USART0"]
4478 pub USART0: USART0,
4479 #[doc = "USART1"]
4480 pub USART1: USART1,
4481 #[doc = "USART2"]
4482 pub USART2: USART2,
4483 #[doc = "USART3"]
4484 pub USART3: USART3,
4485 #[doc = "USART4"]
4486 pub USART4: USART4,
4487 #[doc = "USART5"]
4488 pub USART5: USART5,
4489 #[doc = "USART6"]
4490 pub USART6: USART6,
4491 #[doc = "USART7"]
4492 pub USART7: USART7,
4493 #[doc = "USART8"]
4494 pub USART8: USART8,
4495 #[doc = "USART9"]
4496 pub USART9: USART9,
4497 #[doc = "USART10"]
4498 pub USART10: USART10,
4499 #[doc = "USART11"]
4500 pub USART11: USART11,
4501 #[doc = "USART12"]
4502 pub USART12: USART12,
4503 #[doc = "USART13"]
4504 pub USART13: USART13,
4505 #[doc = "DEBUGGER_MAILBOX"]
4506 pub DEBUGGER_MAILBOX: DEBUGGER_MAILBOX,
4507 #[doc = "MUA"]
4508 pub MUA: MUA,
4509 #[doc = "SEMA42"]
4510 pub SEMA42: SEMA42,
4511 #[doc = "OSTIMER0"]
4512 pub OSTIMER0: OSTIMER0,
4513 #[doc = "CRC_ENGINE"]
4514 pub CRC_ENGINE: CRC_ENGINE,
4515 #[doc = "DMIC0"]
4516 pub DMIC0: DMIC0,
4517 #[doc = "OCOTP0"]
4518 pub OCOTP0: OCOTP0,
4519 #[doc = "FLEXSPI0"]
4520 pub FLEXSPI0: FLEXSPI0,
4521 #[doc = "OTFAD0"]
4522 pub OTFAD0: OTFAD0,
4523 #[doc = "PMC"]
4524 pub PMC: PMC,
4525 #[doc = "USDHC0"]
4526 pub USDHC0: USDHC0,
4527 #[doc = "USDHC1"]
4528 pub USDHC1: USDHC1,
4529 #[doc = "TRNG"]
4530 pub TRNG: TRNG,
4531 #[doc = "ACMP0"]
4532 pub ACMP0: ACMP0,
4533 #[doc = "ADC0"]
4534 pub ADC0: ADC0,
4535 #[doc = "USBPHY"]
4536 pub USBPHY: USBPHY,
4537 #[doc = "USBHSDCD"]
4538 pub USBHSDCD: USBHSDCD,
4539 #[doc = "FLEXSPI1"]
4540 pub FLEXSPI1: FLEXSPI1,
4541 #[doc = "USBHSD"]
4542 pub USBHSD: USBHSD,
4543 #[doc = "USBHSH"]
4544 pub USBHSH: USBHSH,
4545 #[doc = "SCT0"]
4546 pub SCT0: SCT0,
4547 #[doc = "AHB_SECURE_CTRL"]
4548 pub AHB_SECURE_CTRL: AHB_SECURE_CTRL,
4549 #[doc = "POWERQUAD"]
4550 pub POWERQUAD: POWERQUAD,
4551 #[doc = "CASPER"]
4552 pub CASPER: CASPER,
4553 #[doc = "SECGPIO"]
4554 pub SECGPIO: SECGPIO,
4555 #[doc = "HASHCRYPT"]
4556 pub HASHCRYPT: HASHCRYPT,
4557 #[doc = "LCDIF"]
4558 pub LCDIF: LCDIF,
4559 #[doc = "AXI_SWITCH_AMIB"]
4560 pub AXI_SWITCH_AMIB: AXI_SWITCH_AMIB,
4561 #[doc = "AXI_SWITCH_ASIB"]
4562 pub AXI_SWITCH_ASIB: AXI_SWITCH_ASIB,
4563 #[doc = "SCN_SCB"]
4564 pub SCN_SCB: SCN_SCB,
4565 #[doc = "SAU"]
4566 pub SAU: SAU,
4567}
4568impl Peripherals {
4569 #[doc = r" Returns all the peripherals *once*."]
4570 #[cfg(feature = "critical-section")]
4571 #[inline]
4572 pub fn take() -> Option<Self> {
4573 critical_section::with(|_| {
4574 if unsafe { DEVICE_PERIPHERALS } {
4575 return None;
4576 }
4577 Some(unsafe { Peripherals::steal() })
4578 })
4579 }
4580 #[doc = r" Unchecked version of `Peripherals::take`."]
4581 #[doc = r""]
4582 #[doc = r" # Safety"]
4583 #[doc = r""]
4584 #[doc = r" Each of the returned peripherals must be used at most once."]
4585 #[inline]
4586 pub unsafe fn steal() -> Self {
4587 DEVICE_PERIPHERALS = true;
4588 Peripherals {
4589 RSTCTL0: RSTCTL0 {
4590 _marker: PhantomData,
4591 },
4592 CLKCTL0: CLKCTL0 {
4593 _marker: PhantomData,
4594 },
4595 SYSCTL0: SYSCTL0 {
4596 _marker: PhantomData,
4597 },
4598 IOPCTL: IOPCTL {
4599 _marker: PhantomData,
4600 },
4601 PUF: PUF {
4602 _marker: PhantomData,
4603 },
4604 WWDT0: WWDT0 {
4605 _marker: PhantomData,
4606 },
4607 WWDT1: WWDT1 {
4608 _marker: PhantomData,
4609 },
4610 UTICK0: UTICK0 {
4611 _marker: PhantomData,
4612 },
4613 RSTCTL1: RSTCTL1 {
4614 _marker: PhantomData,
4615 },
4616 CLKCTL1: CLKCTL1 {
4617 _marker: PhantomData,
4618 },
4619 SYSCTL1: SYSCTL1 {
4620 _marker: PhantomData,
4621 },
4622 PINT: PINT {
4623 _marker: PhantomData,
4624 },
4625 INPUTMUX: INPUTMUX {
4626 _marker: PhantomData,
4627 },
4628 CTIMER0: CTIMER0 {
4629 _marker: PhantomData,
4630 },
4631 CTIMER1: CTIMER1 {
4632 _marker: PhantomData,
4633 },
4634 CTIMER2: CTIMER2 {
4635 _marker: PhantomData,
4636 },
4637 CTIMER3: CTIMER3 {
4638 _marker: PhantomData,
4639 },
4640 CTIMER4: CTIMER4 {
4641 _marker: PhantomData,
4642 },
4643 MRT0: MRT0 {
4644 _marker: PhantomData,
4645 },
4646 FREQME: FREQME {
4647 _marker: PhantomData,
4648 },
4649 RTC: RTC {
4650 _marker: PhantomData,
4651 },
4652 MIPI_DSI_HOST: MIPI_DSI_HOST {
4653 _marker: PhantomData,
4654 },
4655 FLEXIO0: FLEXIO0 {
4656 _marker: PhantomData,
4657 },
4658 CACHE64_CTRL0: CACHE64_CTRL0 {
4659 _marker: PhantomData,
4660 },
4661 CACHE64_CTRL1: CACHE64_CTRL1 {
4662 _marker: PhantomData,
4663 },
4664 CACHE64_POLSEL0: CACHE64_POLSEL0 {
4665 _marker: PhantomData,
4666 },
4667 CACHE64_POLSEL1: CACHE64_POLSEL1 {
4668 _marker: PhantomData,
4669 },
4670 I3C0: I3C0 {
4671 _marker: PhantomData,
4672 },
4673 I3C1: I3C1 {
4674 _marker: PhantomData,
4675 },
4676 GPIO: GPIO {
4677 _marker: PhantomData,
4678 },
4679 DMA0: DMA0 {
4680 _marker: PhantomData,
4681 },
4682 DMA1: DMA1 {
4683 _marker: PhantomData,
4684 },
4685 FLEXCOMM0: FLEXCOMM0 {
4686 _marker: PhantomData,
4687 },
4688 FLEXCOMM1: FLEXCOMM1 {
4689 _marker: PhantomData,
4690 },
4691 FLEXCOMM2: FLEXCOMM2 {
4692 _marker: PhantomData,
4693 },
4694 FLEXCOMM3: FLEXCOMM3 {
4695 _marker: PhantomData,
4696 },
4697 FLEXCOMM4: FLEXCOMM4 {
4698 _marker: PhantomData,
4699 },
4700 FLEXCOMM5: FLEXCOMM5 {
4701 _marker: PhantomData,
4702 },
4703 FLEXCOMM6: FLEXCOMM6 {
4704 _marker: PhantomData,
4705 },
4706 FLEXCOMM7: FLEXCOMM7 {
4707 _marker: PhantomData,
4708 },
4709 FLEXCOMM14: FLEXCOMM14 {
4710 _marker: PhantomData,
4711 },
4712 FLEXCOMM15: FLEXCOMM15 {
4713 _marker: PhantomData,
4714 },
4715 FLEXCOMM16: FLEXCOMM16 {
4716 _marker: PhantomData,
4717 },
4718 FLEXCOMM8: FLEXCOMM8 {
4719 _marker: PhantomData,
4720 },
4721 FLEXCOMM9: FLEXCOMM9 {
4722 _marker: PhantomData,
4723 },
4724 FLEXCOMM10: FLEXCOMM10 {
4725 _marker: PhantomData,
4726 },
4727 FLEXCOMM11: FLEXCOMM11 {
4728 _marker: PhantomData,
4729 },
4730 FLEXCOMM12: FLEXCOMM12 {
4731 _marker: PhantomData,
4732 },
4733 FLEXCOMM13: FLEXCOMM13 {
4734 _marker: PhantomData,
4735 },
4736 I2C0: I2C0 {
4737 _marker: PhantomData,
4738 },
4739 I2C1: I2C1 {
4740 _marker: PhantomData,
4741 },
4742 I2C2: I2C2 {
4743 _marker: PhantomData,
4744 },
4745 I2C3: I2C3 {
4746 _marker: PhantomData,
4747 },
4748 I2C4: I2C4 {
4749 _marker: PhantomData,
4750 },
4751 I2C5: I2C5 {
4752 _marker: PhantomData,
4753 },
4754 I2C6: I2C6 {
4755 _marker: PhantomData,
4756 },
4757 I2C7: I2C7 {
4758 _marker: PhantomData,
4759 },
4760 I2C15: I2C15 {
4761 _marker: PhantomData,
4762 },
4763 I2C8: I2C8 {
4764 _marker: PhantomData,
4765 },
4766 I2C9: I2C9 {
4767 _marker: PhantomData,
4768 },
4769 I2C10: I2C10 {
4770 _marker: PhantomData,
4771 },
4772 I2C11: I2C11 {
4773 _marker: PhantomData,
4774 },
4775 I2C12: I2C12 {
4776 _marker: PhantomData,
4777 },
4778 I2C13: I2C13 {
4779 _marker: PhantomData,
4780 },
4781 I2S0: I2S0 {
4782 _marker: PhantomData,
4783 },
4784 I2S1: I2S1 {
4785 _marker: PhantomData,
4786 },
4787 I2S2: I2S2 {
4788 _marker: PhantomData,
4789 },
4790 I2S3: I2S3 {
4791 _marker: PhantomData,
4792 },
4793 I2S4: I2S4 {
4794 _marker: PhantomData,
4795 },
4796 I2S5: I2S5 {
4797 _marker: PhantomData,
4798 },
4799 I2S6: I2S6 {
4800 _marker: PhantomData,
4801 },
4802 I2S7: I2S7 {
4803 _marker: PhantomData,
4804 },
4805 I2S8: I2S8 {
4806 _marker: PhantomData,
4807 },
4808 I2S9: I2S9 {
4809 _marker: PhantomData,
4810 },
4811 I2S10: I2S10 {
4812 _marker: PhantomData,
4813 },
4814 I2S11: I2S11 {
4815 _marker: PhantomData,
4816 },
4817 I2S12: I2S12 {
4818 _marker: PhantomData,
4819 },
4820 I2S13: I2S13 {
4821 _marker: PhantomData,
4822 },
4823 SPI0: SPI0 {
4824 _marker: PhantomData,
4825 },
4826 SPI1: SPI1 {
4827 _marker: PhantomData,
4828 },
4829 SPI2: SPI2 {
4830 _marker: PhantomData,
4831 },
4832 SPI3: SPI3 {
4833 _marker: PhantomData,
4834 },
4835 SPI4: SPI4 {
4836 _marker: PhantomData,
4837 },
4838 SPI5: SPI5 {
4839 _marker: PhantomData,
4840 },
4841 SPI6: SPI6 {
4842 _marker: PhantomData,
4843 },
4844 SPI7: SPI7 {
4845 _marker: PhantomData,
4846 },
4847 SPI14: SPI14 {
4848 _marker: PhantomData,
4849 },
4850 SPI16: SPI16 {
4851 _marker: PhantomData,
4852 },
4853 SPI8: SPI8 {
4854 _marker: PhantomData,
4855 },
4856 SPI9: SPI9 {
4857 _marker: PhantomData,
4858 },
4859 SPI10: SPI10 {
4860 _marker: PhantomData,
4861 },
4862 SPI11: SPI11 {
4863 _marker: PhantomData,
4864 },
4865 SPI12: SPI12 {
4866 _marker: PhantomData,
4867 },
4868 SPI13: SPI13 {
4869 _marker: PhantomData,
4870 },
4871 USART0: USART0 {
4872 _marker: PhantomData,
4873 },
4874 USART1: USART1 {
4875 _marker: PhantomData,
4876 },
4877 USART2: USART2 {
4878 _marker: PhantomData,
4879 },
4880 USART3: USART3 {
4881 _marker: PhantomData,
4882 },
4883 USART4: USART4 {
4884 _marker: PhantomData,
4885 },
4886 USART5: USART5 {
4887 _marker: PhantomData,
4888 },
4889 USART6: USART6 {
4890 _marker: PhantomData,
4891 },
4892 USART7: USART7 {
4893 _marker: PhantomData,
4894 },
4895 USART8: USART8 {
4896 _marker: PhantomData,
4897 },
4898 USART9: USART9 {
4899 _marker: PhantomData,
4900 },
4901 USART10: USART10 {
4902 _marker: PhantomData,
4903 },
4904 USART11: USART11 {
4905 _marker: PhantomData,
4906 },
4907 USART12: USART12 {
4908 _marker: PhantomData,
4909 },
4910 USART13: USART13 {
4911 _marker: PhantomData,
4912 },
4913 DEBUGGER_MAILBOX: DEBUGGER_MAILBOX {
4914 _marker: PhantomData,
4915 },
4916 MUA: MUA {
4917 _marker: PhantomData,
4918 },
4919 SEMA42: SEMA42 {
4920 _marker: PhantomData,
4921 },
4922 OSTIMER0: OSTIMER0 {
4923 _marker: PhantomData,
4924 },
4925 CRC_ENGINE: CRC_ENGINE {
4926 _marker: PhantomData,
4927 },
4928 DMIC0: DMIC0 {
4929 _marker: PhantomData,
4930 },
4931 OCOTP0: OCOTP0 {
4932 _marker: PhantomData,
4933 },
4934 FLEXSPI0: FLEXSPI0 {
4935 _marker: PhantomData,
4936 },
4937 OTFAD0: OTFAD0 {
4938 _marker: PhantomData,
4939 },
4940 PMC: PMC {
4941 _marker: PhantomData,
4942 },
4943 USDHC0: USDHC0 {
4944 _marker: PhantomData,
4945 },
4946 USDHC1: USDHC1 {
4947 _marker: PhantomData,
4948 },
4949 TRNG: TRNG {
4950 _marker: PhantomData,
4951 },
4952 ACMP0: ACMP0 {
4953 _marker: PhantomData,
4954 },
4955 ADC0: ADC0 {
4956 _marker: PhantomData,
4957 },
4958 USBPHY: USBPHY {
4959 _marker: PhantomData,
4960 },
4961 USBHSDCD: USBHSDCD {
4962 _marker: PhantomData,
4963 },
4964 FLEXSPI1: FLEXSPI1 {
4965 _marker: PhantomData,
4966 },
4967 USBHSD: USBHSD {
4968 _marker: PhantomData,
4969 },
4970 USBHSH: USBHSH {
4971 _marker: PhantomData,
4972 },
4973 SCT0: SCT0 {
4974 _marker: PhantomData,
4975 },
4976 AHB_SECURE_CTRL: AHB_SECURE_CTRL {
4977 _marker: PhantomData,
4978 },
4979 POWERQUAD: POWERQUAD {
4980 _marker: PhantomData,
4981 },
4982 CASPER: CASPER {
4983 _marker: PhantomData,
4984 },
4985 SECGPIO: SECGPIO {
4986 _marker: PhantomData,
4987 },
4988 HASHCRYPT: HASHCRYPT {
4989 _marker: PhantomData,
4990 },
4991 LCDIF: LCDIF {
4992 _marker: PhantomData,
4993 },
4994 AXI_SWITCH_AMIB: AXI_SWITCH_AMIB {
4995 _marker: PhantomData,
4996 },
4997 AXI_SWITCH_ASIB: AXI_SWITCH_ASIB {
4998 _marker: PhantomData,
4999 },
5000 SCN_SCB: SCN_SCB {
5001 _marker: PhantomData,
5002 },
5003 SAU: SAU {
5004 _marker: PhantomData,
5005 },
5006 }
5007 }
5008}