1#![doc = "Peripheral access API for LPC55S69_CM33_CORE0 microcontrollers (generated using svd2rust v0.20.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.20.0/svd2rust/#peripheral-api\n[next]: https://github.com/rust-embedded/svd2rust/blob/master/CHANGELOG.md#unreleased\n[repository]: https://github.com/rust-embedded/svd2rust"]
3#![deny(const_err)]
4#![deny(dead_code)]
5#![deny(improper_ctypes)]
6#![deny(missing_docs)]
7#![deny(no_mangle_generic_items)]
8#![deny(non_shorthand_field_patterns)]
9#![deny(overflowing_literals)]
10#![deny(path_statements)]
11#![deny(patterns_in_fns_without_body)]
12#![deny(private_in_public)]
13#![deny(unconditional_recursion)]
14#![deny(unused_allocation)]
15#![deny(unused_comparisons)]
16#![deny(unused_parens)]
17#![deny(while_true)]
18#![allow(non_camel_case_types)]
19#![allow(non_snake_case)]
20#![no_std]
21use core::marker::PhantomData;
22use core::ops::Deref;
23#[doc = r"Number available in the NVIC for configuring priority"]
24pub const NVIC_PRIO_BITS: u8 = 3;
25#[cfg(feature = "rt")]
26pub use self::Interrupt as interrupt;
27pub use cortex_m::peripheral::Peripherals as CorePeripherals;
28pub use cortex_m::peripheral::{CBP, CPUID, DCB, DWT, FPB, FPU, ITM, MPU, NVIC, SCB, SYST, TPIU};
29#[cfg(feature = "rt")]
30pub use cortex_m_rt::interrupt;
31#[allow(unused_imports)]
32use generic::*;
33#[doc = r"Common register and bit access and modify traits"]
34pub mod generic;
35#[cfg(feature = "rt")]
36extern "C" {
37 fn WDT_BOD();
38 fn DMA0();
39 fn GINT0();
40 fn GINT1();
41 fn PIN_INT0();
42 fn PIN_INT1();
43 fn PIN_INT2();
44 fn PIN_INT3();
45 fn UTICK0();
46 fn MRT0();
47 fn CTIMER0();
48 fn CTIMER1();
49 fn SCT0();
50 fn CTIMER3();
51 fn FLEXCOMM0();
52 fn FLEXCOMM1();
53 fn FLEXCOMM2();
54 fn FLEXCOMM3();
55 fn FLEXCOMM4();
56 fn FLEXCOMM5();
57 fn FLEXCOMM6();
58 fn FLEXCOMM7();
59 fn ADC0();
60 fn ACMP();
61 fn USB0_NEEDCLK();
62 fn USB0();
63 fn RTC();
64 fn MAILBOX();
65 fn PIN_INT4();
66 fn PIN_INT5();
67 fn PIN_INT6();
68 fn PIN_INT7();
69 fn CTIMER2();
70 fn CTIMER4();
71 fn OS_EVENT();
72 fn SDIO();
73 fn USB1_PHY();
74 fn USB1();
75 fn USB1_NEEDCLK();
76 fn SEC_HYPERVISOR_CALL();
77 fn SEC_GPIO_INT0_IRQ0();
78 fn SEC_GPIO_INT0_IRQ1();
79 fn PLU();
80 fn SEC_VIO();
81 fn HASHCRYPT();
82 fn CASER();
83 fn PUF();
84 fn PQ();
85 fn DMA1();
86 fn FLEXCOMM8();
87}
88#[doc(hidden)]
89pub union Vector {
90 _handler: unsafe extern "C" fn(),
91 _reserved: u32,
92}
93#[cfg(feature = "rt")]
94#[doc(hidden)]
95#[link_section = ".vector_table.interrupts"]
96#[no_mangle]
97pub static __INTERRUPTS: [Vector; 60] = [
98 Vector { _handler: WDT_BOD },
99 Vector { _handler: DMA0 },
100 Vector { _handler: GINT0 },
101 Vector { _handler: GINT1 },
102 Vector { _handler: PIN_INT0 },
103 Vector { _handler: PIN_INT1 },
104 Vector { _handler: PIN_INT2 },
105 Vector { _handler: PIN_INT3 },
106 Vector { _handler: UTICK0 },
107 Vector { _handler: MRT0 },
108 Vector { _handler: CTIMER0 },
109 Vector { _handler: CTIMER1 },
110 Vector { _handler: SCT0 },
111 Vector { _handler: CTIMER3 },
112 Vector {
113 _handler: FLEXCOMM0,
114 },
115 Vector {
116 _handler: FLEXCOMM1,
117 },
118 Vector {
119 _handler: FLEXCOMM2,
120 },
121 Vector {
122 _handler: FLEXCOMM3,
123 },
124 Vector {
125 _handler: FLEXCOMM4,
126 },
127 Vector {
128 _handler: FLEXCOMM5,
129 },
130 Vector {
131 _handler: FLEXCOMM6,
132 },
133 Vector {
134 _handler: FLEXCOMM7,
135 },
136 Vector { _handler: ADC0 },
137 Vector { _reserved: 0 },
138 Vector { _handler: ACMP },
139 Vector { _reserved: 0 },
140 Vector { _reserved: 0 },
141 Vector {
142 _handler: USB0_NEEDCLK,
143 },
144 Vector { _handler: USB0 },
145 Vector { _handler: RTC },
146 Vector { _reserved: 0 },
147 Vector { _handler: MAILBOX },
148 Vector { _handler: PIN_INT4 },
149 Vector { _handler: PIN_INT5 },
150 Vector { _handler: PIN_INT6 },
151 Vector { _handler: PIN_INT7 },
152 Vector { _handler: CTIMER2 },
153 Vector { _handler: CTIMER4 },
154 Vector { _handler: OS_EVENT },
155 Vector { _reserved: 0 },
156 Vector { _reserved: 0 },
157 Vector { _reserved: 0 },
158 Vector { _handler: SDIO },
159 Vector { _reserved: 0 },
160 Vector { _reserved: 0 },
161 Vector { _reserved: 0 },
162 Vector { _handler: USB1_PHY },
163 Vector { _handler: USB1 },
164 Vector {
165 _handler: USB1_NEEDCLK,
166 },
167 Vector {
168 _handler: SEC_HYPERVISOR_CALL,
169 },
170 Vector {
171 _handler: SEC_GPIO_INT0_IRQ0,
172 },
173 Vector {
174 _handler: SEC_GPIO_INT0_IRQ1,
175 },
176 Vector { _handler: PLU },
177 Vector { _handler: SEC_VIO },
178 Vector {
179 _handler: HASHCRYPT,
180 },
181 Vector { _handler: CASER },
182 Vector { _handler: PUF },
183 Vector { _handler: PQ },
184 Vector { _handler: DMA1 },
185 Vector {
186 _handler: FLEXCOMM8,
187 },
188];
189#[doc = r"Enumeration of all the interrupts."]
190#[derive(Copy, Clone, Debug, PartialEq, Eq)]
191#[repr(u16)]
192pub enum Interrupt {
193 #[doc = "0 - WDT_BOD"]
194 WDT_BOD = 0,
195 #[doc = "1 - DMA0"]
196 DMA0 = 1,
197 #[doc = "2 - GINT0"]
198 GINT0 = 2,
199 #[doc = "3 - GINT1"]
200 GINT1 = 3,
201 #[doc = "4 - PIN_INT0"]
202 PIN_INT0 = 4,
203 #[doc = "5 - PIN_INT1"]
204 PIN_INT1 = 5,
205 #[doc = "6 - PIN_INT2"]
206 PIN_INT2 = 6,
207 #[doc = "7 - PIN_INT3"]
208 PIN_INT3 = 7,
209 #[doc = "8 - UTICK0"]
210 UTICK0 = 8,
211 #[doc = "9 - MRT0"]
212 MRT0 = 9,
213 #[doc = "10 - CTIMER0"]
214 CTIMER0 = 10,
215 #[doc = "11 - CTIMER1"]
216 CTIMER1 = 11,
217 #[doc = "12 - SCT0"]
218 SCT0 = 12,
219 #[doc = "13 - CTIMER3"]
220 CTIMER3 = 13,
221 #[doc = "14 - FLEXCOMM0"]
222 FLEXCOMM0 = 14,
223 #[doc = "15 - FLEXCOMM1"]
224 FLEXCOMM1 = 15,
225 #[doc = "16 - FLEXCOMM2"]
226 FLEXCOMM2 = 16,
227 #[doc = "17 - FLEXCOMM3"]
228 FLEXCOMM3 = 17,
229 #[doc = "18 - FLEXCOMM4"]
230 FLEXCOMM4 = 18,
231 #[doc = "19 - FLEXCOMM5"]
232 FLEXCOMM5 = 19,
233 #[doc = "20 - FLEXCOMM6"]
234 FLEXCOMM6 = 20,
235 #[doc = "21 - FLEXCOMM7"]
236 FLEXCOMM7 = 21,
237 #[doc = "22 - ADC0"]
238 ADC0 = 22,
239 #[doc = "24 - ACMP"]
240 ACMP = 24,
241 #[doc = "27 - USB0_NEEDCLK"]
242 USB0_NEEDCLK = 27,
243 #[doc = "28 - USB0"]
244 USB0 = 28,
245 #[doc = "29 - RTC"]
246 RTC = 29,
247 #[doc = "31 - MAILBOX"]
248 MAILBOX = 31,
249 #[doc = "32 - PIN_INT4"]
250 PIN_INT4 = 32,
251 #[doc = "33 - PIN_INT5"]
252 PIN_INT5 = 33,
253 #[doc = "34 - PIN_INT6"]
254 PIN_INT6 = 34,
255 #[doc = "35 - PIN_INT7"]
256 PIN_INT7 = 35,
257 #[doc = "36 - CTIMER2"]
258 CTIMER2 = 36,
259 #[doc = "37 - CTIMER4"]
260 CTIMER4 = 37,
261 #[doc = "38 - OS_EVENT"]
262 OS_EVENT = 38,
263 #[doc = "42 - SDIO"]
264 SDIO = 42,
265 #[doc = "46 - USB1_PHY"]
266 USB1_PHY = 46,
267 #[doc = "47 - USB1"]
268 USB1 = 47,
269 #[doc = "48 - USB1_NEEDCLK"]
270 USB1_NEEDCLK = 48,
271 #[doc = "49 - SEC_HYPERVISOR_CALL"]
272 SEC_HYPERVISOR_CALL = 49,
273 #[doc = "50 - SEC_GPIO_INT0_IRQ0"]
274 SEC_GPIO_INT0_IRQ0 = 50,
275 #[doc = "51 - SEC_GPIO_INT0_IRQ1"]
276 SEC_GPIO_INT0_IRQ1 = 51,
277 #[doc = "52 - PLU"]
278 PLU = 52,
279 #[doc = "53 - SEC_VIO"]
280 SEC_VIO = 53,
281 #[doc = "54 - HASHCRYPT"]
282 HASHCRYPT = 54,
283 #[doc = "55 - CASER"]
284 CASER = 55,
285 #[doc = "56 - PUF"]
286 PUF = 56,
287 #[doc = "57 - PQ"]
288 PQ = 57,
289 #[doc = "58 - DMA1"]
290 DMA1 = 58,
291 #[doc = "59 - FLEXCOMM8"]
292 FLEXCOMM8 = 59,
293}
294unsafe impl cortex_m::interrupt::InterruptNumber for Interrupt {
295 #[inline(always)]
296 fn number(self) -> u16 {
297 self as u16
298 }
299}
300#[doc = "FLASH_CFPA"]
301pub struct FLASH_CFPA0 {
302 _marker: PhantomData<*const ()>,
303}
304unsafe impl Send for FLASH_CFPA0 {}
305impl FLASH_CFPA0 {
306 #[doc = r"Pointer to the register block"]
307 pub const PTR: *const flash_cfpa0::RegisterBlock = 0x0009_e000 as *const _;
308 #[doc = r"Return the pointer to the register block"]
309 #[inline(always)]
310 pub const fn ptr() -> *const flash_cfpa0::RegisterBlock {
311 Self::PTR
312 }
313}
314impl Deref for FLASH_CFPA0 {
315 type Target = flash_cfpa0::RegisterBlock;
316 #[inline(always)]
317 fn deref(&self) -> &Self::Target {
318 unsafe { &*Self::PTR }
319 }
320}
321impl core::fmt::Debug for FLASH_CFPA0 {
322 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
323 f.debug_struct("FLASH_CFPA0").finish()
324 }
325}
326#[doc = "FLASH_CFPA"]
327pub mod flash_cfpa0;
328#[doc = "FLASH_CFPA"]
329pub struct FLASH_CFPA_SCRATCH {
330 _marker: PhantomData<*const ()>,
331}
332unsafe impl Send for FLASH_CFPA_SCRATCH {}
333impl FLASH_CFPA_SCRATCH {
334 #[doc = r"Pointer to the register block"]
335 pub const PTR: *const flash_cfpa0::RegisterBlock = 0x0009_de00 as *const _;
336 #[doc = r"Return the pointer to the register block"]
337 #[inline(always)]
338 pub const fn ptr() -> *const flash_cfpa0::RegisterBlock {
339 Self::PTR
340 }
341}
342impl Deref for FLASH_CFPA_SCRATCH {
343 type Target = flash_cfpa0::RegisterBlock;
344 #[inline(always)]
345 fn deref(&self) -> &Self::Target {
346 unsafe { &*Self::PTR }
347 }
348}
349impl core::fmt::Debug for FLASH_CFPA_SCRATCH {
350 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
351 f.debug_struct("FLASH_CFPA_SCRATCH").finish()
352 }
353}
354#[doc = "FLASH_CFPA"]
355pub use flash_cfpa0 as flash_cfpa_scratch;
356#[doc = "FLASH_CFPA"]
357pub struct FLASH_CFPA1 {
358 _marker: PhantomData<*const ()>,
359}
360unsafe impl Send for FLASH_CFPA1 {}
361impl FLASH_CFPA1 {
362 #[doc = r"Pointer to the register block"]
363 pub const PTR: *const flash_cfpa0::RegisterBlock = 0x0009_e200 as *const _;
364 #[doc = r"Return the pointer to the register block"]
365 #[inline(always)]
366 pub const fn ptr() -> *const flash_cfpa0::RegisterBlock {
367 Self::PTR
368 }
369}
370impl Deref for FLASH_CFPA1 {
371 type Target = flash_cfpa0::RegisterBlock;
372 #[inline(always)]
373 fn deref(&self) -> &Self::Target {
374 unsafe { &*Self::PTR }
375 }
376}
377impl core::fmt::Debug for FLASH_CFPA1 {
378 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
379 f.debug_struct("FLASH_CFPA1").finish()
380 }
381}
382#[doc = "FLASH_CFPA"]
383pub use flash_cfpa0 as flash_cfpa1;
384#[doc = "FLASH_CMPA"]
385pub struct FLASH_CMPA {
386 _marker: PhantomData<*const ()>,
387}
388unsafe impl Send for FLASH_CMPA {}
389impl FLASH_CMPA {
390 #[doc = r"Pointer to the register block"]
391 pub const PTR: *const flash_cmpa::RegisterBlock = 0x0009_e400 as *const _;
392 #[doc = r"Return the pointer to the register block"]
393 #[inline(always)]
394 pub const fn ptr() -> *const flash_cmpa::RegisterBlock {
395 Self::PTR
396 }
397}
398impl Deref for FLASH_CMPA {
399 type Target = flash_cmpa::RegisterBlock;
400 #[inline(always)]
401 fn deref(&self) -> &Self::Target {
402 unsafe { &*Self::PTR }
403 }
404}
405impl core::fmt::Debug for FLASH_CMPA {
406 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
407 f.debug_struct("FLASH_CMPA").finish()
408 }
409}
410#[doc = "FLASH_CMPA"]
411pub mod flash_cmpa;
412#[doc = "FLASH_KEY_STORE"]
413pub struct FLASH_KEY_STORE {
414 _marker: PhantomData<*const ()>,
415}
416unsafe impl Send for FLASH_KEY_STORE {}
417impl FLASH_KEY_STORE {
418 #[doc = r"Pointer to the register block"]
419 pub const PTR: *const flash_key_store::RegisterBlock = 0x0009_e600 as *const _;
420 #[doc = r"Return the pointer to the register block"]
421 #[inline(always)]
422 pub const fn ptr() -> *const flash_key_store::RegisterBlock {
423 Self::PTR
424 }
425}
426impl Deref for FLASH_KEY_STORE {
427 type Target = flash_key_store::RegisterBlock;
428 #[inline(always)]
429 fn deref(&self) -> &Self::Target {
430 unsafe { &*Self::PTR }
431 }
432}
433impl core::fmt::Debug for FLASH_KEY_STORE {
434 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
435 f.debug_struct("FLASH_KEY_STORE").finish()
436 }
437}
438#[doc = "FLASH_KEY_STORE"]
439pub mod flash_key_store;
440#[doc = "SYSCON"]
441pub struct SYSCON {
442 _marker: PhantomData<*const ()>,
443}
444unsafe impl Send for SYSCON {}
445impl SYSCON {
446 #[doc = r"Pointer to the register block"]
447 pub const PTR: *const syscon::RegisterBlock = 0x4000_0000 as *const _;
448 #[doc = r"Return the pointer to the register block"]
449 #[inline(always)]
450 pub const fn ptr() -> *const syscon::RegisterBlock {
451 Self::PTR
452 }
453}
454impl Deref for SYSCON {
455 type Target = syscon::RegisterBlock;
456 #[inline(always)]
457 fn deref(&self) -> &Self::Target {
458 unsafe { &*Self::PTR }
459 }
460}
461impl core::fmt::Debug for SYSCON {
462 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
463 f.debug_struct("SYSCON").finish()
464 }
465}
466#[doc = "SYSCON"]
467pub mod syscon;
468#[doc = "I/O pin configuration (IOCON)"]
469pub struct IOCON {
470 _marker: PhantomData<*const ()>,
471}
472unsafe impl Send for IOCON {}
473impl IOCON {
474 #[doc = r"Pointer to the register block"]
475 pub const PTR: *const iocon::RegisterBlock = 0x4000_1000 as *const _;
476 #[doc = r"Return the pointer to the register block"]
477 #[inline(always)]
478 pub const fn ptr() -> *const iocon::RegisterBlock {
479 Self::PTR
480 }
481}
482impl Deref for IOCON {
483 type Target = iocon::RegisterBlock;
484 #[inline(always)]
485 fn deref(&self) -> &Self::Target {
486 unsafe { &*Self::PTR }
487 }
488}
489impl core::fmt::Debug for IOCON {
490 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
491 f.debug_struct("IOCON").finish()
492 }
493}
494#[doc = "I/O pin configuration (IOCON)"]
495pub mod iocon;
496#[doc = "Group GPIO input interrupt (GINT0/1)"]
497pub struct GINT0 {
498 _marker: PhantomData<*const ()>,
499}
500unsafe impl Send for GINT0 {}
501impl GINT0 {
502 #[doc = r"Pointer to the register block"]
503 pub const PTR: *const gint0::RegisterBlock = 0x4000_2000 as *const _;
504 #[doc = r"Return the pointer to the register block"]
505 #[inline(always)]
506 pub const fn ptr() -> *const gint0::RegisterBlock {
507 Self::PTR
508 }
509}
510impl Deref for GINT0 {
511 type Target = gint0::RegisterBlock;
512 #[inline(always)]
513 fn deref(&self) -> &Self::Target {
514 unsafe { &*Self::PTR }
515 }
516}
517impl core::fmt::Debug for GINT0 {
518 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
519 f.debug_struct("GINT0").finish()
520 }
521}
522#[doc = "Group GPIO input interrupt (GINT0/1)"]
523pub mod gint0;
524#[doc = "Group GPIO input interrupt (GINT0/1)"]
525pub struct GINT1 {
526 _marker: PhantomData<*const ()>,
527}
528unsafe impl Send for GINT1 {}
529impl GINT1 {
530 #[doc = r"Pointer to the register block"]
531 pub const PTR: *const gint0::RegisterBlock = 0x4000_3000 as *const _;
532 #[doc = r"Return the pointer to the register block"]
533 #[inline(always)]
534 pub const fn ptr() -> *const gint0::RegisterBlock {
535 Self::PTR
536 }
537}
538impl Deref for GINT1 {
539 type Target = gint0::RegisterBlock;
540 #[inline(always)]
541 fn deref(&self) -> &Self::Target {
542 unsafe { &*Self::PTR }
543 }
544}
545impl core::fmt::Debug for GINT1 {
546 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
547 f.debug_struct("GINT1").finish()
548 }
549}
550#[doc = "Group GPIO input interrupt (GINT0/1)"]
551pub use gint0 as gint1;
552#[doc = "Pin interrupt and pattern match (PINT)"]
553pub struct PINT {
554 _marker: PhantomData<*const ()>,
555}
556unsafe impl Send for PINT {}
557impl PINT {
558 #[doc = r"Pointer to the register block"]
559 pub const PTR: *const pint::RegisterBlock = 0x4000_4000 as *const _;
560 #[doc = r"Return the pointer to the register block"]
561 #[inline(always)]
562 pub const fn ptr() -> *const pint::RegisterBlock {
563 Self::PTR
564 }
565}
566impl Deref for PINT {
567 type Target = pint::RegisterBlock;
568 #[inline(always)]
569 fn deref(&self) -> &Self::Target {
570 unsafe { &*Self::PTR }
571 }
572}
573impl core::fmt::Debug for PINT {
574 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
575 f.debug_struct("PINT").finish()
576 }
577}
578#[doc = "Pin interrupt and pattern match (PINT)"]
579pub mod pint;
580#[doc = "Pin interrupt and pattern match (PINT)"]
581pub struct SECPINT {
582 _marker: PhantomData<*const ()>,
583}
584unsafe impl Send for SECPINT {}
585impl SECPINT {
586 #[doc = r"Pointer to the register block"]
587 pub const PTR: *const pint::RegisterBlock = 0x4000_5000 as *const _;
588 #[doc = r"Return the pointer to the register block"]
589 #[inline(always)]
590 pub const fn ptr() -> *const pint::RegisterBlock {
591 Self::PTR
592 }
593}
594impl Deref for SECPINT {
595 type Target = pint::RegisterBlock;
596 #[inline(always)]
597 fn deref(&self) -> &Self::Target {
598 unsafe { &*Self::PTR }
599 }
600}
601impl core::fmt::Debug for SECPINT {
602 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
603 f.debug_struct("SECPINT").finish()
604 }
605}
606#[doc = "Pin interrupt and pattern match (PINT)"]
607pub use pint as secpint;
608#[doc = "Input multiplexing (INPUT MUX)"]
609pub struct INPUTMUX {
610 _marker: PhantomData<*const ()>,
611}
612unsafe impl Send for INPUTMUX {}
613impl INPUTMUX {
614 #[doc = r"Pointer to the register block"]
615 pub const PTR: *const inputmux::RegisterBlock = 0x4000_6000 as *const _;
616 #[doc = r"Return the pointer to the register block"]
617 #[inline(always)]
618 pub const fn ptr() -> *const inputmux::RegisterBlock {
619 Self::PTR
620 }
621}
622impl Deref for INPUTMUX {
623 type Target = inputmux::RegisterBlock;
624 #[inline(always)]
625 fn deref(&self) -> &Self::Target {
626 unsafe { &*Self::PTR }
627 }
628}
629impl core::fmt::Debug for INPUTMUX {
630 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
631 f.debug_struct("INPUTMUX").finish()
632 }
633}
634#[doc = "Input multiplexing (INPUT MUX)"]
635pub mod inputmux;
636#[doc = "Standard counter/timers (CTIMER0 to 4)"]
637pub struct CTIMER0 {
638 _marker: PhantomData<*const ()>,
639}
640unsafe impl Send for CTIMER0 {}
641impl CTIMER0 {
642 #[doc = r"Pointer to the register block"]
643 pub const PTR: *const ctimer0::RegisterBlock = 0x4000_8000 as *const _;
644 #[doc = r"Return the pointer to the register block"]
645 #[inline(always)]
646 pub const fn ptr() -> *const ctimer0::RegisterBlock {
647 Self::PTR
648 }
649}
650impl Deref for CTIMER0 {
651 type Target = ctimer0::RegisterBlock;
652 #[inline(always)]
653 fn deref(&self) -> &Self::Target {
654 unsafe { &*Self::PTR }
655 }
656}
657impl core::fmt::Debug for CTIMER0 {
658 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
659 f.debug_struct("CTIMER0").finish()
660 }
661}
662#[doc = "Standard counter/timers (CTIMER0 to 4)"]
663pub mod ctimer0;
664#[doc = "Standard counter/timers (CTIMER0 to 4)"]
665pub struct CTIMER1 {
666 _marker: PhantomData<*const ()>,
667}
668unsafe impl Send for CTIMER1 {}
669impl CTIMER1 {
670 #[doc = r"Pointer to the register block"]
671 pub const PTR: *const ctimer0::RegisterBlock = 0x4000_9000 as *const _;
672 #[doc = r"Return the pointer to the register block"]
673 #[inline(always)]
674 pub const fn ptr() -> *const ctimer0::RegisterBlock {
675 Self::PTR
676 }
677}
678impl Deref for CTIMER1 {
679 type Target = ctimer0::RegisterBlock;
680 #[inline(always)]
681 fn deref(&self) -> &Self::Target {
682 unsafe { &*Self::PTR }
683 }
684}
685impl core::fmt::Debug for CTIMER1 {
686 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
687 f.debug_struct("CTIMER1").finish()
688 }
689}
690#[doc = "Standard counter/timers (CTIMER0 to 4)"]
691pub use ctimer0 as ctimer1;
692#[doc = "Standard counter/timers (CTIMER0 to 4)"]
693pub struct CTIMER2 {
694 _marker: PhantomData<*const ()>,
695}
696unsafe impl Send for CTIMER2 {}
697impl CTIMER2 {
698 #[doc = r"Pointer to the register block"]
699 pub const PTR: *const ctimer0::RegisterBlock = 0x4002_8000 as *const _;
700 #[doc = r"Return the pointer to the register block"]
701 #[inline(always)]
702 pub const fn ptr() -> *const ctimer0::RegisterBlock {
703 Self::PTR
704 }
705}
706impl Deref for CTIMER2 {
707 type Target = ctimer0::RegisterBlock;
708 #[inline(always)]
709 fn deref(&self) -> &Self::Target {
710 unsafe { &*Self::PTR }
711 }
712}
713impl core::fmt::Debug for CTIMER2 {
714 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
715 f.debug_struct("CTIMER2").finish()
716 }
717}
718#[doc = "Standard counter/timers (CTIMER0 to 4)"]
719pub use ctimer0 as ctimer2;
720#[doc = "Standard counter/timers (CTIMER0 to 4)"]
721pub struct CTIMER3 {
722 _marker: PhantomData<*const ()>,
723}
724unsafe impl Send for CTIMER3 {}
725impl CTIMER3 {
726 #[doc = r"Pointer to the register block"]
727 pub const PTR: *const ctimer0::RegisterBlock = 0x4002_9000 as *const _;
728 #[doc = r"Return the pointer to the register block"]
729 #[inline(always)]
730 pub const fn ptr() -> *const ctimer0::RegisterBlock {
731 Self::PTR
732 }
733}
734impl Deref for CTIMER3 {
735 type Target = ctimer0::RegisterBlock;
736 #[inline(always)]
737 fn deref(&self) -> &Self::Target {
738 unsafe { &*Self::PTR }
739 }
740}
741impl core::fmt::Debug for CTIMER3 {
742 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
743 f.debug_struct("CTIMER3").finish()
744 }
745}
746#[doc = "Standard counter/timers (CTIMER0 to 4)"]
747pub use ctimer0 as ctimer3;
748#[doc = "Standard counter/timers (CTIMER0 to 4)"]
749pub struct CTIMER4 {
750 _marker: PhantomData<*const ()>,
751}
752unsafe impl Send for CTIMER4 {}
753impl CTIMER4 {
754 #[doc = r"Pointer to the register block"]
755 pub const PTR: *const ctimer0::RegisterBlock = 0x4002_a000 as *const _;
756 #[doc = r"Return the pointer to the register block"]
757 #[inline(always)]
758 pub const fn ptr() -> *const ctimer0::RegisterBlock {
759 Self::PTR
760 }
761}
762impl Deref for CTIMER4 {
763 type Target = ctimer0::RegisterBlock;
764 #[inline(always)]
765 fn deref(&self) -> &Self::Target {
766 unsafe { &*Self::PTR }
767 }
768}
769impl core::fmt::Debug for CTIMER4 {
770 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
771 f.debug_struct("CTIMER4").finish()
772 }
773}
774#[doc = "Standard counter/timers (CTIMER0 to 4)"]
775pub use ctimer0 as ctimer4;
776#[doc = "Windowed Watchdog Timer (WWDT)"]
777pub struct WWDT {
778 _marker: PhantomData<*const ()>,
779}
780unsafe impl Send for WWDT {}
781impl WWDT {
782 #[doc = r"Pointer to the register block"]
783 pub const PTR: *const wwdt::RegisterBlock = 0x4000_c000 as *const _;
784 #[doc = r"Return the pointer to the register block"]
785 #[inline(always)]
786 pub const fn ptr() -> *const wwdt::RegisterBlock {
787 Self::PTR
788 }
789}
790impl Deref for WWDT {
791 type Target = wwdt::RegisterBlock;
792 #[inline(always)]
793 fn deref(&self) -> &Self::Target {
794 unsafe { &*Self::PTR }
795 }
796}
797impl core::fmt::Debug for WWDT {
798 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
799 f.debug_struct("WWDT").finish()
800 }
801}
802#[doc = "Windowed Watchdog Timer (WWDT)"]
803pub mod wwdt;
804#[doc = "Multi-Rate Timer (MRT)"]
805pub struct MRT0 {
806 _marker: PhantomData<*const ()>,
807}
808unsafe impl Send for MRT0 {}
809impl MRT0 {
810 #[doc = r"Pointer to the register block"]
811 pub const PTR: *const mrt0::RegisterBlock = 0x4000_d000 as *const _;
812 #[doc = r"Return the pointer to the register block"]
813 #[inline(always)]
814 pub const fn ptr() -> *const mrt0::RegisterBlock {
815 Self::PTR
816 }
817}
818impl Deref for MRT0 {
819 type Target = mrt0::RegisterBlock;
820 #[inline(always)]
821 fn deref(&self) -> &Self::Target {
822 unsafe { &*Self::PTR }
823 }
824}
825impl core::fmt::Debug for MRT0 {
826 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
827 f.debug_struct("MRT0").finish()
828 }
829}
830#[doc = "Multi-Rate Timer (MRT)"]
831pub mod mrt0;
832#[doc = "Micro-tick Timer (UTICK)"]
833pub struct UTICK0 {
834 _marker: PhantomData<*const ()>,
835}
836unsafe impl Send for UTICK0 {}
837impl UTICK0 {
838 #[doc = r"Pointer to the register block"]
839 pub const PTR: *const utick0::RegisterBlock = 0x4000_e000 as *const _;
840 #[doc = r"Return the pointer to the register block"]
841 #[inline(always)]
842 pub const fn ptr() -> *const utick0::RegisterBlock {
843 Self::PTR
844 }
845}
846impl Deref for UTICK0 {
847 type Target = utick0::RegisterBlock;
848 #[inline(always)]
849 fn deref(&self) -> &Self::Target {
850 unsafe { &*Self::PTR }
851 }
852}
853impl core::fmt::Debug for UTICK0 {
854 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
855 f.debug_struct("UTICK0").finish()
856 }
857}
858#[doc = "Micro-tick Timer (UTICK)"]
859pub mod utick0;
860#[doc = "ANALOGCTRL"]
861pub struct ANACTRL {
862 _marker: PhantomData<*const ()>,
863}
864unsafe impl Send for ANACTRL {}
865impl ANACTRL {
866 #[doc = r"Pointer to the register block"]
867 pub const PTR: *const anactrl::RegisterBlock = 0x4001_3000 as *const _;
868 #[doc = r"Return the pointer to the register block"]
869 #[inline(always)]
870 pub const fn ptr() -> *const anactrl::RegisterBlock {
871 Self::PTR
872 }
873}
874impl Deref for ANACTRL {
875 type Target = anactrl::RegisterBlock;
876 #[inline(always)]
877 fn deref(&self) -> &Self::Target {
878 unsafe { &*Self::PTR }
879 }
880}
881impl core::fmt::Debug for ANACTRL {
882 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
883 f.debug_struct("ANACTRL").finish()
884 }
885}
886#[doc = "ANALOGCTRL"]
887pub mod anactrl;
888#[doc = "PMC"]
889pub struct PMC {
890 _marker: PhantomData<*const ()>,
891}
892unsafe impl Send for PMC {}
893impl PMC {
894 #[doc = r"Pointer to the register block"]
895 pub const PTR: *const pmc::RegisterBlock = 0x4002_0000 as *const _;
896 #[doc = r"Return the pointer to the register block"]
897 #[inline(always)]
898 pub const fn ptr() -> *const pmc::RegisterBlock {
899 Self::PTR
900 }
901}
902impl Deref for PMC {
903 type Target = pmc::RegisterBlock;
904 #[inline(always)]
905 fn deref(&self) -> &Self::Target {
906 unsafe { &*Self::PTR }
907 }
908}
909impl core::fmt::Debug for PMC {
910 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
911 f.debug_struct("PMC").finish()
912 }
913}
914#[doc = "PMC"]
915pub mod pmc;
916#[doc = "system controller"]
917pub struct SYSCTL {
918 _marker: PhantomData<*const ()>,
919}
920unsafe impl Send for SYSCTL {}
921impl SYSCTL {
922 #[doc = r"Pointer to the register block"]
923 pub const PTR: *const sysctl::RegisterBlock = 0x4002_3000 as *const _;
924 #[doc = r"Return the pointer to the register block"]
925 #[inline(always)]
926 pub const fn ptr() -> *const sysctl::RegisterBlock {
927 Self::PTR
928 }
929}
930impl Deref for SYSCTL {
931 type Target = sysctl::RegisterBlock;
932 #[inline(always)]
933 fn deref(&self) -> &Self::Target {
934 unsafe { &*Self::PTR }
935 }
936}
937impl core::fmt::Debug for SYSCTL {
938 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
939 f.debug_struct("SYSCTL").finish()
940 }
941}
942#[doc = "system controller"]
943pub mod sysctl;
944#[doc = "Real-Time Clock (RTC)"]
945pub struct RTC {
946 _marker: PhantomData<*const ()>,
947}
948unsafe impl Send for RTC {}
949impl RTC {
950 #[doc = r"Pointer to the register block"]
951 pub const PTR: *const rtc::RegisterBlock = 0x4002_c000 as *const _;
952 #[doc = r"Return the pointer to the register block"]
953 #[inline(always)]
954 pub const fn ptr() -> *const rtc::RegisterBlock {
955 Self::PTR
956 }
957}
958impl Deref for RTC {
959 type Target = rtc::RegisterBlock;
960 #[inline(always)]
961 fn deref(&self) -> &Self::Target {
962 unsafe { &*Self::PTR }
963 }
964}
965impl core::fmt::Debug for RTC {
966 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
967 f.debug_struct("RTC").finish()
968 }
969}
970#[doc = "Real-Time Clock (RTC)"]
971pub mod rtc;
972#[doc = "Synchronous OS/Event timer with Wakeup Timer"]
973pub struct OSTIMER {
974 _marker: PhantomData<*const ()>,
975}
976unsafe impl Send for OSTIMER {}
977impl OSTIMER {
978 #[doc = r"Pointer to the register block"]
979 pub const PTR: *const ostimer::RegisterBlock = 0x4002_d000 as *const _;
980 #[doc = r"Return the pointer to the register block"]
981 #[inline(always)]
982 pub const fn ptr() -> *const ostimer::RegisterBlock {
983 Self::PTR
984 }
985}
986impl Deref for OSTIMER {
987 type Target = ostimer::RegisterBlock;
988 #[inline(always)]
989 fn deref(&self) -> &Self::Target {
990 unsafe { &*Self::PTR }
991 }
992}
993impl core::fmt::Debug for OSTIMER {
994 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
995 f.debug_struct("OSTIMER").finish()
996 }
997}
998#[doc = "Synchronous OS/Event timer with Wakeup Timer"]
999pub mod ostimer;
1000#[doc = "FLASH"]
1001pub struct FLASH {
1002 _marker: PhantomData<*const ()>,
1003}
1004unsafe impl Send for FLASH {}
1005impl FLASH {
1006 #[doc = r"Pointer to the register block"]
1007 pub const PTR: *const flash::RegisterBlock = 0x4003_4000 as *const _;
1008 #[doc = r"Return the pointer to the register block"]
1009 #[inline(always)]
1010 pub const fn ptr() -> *const flash::RegisterBlock {
1011 Self::PTR
1012 }
1013}
1014impl Deref for FLASH {
1015 type Target = flash::RegisterBlock;
1016 #[inline(always)]
1017 fn deref(&self) -> &Self::Target {
1018 unsafe { &*Self::PTR }
1019 }
1020}
1021impl core::fmt::Debug for FLASH {
1022 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1023 f.debug_struct("FLASH").finish()
1024 }
1025}
1026#[doc = "FLASH"]
1027pub mod flash;
1028#[doc = "PRINCE"]
1029pub struct PRINCE {
1030 _marker: PhantomData<*const ()>,
1031}
1032unsafe impl Send for PRINCE {}
1033impl PRINCE {
1034 #[doc = r"Pointer to the register block"]
1035 pub const PTR: *const prince::RegisterBlock = 0x4003_5000 as *const _;
1036 #[doc = r"Return the pointer to the register block"]
1037 #[inline(always)]
1038 pub const fn ptr() -> *const prince::RegisterBlock {
1039 Self::PTR
1040 }
1041}
1042impl Deref for PRINCE {
1043 type Target = prince::RegisterBlock;
1044 #[inline(always)]
1045 fn deref(&self) -> &Self::Target {
1046 unsafe { &*Self::PTR }
1047 }
1048}
1049impl core::fmt::Debug for PRINCE {
1050 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1051 f.debug_struct("PRINCE").finish()
1052 }
1053}
1054#[doc = "PRINCE"]
1055pub mod prince;
1056#[doc = "Universal System Bus Physical Layer"]
1057pub struct USBPHY {
1058 _marker: PhantomData<*const ()>,
1059}
1060unsafe impl Send for USBPHY {}
1061impl USBPHY {
1062 #[doc = r"Pointer to the register block"]
1063 pub const PTR: *const usbphy::RegisterBlock = 0x4003_8000 as *const _;
1064 #[doc = r"Return the pointer to the register block"]
1065 #[inline(always)]
1066 pub const fn ptr() -> *const usbphy::RegisterBlock {
1067 Self::PTR
1068 }
1069}
1070impl Deref for USBPHY {
1071 type Target = usbphy::RegisterBlock;
1072 #[inline(always)]
1073 fn deref(&self) -> &Self::Target {
1074 unsafe { &*Self::PTR }
1075 }
1076}
1077impl core::fmt::Debug for USBPHY {
1078 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1079 f.debug_struct("USBPHY").finish()
1080 }
1081}
1082#[doc = "Universal System Bus Physical Layer"]
1083pub mod usbphy;
1084#[doc = "RNG"]
1085pub struct RNG {
1086 _marker: PhantomData<*const ()>,
1087}
1088unsafe impl Send for RNG {}
1089impl RNG {
1090 #[doc = r"Pointer to the register block"]
1091 pub const PTR: *const rng::RegisterBlock = 0x4003_a000 as *const _;
1092 #[doc = r"Return the pointer to the register block"]
1093 #[inline(always)]
1094 pub const fn ptr() -> *const rng::RegisterBlock {
1095 Self::PTR
1096 }
1097}
1098impl Deref for RNG {
1099 type Target = rng::RegisterBlock;
1100 #[inline(always)]
1101 fn deref(&self) -> &Self::Target {
1102 unsafe { &*Self::PTR }
1103 }
1104}
1105impl core::fmt::Debug for RNG {
1106 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1107 f.debug_struct("RNG").finish()
1108 }
1109}
1110#[doc = "RNG"]
1111pub mod rng;
1112#[doc = "PUFCTRL"]
1113pub struct PUF {
1114 _marker: PhantomData<*const ()>,
1115}
1116unsafe impl Send for PUF {}
1117impl PUF {
1118 #[doc = r"Pointer to the register block"]
1119 pub const PTR: *const puf::RegisterBlock = 0x4003_b000 as *const _;
1120 #[doc = r"Return the pointer to the register block"]
1121 #[inline(always)]
1122 pub const fn ptr() -> *const puf::RegisterBlock {
1123 Self::PTR
1124 }
1125}
1126impl Deref for PUF {
1127 type Target = puf::RegisterBlock;
1128 #[inline(always)]
1129 fn deref(&self) -> &Self::Target {
1130 unsafe { &*Self::PTR }
1131 }
1132}
1133impl core::fmt::Debug for PUF {
1134 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1135 f.debug_struct("PUF").finish()
1136 }
1137}
1138#[doc = "PUFCTRL"]
1139pub mod puf;
1140#[doc = "LPC80X Programmable Logic Unit (PLU)"]
1141pub struct PLU {
1142 _marker: PhantomData<*const ()>,
1143}
1144unsafe impl Send for PLU {}
1145impl PLU {
1146 #[doc = r"Pointer to the register block"]
1147 pub const PTR: *const plu::RegisterBlock = 0x4003_d000 as *const _;
1148 #[doc = r"Return the pointer to the register block"]
1149 #[inline(always)]
1150 pub const fn ptr() -> *const plu::RegisterBlock {
1151 Self::PTR
1152 }
1153}
1154impl Deref for PLU {
1155 type Target = plu::RegisterBlock;
1156 #[inline(always)]
1157 fn deref(&self) -> &Self::Target {
1158 unsafe { &*Self::PTR }
1159 }
1160}
1161impl core::fmt::Debug for PLU {
1162 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1163 f.debug_struct("PLU").finish()
1164 }
1165}
1166#[doc = "LPC80X Programmable Logic Unit (PLU)"]
1167pub mod plu;
1168#[doc = "DMA controller"]
1169pub struct DMA0 {
1170 _marker: PhantomData<*const ()>,
1171}
1172unsafe impl Send for DMA0 {}
1173impl DMA0 {
1174 #[doc = r"Pointer to the register block"]
1175 pub const PTR: *const dma0::RegisterBlock = 0x4008_2000 as *const _;
1176 #[doc = r"Return the pointer to the register block"]
1177 #[inline(always)]
1178 pub const fn ptr() -> *const dma0::RegisterBlock {
1179 Self::PTR
1180 }
1181}
1182impl Deref for DMA0 {
1183 type Target = dma0::RegisterBlock;
1184 #[inline(always)]
1185 fn deref(&self) -> &Self::Target {
1186 unsafe { &*Self::PTR }
1187 }
1188}
1189impl core::fmt::Debug for DMA0 {
1190 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1191 f.debug_struct("DMA0").finish()
1192 }
1193}
1194#[doc = "DMA controller"]
1195pub mod dma0;
1196#[doc = "DMA controller"]
1197pub struct DMA1 {
1198 _marker: PhantomData<*const ()>,
1199}
1200unsafe impl Send for DMA1 {}
1201impl DMA1 {
1202 #[doc = r"Pointer to the register block"]
1203 pub const PTR: *const dma0::RegisterBlock = 0x400a_7000 as *const _;
1204 #[doc = r"Return the pointer to the register block"]
1205 #[inline(always)]
1206 pub const fn ptr() -> *const dma0::RegisterBlock {
1207 Self::PTR
1208 }
1209}
1210impl Deref for DMA1 {
1211 type Target = dma0::RegisterBlock;
1212 #[inline(always)]
1213 fn deref(&self) -> &Self::Target {
1214 unsafe { &*Self::PTR }
1215 }
1216}
1217impl core::fmt::Debug for DMA1 {
1218 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1219 f.debug_struct("DMA1").finish()
1220 }
1221}
1222#[doc = "DMA controller"]
1223pub use dma0 as dma1;
1224#[doc = "SCTimer/PWM (SCT)"]
1225pub struct SCT0 {
1226 _marker: PhantomData<*const ()>,
1227}
1228unsafe impl Send for SCT0 {}
1229impl SCT0 {
1230 #[doc = r"Pointer to the register block"]
1231 pub const PTR: *const sct0::RegisterBlock = 0x4008_5000 as *const _;
1232 #[doc = r"Return the pointer to the register block"]
1233 #[inline(always)]
1234 pub const fn ptr() -> *const sct0::RegisterBlock {
1235 Self::PTR
1236 }
1237}
1238impl Deref for SCT0 {
1239 type Target = sct0::RegisterBlock;
1240 #[inline(always)]
1241 fn deref(&self) -> &Self::Target {
1242 unsafe { &*Self::PTR }
1243 }
1244}
1245impl core::fmt::Debug for SCT0 {
1246 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1247 f.debug_struct("SCT0").finish()
1248 }
1249}
1250#[doc = "SCTimer/PWM (SCT)"]
1251pub mod sct0;
1252#[doc = "Flexcomm serial communication"]
1253pub struct FLEXCOMM0 {
1254 _marker: PhantomData<*const ()>,
1255}
1256unsafe impl Send for FLEXCOMM0 {}
1257impl FLEXCOMM0 {
1258 #[doc = r"Pointer to the register block"]
1259 pub const PTR: *const flexcomm0::RegisterBlock = 0x4008_6000 as *const _;
1260 #[doc = r"Return the pointer to the register block"]
1261 #[inline(always)]
1262 pub const fn ptr() -> *const flexcomm0::RegisterBlock {
1263 Self::PTR
1264 }
1265}
1266impl Deref for FLEXCOMM0 {
1267 type Target = flexcomm0::RegisterBlock;
1268 #[inline(always)]
1269 fn deref(&self) -> &Self::Target {
1270 unsafe { &*Self::PTR }
1271 }
1272}
1273impl core::fmt::Debug for FLEXCOMM0 {
1274 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1275 f.debug_struct("FLEXCOMM0").finish()
1276 }
1277}
1278#[doc = "Flexcomm serial communication"]
1279pub mod flexcomm0;
1280#[doc = "Flexcomm serial communication"]
1281pub struct FLEXCOMM1 {
1282 _marker: PhantomData<*const ()>,
1283}
1284unsafe impl Send for FLEXCOMM1 {}
1285impl FLEXCOMM1 {
1286 #[doc = r"Pointer to the register block"]
1287 pub const PTR: *const flexcomm0::RegisterBlock = 0x4008_7000 as *const _;
1288 #[doc = r"Return the pointer to the register block"]
1289 #[inline(always)]
1290 pub const fn ptr() -> *const flexcomm0::RegisterBlock {
1291 Self::PTR
1292 }
1293}
1294impl Deref for FLEXCOMM1 {
1295 type Target = flexcomm0::RegisterBlock;
1296 #[inline(always)]
1297 fn deref(&self) -> &Self::Target {
1298 unsafe { &*Self::PTR }
1299 }
1300}
1301impl core::fmt::Debug for FLEXCOMM1 {
1302 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1303 f.debug_struct("FLEXCOMM1").finish()
1304 }
1305}
1306#[doc = "Flexcomm serial communication"]
1307pub use flexcomm0 as flexcomm1;
1308#[doc = "Flexcomm serial communication"]
1309pub struct FLEXCOMM2 {
1310 _marker: PhantomData<*const ()>,
1311}
1312unsafe impl Send for FLEXCOMM2 {}
1313impl FLEXCOMM2 {
1314 #[doc = r"Pointer to the register block"]
1315 pub const PTR: *const flexcomm0::RegisterBlock = 0x4008_8000 as *const _;
1316 #[doc = r"Return the pointer to the register block"]
1317 #[inline(always)]
1318 pub const fn ptr() -> *const flexcomm0::RegisterBlock {
1319 Self::PTR
1320 }
1321}
1322impl Deref for FLEXCOMM2 {
1323 type Target = flexcomm0::RegisterBlock;
1324 #[inline(always)]
1325 fn deref(&self) -> &Self::Target {
1326 unsafe { &*Self::PTR }
1327 }
1328}
1329impl core::fmt::Debug for FLEXCOMM2 {
1330 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1331 f.debug_struct("FLEXCOMM2").finish()
1332 }
1333}
1334#[doc = "Flexcomm serial communication"]
1335pub use flexcomm0 as flexcomm2;
1336#[doc = "Flexcomm serial communication"]
1337pub struct FLEXCOMM3 {
1338 _marker: PhantomData<*const ()>,
1339}
1340unsafe impl Send for FLEXCOMM3 {}
1341impl FLEXCOMM3 {
1342 #[doc = r"Pointer to the register block"]
1343 pub const PTR: *const flexcomm0::RegisterBlock = 0x4008_9000 as *const _;
1344 #[doc = r"Return the pointer to the register block"]
1345 #[inline(always)]
1346 pub const fn ptr() -> *const flexcomm0::RegisterBlock {
1347 Self::PTR
1348 }
1349}
1350impl Deref for FLEXCOMM3 {
1351 type Target = flexcomm0::RegisterBlock;
1352 #[inline(always)]
1353 fn deref(&self) -> &Self::Target {
1354 unsafe { &*Self::PTR }
1355 }
1356}
1357impl core::fmt::Debug for FLEXCOMM3 {
1358 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1359 f.debug_struct("FLEXCOMM3").finish()
1360 }
1361}
1362#[doc = "Flexcomm serial communication"]
1363pub use flexcomm0 as flexcomm3;
1364#[doc = "Flexcomm serial communication"]
1365pub struct FLEXCOMM4 {
1366 _marker: PhantomData<*const ()>,
1367}
1368unsafe impl Send for FLEXCOMM4 {}
1369impl FLEXCOMM4 {
1370 #[doc = r"Pointer to the register block"]
1371 pub const PTR: *const flexcomm0::RegisterBlock = 0x4008_a000 as *const _;
1372 #[doc = r"Return the pointer to the register block"]
1373 #[inline(always)]
1374 pub const fn ptr() -> *const flexcomm0::RegisterBlock {
1375 Self::PTR
1376 }
1377}
1378impl Deref for FLEXCOMM4 {
1379 type Target = flexcomm0::RegisterBlock;
1380 #[inline(always)]
1381 fn deref(&self) -> &Self::Target {
1382 unsafe { &*Self::PTR }
1383 }
1384}
1385impl core::fmt::Debug for FLEXCOMM4 {
1386 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1387 f.debug_struct("FLEXCOMM4").finish()
1388 }
1389}
1390#[doc = "Flexcomm serial communication"]
1391pub use flexcomm0 as flexcomm4;
1392#[doc = "Flexcomm serial communication"]
1393pub struct FLEXCOMM5 {
1394 _marker: PhantomData<*const ()>,
1395}
1396unsafe impl Send for FLEXCOMM5 {}
1397impl FLEXCOMM5 {
1398 #[doc = r"Pointer to the register block"]
1399 pub const PTR: *const flexcomm0::RegisterBlock = 0x4009_6000 as *const _;
1400 #[doc = r"Return the pointer to the register block"]
1401 #[inline(always)]
1402 pub const fn ptr() -> *const flexcomm0::RegisterBlock {
1403 Self::PTR
1404 }
1405}
1406impl Deref for FLEXCOMM5 {
1407 type Target = flexcomm0::RegisterBlock;
1408 #[inline(always)]
1409 fn deref(&self) -> &Self::Target {
1410 unsafe { &*Self::PTR }
1411 }
1412}
1413impl core::fmt::Debug for FLEXCOMM5 {
1414 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1415 f.debug_struct("FLEXCOMM5").finish()
1416 }
1417}
1418#[doc = "Flexcomm serial communication"]
1419pub use flexcomm0 as flexcomm5;
1420#[doc = "Flexcomm serial communication"]
1421pub struct FLEXCOMM6 {
1422 _marker: PhantomData<*const ()>,
1423}
1424unsafe impl Send for FLEXCOMM6 {}
1425impl FLEXCOMM6 {
1426 #[doc = r"Pointer to the register block"]
1427 pub const PTR: *const flexcomm0::RegisterBlock = 0x4009_7000 as *const _;
1428 #[doc = r"Return the pointer to the register block"]
1429 #[inline(always)]
1430 pub const fn ptr() -> *const flexcomm0::RegisterBlock {
1431 Self::PTR
1432 }
1433}
1434impl Deref for FLEXCOMM6 {
1435 type Target = flexcomm0::RegisterBlock;
1436 #[inline(always)]
1437 fn deref(&self) -> &Self::Target {
1438 unsafe { &*Self::PTR }
1439 }
1440}
1441impl core::fmt::Debug for FLEXCOMM6 {
1442 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1443 f.debug_struct("FLEXCOMM6").finish()
1444 }
1445}
1446#[doc = "Flexcomm serial communication"]
1447pub use flexcomm0 as flexcomm6;
1448#[doc = "Flexcomm serial communication"]
1449pub struct FLEXCOMM7 {
1450 _marker: PhantomData<*const ()>,
1451}
1452unsafe impl Send for FLEXCOMM7 {}
1453impl FLEXCOMM7 {
1454 #[doc = r"Pointer to the register block"]
1455 pub const PTR: *const flexcomm0::RegisterBlock = 0x4009_8000 as *const _;
1456 #[doc = r"Return the pointer to the register block"]
1457 #[inline(always)]
1458 pub const fn ptr() -> *const flexcomm0::RegisterBlock {
1459 Self::PTR
1460 }
1461}
1462impl Deref for FLEXCOMM7 {
1463 type Target = flexcomm0::RegisterBlock;
1464 #[inline(always)]
1465 fn deref(&self) -> &Self::Target {
1466 unsafe { &*Self::PTR }
1467 }
1468}
1469impl core::fmt::Debug for FLEXCOMM7 {
1470 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1471 f.debug_struct("FLEXCOMM7").finish()
1472 }
1473}
1474#[doc = "Flexcomm serial communication"]
1475pub use flexcomm0 as flexcomm7;
1476#[doc = "Flexcomm serial communication"]
1477pub struct FLEXCOMM8 {
1478 _marker: PhantomData<*const ()>,
1479}
1480unsafe impl Send for FLEXCOMM8 {}
1481impl FLEXCOMM8 {
1482 #[doc = r"Pointer to the register block"]
1483 pub const PTR: *const flexcomm0::RegisterBlock = 0x4009_f000 as *const _;
1484 #[doc = r"Return the pointer to the register block"]
1485 #[inline(always)]
1486 pub const fn ptr() -> *const flexcomm0::RegisterBlock {
1487 Self::PTR
1488 }
1489}
1490impl Deref for FLEXCOMM8 {
1491 type Target = flexcomm0::RegisterBlock;
1492 #[inline(always)]
1493 fn deref(&self) -> &Self::Target {
1494 unsafe { &*Self::PTR }
1495 }
1496}
1497impl core::fmt::Debug for FLEXCOMM8 {
1498 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1499 f.debug_struct("FLEXCOMM8").finish()
1500 }
1501}
1502#[doc = "Flexcomm serial communication"]
1503pub use flexcomm0 as flexcomm8;
1504#[doc = "I2C-bus interfaces"]
1505pub struct I2C0 {
1506 _marker: PhantomData<*const ()>,
1507}
1508unsafe impl Send for I2C0 {}
1509impl I2C0 {
1510 #[doc = r"Pointer to the register block"]
1511 pub const PTR: *const i2c0::RegisterBlock = 0x4008_6000 as *const _;
1512 #[doc = r"Return the pointer to the register block"]
1513 #[inline(always)]
1514 pub const fn ptr() -> *const i2c0::RegisterBlock {
1515 Self::PTR
1516 }
1517}
1518impl Deref for I2C0 {
1519 type Target = i2c0::RegisterBlock;
1520 #[inline(always)]
1521 fn deref(&self) -> &Self::Target {
1522 unsafe { &*Self::PTR }
1523 }
1524}
1525impl core::fmt::Debug for I2C0 {
1526 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1527 f.debug_struct("I2C0").finish()
1528 }
1529}
1530#[doc = "I2C-bus interfaces"]
1531pub mod i2c0;
1532#[doc = "I2C-bus interfaces"]
1533pub struct I2C1 {
1534 _marker: PhantomData<*const ()>,
1535}
1536unsafe impl Send for I2C1 {}
1537impl I2C1 {
1538 #[doc = r"Pointer to the register block"]
1539 pub const PTR: *const i2c0::RegisterBlock = 0x4008_7000 as *const _;
1540 #[doc = r"Return the pointer to the register block"]
1541 #[inline(always)]
1542 pub const fn ptr() -> *const i2c0::RegisterBlock {
1543 Self::PTR
1544 }
1545}
1546impl Deref for I2C1 {
1547 type Target = i2c0::RegisterBlock;
1548 #[inline(always)]
1549 fn deref(&self) -> &Self::Target {
1550 unsafe { &*Self::PTR }
1551 }
1552}
1553impl core::fmt::Debug for I2C1 {
1554 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1555 f.debug_struct("I2C1").finish()
1556 }
1557}
1558#[doc = "I2C-bus interfaces"]
1559pub use i2c0 as i2c1;
1560#[doc = "I2C-bus interfaces"]
1561pub struct I2C2 {
1562 _marker: PhantomData<*const ()>,
1563}
1564unsafe impl Send for I2C2 {}
1565impl I2C2 {
1566 #[doc = r"Pointer to the register block"]
1567 pub const PTR: *const i2c0::RegisterBlock = 0x4008_8000 as *const _;
1568 #[doc = r"Return the pointer to the register block"]
1569 #[inline(always)]
1570 pub const fn ptr() -> *const i2c0::RegisterBlock {
1571 Self::PTR
1572 }
1573}
1574impl Deref for I2C2 {
1575 type Target = i2c0::RegisterBlock;
1576 #[inline(always)]
1577 fn deref(&self) -> &Self::Target {
1578 unsafe { &*Self::PTR }
1579 }
1580}
1581impl core::fmt::Debug for I2C2 {
1582 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1583 f.debug_struct("I2C2").finish()
1584 }
1585}
1586#[doc = "I2C-bus interfaces"]
1587pub use i2c0 as i2c2;
1588#[doc = "I2C-bus interfaces"]
1589pub struct I2C3 {
1590 _marker: PhantomData<*const ()>,
1591}
1592unsafe impl Send for I2C3 {}
1593impl I2C3 {
1594 #[doc = r"Pointer to the register block"]
1595 pub const PTR: *const i2c0::RegisterBlock = 0x4008_9000 as *const _;
1596 #[doc = r"Return the pointer to the register block"]
1597 #[inline(always)]
1598 pub const fn ptr() -> *const i2c0::RegisterBlock {
1599 Self::PTR
1600 }
1601}
1602impl Deref for I2C3 {
1603 type Target = i2c0::RegisterBlock;
1604 #[inline(always)]
1605 fn deref(&self) -> &Self::Target {
1606 unsafe { &*Self::PTR }
1607 }
1608}
1609impl core::fmt::Debug for I2C3 {
1610 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1611 f.debug_struct("I2C3").finish()
1612 }
1613}
1614#[doc = "I2C-bus interfaces"]
1615pub use i2c0 as i2c3;
1616#[doc = "I2C-bus interfaces"]
1617pub struct I2C4 {
1618 _marker: PhantomData<*const ()>,
1619}
1620unsafe impl Send for I2C4 {}
1621impl I2C4 {
1622 #[doc = r"Pointer to the register block"]
1623 pub const PTR: *const i2c0::RegisterBlock = 0x4008_a000 as *const _;
1624 #[doc = r"Return the pointer to the register block"]
1625 #[inline(always)]
1626 pub const fn ptr() -> *const i2c0::RegisterBlock {
1627 Self::PTR
1628 }
1629}
1630impl Deref for I2C4 {
1631 type Target = i2c0::RegisterBlock;
1632 #[inline(always)]
1633 fn deref(&self) -> &Self::Target {
1634 unsafe { &*Self::PTR }
1635 }
1636}
1637impl core::fmt::Debug for I2C4 {
1638 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1639 f.debug_struct("I2C4").finish()
1640 }
1641}
1642#[doc = "I2C-bus interfaces"]
1643pub use i2c0 as i2c4;
1644#[doc = "I2C-bus interfaces"]
1645pub struct I2C5 {
1646 _marker: PhantomData<*const ()>,
1647}
1648unsafe impl Send for I2C5 {}
1649impl I2C5 {
1650 #[doc = r"Pointer to the register block"]
1651 pub const PTR: *const i2c0::RegisterBlock = 0x4009_6000 as *const _;
1652 #[doc = r"Return the pointer to the register block"]
1653 #[inline(always)]
1654 pub const fn ptr() -> *const i2c0::RegisterBlock {
1655 Self::PTR
1656 }
1657}
1658impl Deref for I2C5 {
1659 type Target = i2c0::RegisterBlock;
1660 #[inline(always)]
1661 fn deref(&self) -> &Self::Target {
1662 unsafe { &*Self::PTR }
1663 }
1664}
1665impl core::fmt::Debug for I2C5 {
1666 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1667 f.debug_struct("I2C5").finish()
1668 }
1669}
1670#[doc = "I2C-bus interfaces"]
1671pub use i2c0 as i2c5;
1672#[doc = "I2C-bus interfaces"]
1673pub struct I2C6 {
1674 _marker: PhantomData<*const ()>,
1675}
1676unsafe impl Send for I2C6 {}
1677impl I2C6 {
1678 #[doc = r"Pointer to the register block"]
1679 pub const PTR: *const i2c0::RegisterBlock = 0x4009_7000 as *const _;
1680 #[doc = r"Return the pointer to the register block"]
1681 #[inline(always)]
1682 pub const fn ptr() -> *const i2c0::RegisterBlock {
1683 Self::PTR
1684 }
1685}
1686impl Deref for I2C6 {
1687 type Target = i2c0::RegisterBlock;
1688 #[inline(always)]
1689 fn deref(&self) -> &Self::Target {
1690 unsafe { &*Self::PTR }
1691 }
1692}
1693impl core::fmt::Debug for I2C6 {
1694 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1695 f.debug_struct("I2C6").finish()
1696 }
1697}
1698#[doc = "I2C-bus interfaces"]
1699pub use i2c0 as i2c6;
1700#[doc = "I2C-bus interfaces"]
1701pub struct I2C7 {
1702 _marker: PhantomData<*const ()>,
1703}
1704unsafe impl Send for I2C7 {}
1705impl I2C7 {
1706 #[doc = r"Pointer to the register block"]
1707 pub const PTR: *const i2c0::RegisterBlock = 0x4009_8000 as *const _;
1708 #[doc = r"Return the pointer to the register block"]
1709 #[inline(always)]
1710 pub const fn ptr() -> *const i2c0::RegisterBlock {
1711 Self::PTR
1712 }
1713}
1714impl Deref for I2C7 {
1715 type Target = i2c0::RegisterBlock;
1716 #[inline(always)]
1717 fn deref(&self) -> &Self::Target {
1718 unsafe { &*Self::PTR }
1719 }
1720}
1721impl core::fmt::Debug for I2C7 {
1722 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1723 f.debug_struct("I2C7").finish()
1724 }
1725}
1726#[doc = "I2C-bus interfaces"]
1727pub use i2c0 as i2c7;
1728#[doc = "I2S interface"]
1729pub struct I2S0 {
1730 _marker: PhantomData<*const ()>,
1731}
1732unsafe impl Send for I2S0 {}
1733impl I2S0 {
1734 #[doc = r"Pointer to the register block"]
1735 pub const PTR: *const i2s0::RegisterBlock = 0x4008_6000 as *const _;
1736 #[doc = r"Return the pointer to the register block"]
1737 #[inline(always)]
1738 pub const fn ptr() -> *const i2s0::RegisterBlock {
1739 Self::PTR
1740 }
1741}
1742impl Deref for I2S0 {
1743 type Target = i2s0::RegisterBlock;
1744 #[inline(always)]
1745 fn deref(&self) -> &Self::Target {
1746 unsafe { &*Self::PTR }
1747 }
1748}
1749impl core::fmt::Debug for I2S0 {
1750 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1751 f.debug_struct("I2S0").finish()
1752 }
1753}
1754#[doc = "I2S interface"]
1755pub mod i2s0;
1756#[doc = "I2S interface"]
1757pub struct I2S1 {
1758 _marker: PhantomData<*const ()>,
1759}
1760unsafe impl Send for I2S1 {}
1761impl I2S1 {
1762 #[doc = r"Pointer to the register block"]
1763 pub const PTR: *const i2s0::RegisterBlock = 0x4008_7000 as *const _;
1764 #[doc = r"Return the pointer to the register block"]
1765 #[inline(always)]
1766 pub const fn ptr() -> *const i2s0::RegisterBlock {
1767 Self::PTR
1768 }
1769}
1770impl Deref for I2S1 {
1771 type Target = i2s0::RegisterBlock;
1772 #[inline(always)]
1773 fn deref(&self) -> &Self::Target {
1774 unsafe { &*Self::PTR }
1775 }
1776}
1777impl core::fmt::Debug for I2S1 {
1778 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1779 f.debug_struct("I2S1").finish()
1780 }
1781}
1782#[doc = "I2S interface"]
1783pub use i2s0 as i2s1;
1784#[doc = "I2S interface"]
1785pub struct I2S2 {
1786 _marker: PhantomData<*const ()>,
1787}
1788unsafe impl Send for I2S2 {}
1789impl I2S2 {
1790 #[doc = r"Pointer to the register block"]
1791 pub const PTR: *const i2s0::RegisterBlock = 0x4008_8000 as *const _;
1792 #[doc = r"Return the pointer to the register block"]
1793 #[inline(always)]
1794 pub const fn ptr() -> *const i2s0::RegisterBlock {
1795 Self::PTR
1796 }
1797}
1798impl Deref for I2S2 {
1799 type Target = i2s0::RegisterBlock;
1800 #[inline(always)]
1801 fn deref(&self) -> &Self::Target {
1802 unsafe { &*Self::PTR }
1803 }
1804}
1805impl core::fmt::Debug for I2S2 {
1806 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1807 f.debug_struct("I2S2").finish()
1808 }
1809}
1810#[doc = "I2S interface"]
1811pub use i2s0 as i2s2;
1812#[doc = "I2S interface"]
1813pub struct I2S3 {
1814 _marker: PhantomData<*const ()>,
1815}
1816unsafe impl Send for I2S3 {}
1817impl I2S3 {
1818 #[doc = r"Pointer to the register block"]
1819 pub const PTR: *const i2s0::RegisterBlock = 0x4008_9000 as *const _;
1820 #[doc = r"Return the pointer to the register block"]
1821 #[inline(always)]
1822 pub const fn ptr() -> *const i2s0::RegisterBlock {
1823 Self::PTR
1824 }
1825}
1826impl Deref for I2S3 {
1827 type Target = i2s0::RegisterBlock;
1828 #[inline(always)]
1829 fn deref(&self) -> &Self::Target {
1830 unsafe { &*Self::PTR }
1831 }
1832}
1833impl core::fmt::Debug for I2S3 {
1834 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1835 f.debug_struct("I2S3").finish()
1836 }
1837}
1838#[doc = "I2S interface"]
1839pub use i2s0 as i2s3;
1840#[doc = "I2S interface"]
1841pub struct I2S4 {
1842 _marker: PhantomData<*const ()>,
1843}
1844unsafe impl Send for I2S4 {}
1845impl I2S4 {
1846 #[doc = r"Pointer to the register block"]
1847 pub const PTR: *const i2s0::RegisterBlock = 0x4008_a000 as *const _;
1848 #[doc = r"Return the pointer to the register block"]
1849 #[inline(always)]
1850 pub const fn ptr() -> *const i2s0::RegisterBlock {
1851 Self::PTR
1852 }
1853}
1854impl Deref for I2S4 {
1855 type Target = i2s0::RegisterBlock;
1856 #[inline(always)]
1857 fn deref(&self) -> &Self::Target {
1858 unsafe { &*Self::PTR }
1859 }
1860}
1861impl core::fmt::Debug for I2S4 {
1862 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1863 f.debug_struct("I2S4").finish()
1864 }
1865}
1866#[doc = "I2S interface"]
1867pub use i2s0 as i2s4;
1868#[doc = "I2S interface"]
1869pub struct I2S5 {
1870 _marker: PhantomData<*const ()>,
1871}
1872unsafe impl Send for I2S5 {}
1873impl I2S5 {
1874 #[doc = r"Pointer to the register block"]
1875 pub const PTR: *const i2s0::RegisterBlock = 0x4009_6000 as *const _;
1876 #[doc = r"Return the pointer to the register block"]
1877 #[inline(always)]
1878 pub const fn ptr() -> *const i2s0::RegisterBlock {
1879 Self::PTR
1880 }
1881}
1882impl Deref for I2S5 {
1883 type Target = i2s0::RegisterBlock;
1884 #[inline(always)]
1885 fn deref(&self) -> &Self::Target {
1886 unsafe { &*Self::PTR }
1887 }
1888}
1889impl core::fmt::Debug for I2S5 {
1890 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1891 f.debug_struct("I2S5").finish()
1892 }
1893}
1894#[doc = "I2S interface"]
1895pub use i2s0 as i2s5;
1896#[doc = "I2S interface"]
1897pub struct I2S6 {
1898 _marker: PhantomData<*const ()>,
1899}
1900unsafe impl Send for I2S6 {}
1901impl I2S6 {
1902 #[doc = r"Pointer to the register block"]
1903 pub const PTR: *const i2s0::RegisterBlock = 0x4009_7000 as *const _;
1904 #[doc = r"Return the pointer to the register block"]
1905 #[inline(always)]
1906 pub const fn ptr() -> *const i2s0::RegisterBlock {
1907 Self::PTR
1908 }
1909}
1910impl Deref for I2S6 {
1911 type Target = i2s0::RegisterBlock;
1912 #[inline(always)]
1913 fn deref(&self) -> &Self::Target {
1914 unsafe { &*Self::PTR }
1915 }
1916}
1917impl core::fmt::Debug for I2S6 {
1918 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1919 f.debug_struct("I2S6").finish()
1920 }
1921}
1922#[doc = "I2S interface"]
1923pub use i2s0 as i2s6;
1924#[doc = "I2S interface"]
1925pub struct I2S7 {
1926 _marker: PhantomData<*const ()>,
1927}
1928unsafe impl Send for I2S7 {}
1929impl I2S7 {
1930 #[doc = r"Pointer to the register block"]
1931 pub const PTR: *const i2s0::RegisterBlock = 0x4009_8000 as *const _;
1932 #[doc = r"Return the pointer to the register block"]
1933 #[inline(always)]
1934 pub const fn ptr() -> *const i2s0::RegisterBlock {
1935 Self::PTR
1936 }
1937}
1938impl Deref for I2S7 {
1939 type Target = i2s0::RegisterBlock;
1940 #[inline(always)]
1941 fn deref(&self) -> &Self::Target {
1942 unsafe { &*Self::PTR }
1943 }
1944}
1945impl core::fmt::Debug for I2S7 {
1946 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1947 f.debug_struct("I2S7").finish()
1948 }
1949}
1950#[doc = "I2S interface"]
1951pub use i2s0 as i2s7;
1952#[doc = "Serial Peripheral Interfaces (SPI)"]
1953pub struct SPI0 {
1954 _marker: PhantomData<*const ()>,
1955}
1956unsafe impl Send for SPI0 {}
1957impl SPI0 {
1958 #[doc = r"Pointer to the register block"]
1959 pub const PTR: *const spi0::RegisterBlock = 0x4008_6000 as *const _;
1960 #[doc = r"Return the pointer to the register block"]
1961 #[inline(always)]
1962 pub const fn ptr() -> *const spi0::RegisterBlock {
1963 Self::PTR
1964 }
1965}
1966impl Deref for SPI0 {
1967 type Target = spi0::RegisterBlock;
1968 #[inline(always)]
1969 fn deref(&self) -> &Self::Target {
1970 unsafe { &*Self::PTR }
1971 }
1972}
1973impl core::fmt::Debug for SPI0 {
1974 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1975 f.debug_struct("SPI0").finish()
1976 }
1977}
1978#[doc = "Serial Peripheral Interfaces (SPI)"]
1979pub mod spi0;
1980#[doc = "Serial Peripheral Interfaces (SPI)"]
1981pub struct SPI1 {
1982 _marker: PhantomData<*const ()>,
1983}
1984unsafe impl Send for SPI1 {}
1985impl SPI1 {
1986 #[doc = r"Pointer to the register block"]
1987 pub const PTR: *const spi0::RegisterBlock = 0x4008_7000 as *const _;
1988 #[doc = r"Return the pointer to the register block"]
1989 #[inline(always)]
1990 pub const fn ptr() -> *const spi0::RegisterBlock {
1991 Self::PTR
1992 }
1993}
1994impl Deref for SPI1 {
1995 type Target = spi0::RegisterBlock;
1996 #[inline(always)]
1997 fn deref(&self) -> &Self::Target {
1998 unsafe { &*Self::PTR }
1999 }
2000}
2001impl core::fmt::Debug for SPI1 {
2002 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2003 f.debug_struct("SPI1").finish()
2004 }
2005}
2006#[doc = "Serial Peripheral Interfaces (SPI)"]
2007pub use spi0 as spi1;
2008#[doc = "Serial Peripheral Interfaces (SPI)"]
2009pub struct SPI2 {
2010 _marker: PhantomData<*const ()>,
2011}
2012unsafe impl Send for SPI2 {}
2013impl SPI2 {
2014 #[doc = r"Pointer to the register block"]
2015 pub const PTR: *const spi0::RegisterBlock = 0x4008_8000 as *const _;
2016 #[doc = r"Return the pointer to the register block"]
2017 #[inline(always)]
2018 pub const fn ptr() -> *const spi0::RegisterBlock {
2019 Self::PTR
2020 }
2021}
2022impl Deref for SPI2 {
2023 type Target = spi0::RegisterBlock;
2024 #[inline(always)]
2025 fn deref(&self) -> &Self::Target {
2026 unsafe { &*Self::PTR }
2027 }
2028}
2029impl core::fmt::Debug for SPI2 {
2030 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2031 f.debug_struct("SPI2").finish()
2032 }
2033}
2034#[doc = "Serial Peripheral Interfaces (SPI)"]
2035pub use spi0 as spi2;
2036#[doc = "Serial Peripheral Interfaces (SPI)"]
2037pub struct SPI3 {
2038 _marker: PhantomData<*const ()>,
2039}
2040unsafe impl Send for SPI3 {}
2041impl SPI3 {
2042 #[doc = r"Pointer to the register block"]
2043 pub const PTR: *const spi0::RegisterBlock = 0x4008_9000 as *const _;
2044 #[doc = r"Return the pointer to the register block"]
2045 #[inline(always)]
2046 pub const fn ptr() -> *const spi0::RegisterBlock {
2047 Self::PTR
2048 }
2049}
2050impl Deref for SPI3 {
2051 type Target = spi0::RegisterBlock;
2052 #[inline(always)]
2053 fn deref(&self) -> &Self::Target {
2054 unsafe { &*Self::PTR }
2055 }
2056}
2057impl core::fmt::Debug for SPI3 {
2058 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2059 f.debug_struct("SPI3").finish()
2060 }
2061}
2062#[doc = "Serial Peripheral Interfaces (SPI)"]
2063pub use spi0 as spi3;
2064#[doc = "Serial Peripheral Interfaces (SPI)"]
2065pub struct SPI4 {
2066 _marker: PhantomData<*const ()>,
2067}
2068unsafe impl Send for SPI4 {}
2069impl SPI4 {
2070 #[doc = r"Pointer to the register block"]
2071 pub const PTR: *const spi0::RegisterBlock = 0x4008_a000 as *const _;
2072 #[doc = r"Return the pointer to the register block"]
2073 #[inline(always)]
2074 pub const fn ptr() -> *const spi0::RegisterBlock {
2075 Self::PTR
2076 }
2077}
2078impl Deref for SPI4 {
2079 type Target = spi0::RegisterBlock;
2080 #[inline(always)]
2081 fn deref(&self) -> &Self::Target {
2082 unsafe { &*Self::PTR }
2083 }
2084}
2085impl core::fmt::Debug for SPI4 {
2086 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2087 f.debug_struct("SPI4").finish()
2088 }
2089}
2090#[doc = "Serial Peripheral Interfaces (SPI)"]
2091pub use spi0 as spi4;
2092#[doc = "Serial Peripheral Interfaces (SPI)"]
2093pub struct SPI5 {
2094 _marker: PhantomData<*const ()>,
2095}
2096unsafe impl Send for SPI5 {}
2097impl SPI5 {
2098 #[doc = r"Pointer to the register block"]
2099 pub const PTR: *const spi0::RegisterBlock = 0x4009_6000 as *const _;
2100 #[doc = r"Return the pointer to the register block"]
2101 #[inline(always)]
2102 pub const fn ptr() -> *const spi0::RegisterBlock {
2103 Self::PTR
2104 }
2105}
2106impl Deref for SPI5 {
2107 type Target = spi0::RegisterBlock;
2108 #[inline(always)]
2109 fn deref(&self) -> &Self::Target {
2110 unsafe { &*Self::PTR }
2111 }
2112}
2113impl core::fmt::Debug for SPI5 {
2114 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2115 f.debug_struct("SPI5").finish()
2116 }
2117}
2118#[doc = "Serial Peripheral Interfaces (SPI)"]
2119pub use spi0 as spi5;
2120#[doc = "Serial Peripheral Interfaces (SPI)"]
2121pub struct SPI6 {
2122 _marker: PhantomData<*const ()>,
2123}
2124unsafe impl Send for SPI6 {}
2125impl SPI6 {
2126 #[doc = r"Pointer to the register block"]
2127 pub const PTR: *const spi0::RegisterBlock = 0x4009_7000 as *const _;
2128 #[doc = r"Return the pointer to the register block"]
2129 #[inline(always)]
2130 pub const fn ptr() -> *const spi0::RegisterBlock {
2131 Self::PTR
2132 }
2133}
2134impl Deref for SPI6 {
2135 type Target = spi0::RegisterBlock;
2136 #[inline(always)]
2137 fn deref(&self) -> &Self::Target {
2138 unsafe { &*Self::PTR }
2139 }
2140}
2141impl core::fmt::Debug for SPI6 {
2142 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2143 f.debug_struct("SPI6").finish()
2144 }
2145}
2146#[doc = "Serial Peripheral Interfaces (SPI)"]
2147pub use spi0 as spi6;
2148#[doc = "Serial Peripheral Interfaces (SPI)"]
2149pub struct SPI7 {
2150 _marker: PhantomData<*const ()>,
2151}
2152unsafe impl Send for SPI7 {}
2153impl SPI7 {
2154 #[doc = r"Pointer to the register block"]
2155 pub const PTR: *const spi0::RegisterBlock = 0x4009_8000 as *const _;
2156 #[doc = r"Return the pointer to the register block"]
2157 #[inline(always)]
2158 pub const fn ptr() -> *const spi0::RegisterBlock {
2159 Self::PTR
2160 }
2161}
2162impl Deref for SPI7 {
2163 type Target = spi0::RegisterBlock;
2164 #[inline(always)]
2165 fn deref(&self) -> &Self::Target {
2166 unsafe { &*Self::PTR }
2167 }
2168}
2169impl core::fmt::Debug for SPI7 {
2170 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2171 f.debug_struct("SPI7").finish()
2172 }
2173}
2174#[doc = "Serial Peripheral Interfaces (SPI)"]
2175pub use spi0 as spi7;
2176#[doc = "Serial Peripheral Interfaces (SPI)"]
2177pub struct SPI8 {
2178 _marker: PhantomData<*const ()>,
2179}
2180unsafe impl Send for SPI8 {}
2181impl SPI8 {
2182 #[doc = r"Pointer to the register block"]
2183 pub const PTR: *const spi0::RegisterBlock = 0x4009_f000 as *const _;
2184 #[doc = r"Return the pointer to the register block"]
2185 #[inline(always)]
2186 pub const fn ptr() -> *const spi0::RegisterBlock {
2187 Self::PTR
2188 }
2189}
2190impl Deref for SPI8 {
2191 type Target = spi0::RegisterBlock;
2192 #[inline(always)]
2193 fn deref(&self) -> &Self::Target {
2194 unsafe { &*Self::PTR }
2195 }
2196}
2197impl core::fmt::Debug for SPI8 {
2198 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2199 f.debug_struct("SPI8").finish()
2200 }
2201}
2202#[doc = "Serial Peripheral Interfaces (SPI)"]
2203pub use spi0 as spi8;
2204#[doc = "USARTs"]
2205pub struct USART0 {
2206 _marker: PhantomData<*const ()>,
2207}
2208unsafe impl Send for USART0 {}
2209impl USART0 {
2210 #[doc = r"Pointer to the register block"]
2211 pub const PTR: *const usart0::RegisterBlock = 0x4008_6000 as *const _;
2212 #[doc = r"Return the pointer to the register block"]
2213 #[inline(always)]
2214 pub const fn ptr() -> *const usart0::RegisterBlock {
2215 Self::PTR
2216 }
2217}
2218impl Deref for USART0 {
2219 type Target = usart0::RegisterBlock;
2220 #[inline(always)]
2221 fn deref(&self) -> &Self::Target {
2222 unsafe { &*Self::PTR }
2223 }
2224}
2225impl core::fmt::Debug for USART0 {
2226 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2227 f.debug_struct("USART0").finish()
2228 }
2229}
2230#[doc = "USARTs"]
2231pub mod usart0;
2232#[doc = "USARTs"]
2233pub struct USART1 {
2234 _marker: PhantomData<*const ()>,
2235}
2236unsafe impl Send for USART1 {}
2237impl USART1 {
2238 #[doc = r"Pointer to the register block"]
2239 pub const PTR: *const usart0::RegisterBlock = 0x4008_7000 as *const _;
2240 #[doc = r"Return the pointer to the register block"]
2241 #[inline(always)]
2242 pub const fn ptr() -> *const usart0::RegisterBlock {
2243 Self::PTR
2244 }
2245}
2246impl Deref for USART1 {
2247 type Target = usart0::RegisterBlock;
2248 #[inline(always)]
2249 fn deref(&self) -> &Self::Target {
2250 unsafe { &*Self::PTR }
2251 }
2252}
2253impl core::fmt::Debug for USART1 {
2254 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2255 f.debug_struct("USART1").finish()
2256 }
2257}
2258#[doc = "USARTs"]
2259pub use usart0 as usart1;
2260#[doc = "USARTs"]
2261pub struct USART2 {
2262 _marker: PhantomData<*const ()>,
2263}
2264unsafe impl Send for USART2 {}
2265impl USART2 {
2266 #[doc = r"Pointer to the register block"]
2267 pub const PTR: *const usart0::RegisterBlock = 0x4008_8000 as *const _;
2268 #[doc = r"Return the pointer to the register block"]
2269 #[inline(always)]
2270 pub const fn ptr() -> *const usart0::RegisterBlock {
2271 Self::PTR
2272 }
2273}
2274impl Deref for USART2 {
2275 type Target = usart0::RegisterBlock;
2276 #[inline(always)]
2277 fn deref(&self) -> &Self::Target {
2278 unsafe { &*Self::PTR }
2279 }
2280}
2281impl core::fmt::Debug for USART2 {
2282 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2283 f.debug_struct("USART2").finish()
2284 }
2285}
2286#[doc = "USARTs"]
2287pub use usart0 as usart2;
2288#[doc = "USARTs"]
2289pub struct USART3 {
2290 _marker: PhantomData<*const ()>,
2291}
2292unsafe impl Send for USART3 {}
2293impl USART3 {
2294 #[doc = r"Pointer to the register block"]
2295 pub const PTR: *const usart0::RegisterBlock = 0x4008_9000 as *const _;
2296 #[doc = r"Return the pointer to the register block"]
2297 #[inline(always)]
2298 pub const fn ptr() -> *const usart0::RegisterBlock {
2299 Self::PTR
2300 }
2301}
2302impl Deref for USART3 {
2303 type Target = usart0::RegisterBlock;
2304 #[inline(always)]
2305 fn deref(&self) -> &Self::Target {
2306 unsafe { &*Self::PTR }
2307 }
2308}
2309impl core::fmt::Debug for USART3 {
2310 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2311 f.debug_struct("USART3").finish()
2312 }
2313}
2314#[doc = "USARTs"]
2315pub use usart0 as usart3;
2316#[doc = "USARTs"]
2317pub struct USART4 {
2318 _marker: PhantomData<*const ()>,
2319}
2320unsafe impl Send for USART4 {}
2321impl USART4 {
2322 #[doc = r"Pointer to the register block"]
2323 pub const PTR: *const usart0::RegisterBlock = 0x4008_a000 as *const _;
2324 #[doc = r"Return the pointer to the register block"]
2325 #[inline(always)]
2326 pub const fn ptr() -> *const usart0::RegisterBlock {
2327 Self::PTR
2328 }
2329}
2330impl Deref for USART4 {
2331 type Target = usart0::RegisterBlock;
2332 #[inline(always)]
2333 fn deref(&self) -> &Self::Target {
2334 unsafe { &*Self::PTR }
2335 }
2336}
2337impl core::fmt::Debug for USART4 {
2338 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2339 f.debug_struct("USART4").finish()
2340 }
2341}
2342#[doc = "USARTs"]
2343pub use usart0 as usart4;
2344#[doc = "USARTs"]
2345pub struct USART5 {
2346 _marker: PhantomData<*const ()>,
2347}
2348unsafe impl Send for USART5 {}
2349impl USART5 {
2350 #[doc = r"Pointer to the register block"]
2351 pub const PTR: *const usart0::RegisterBlock = 0x4009_6000 as *const _;
2352 #[doc = r"Return the pointer to the register block"]
2353 #[inline(always)]
2354 pub const fn ptr() -> *const usart0::RegisterBlock {
2355 Self::PTR
2356 }
2357}
2358impl Deref for USART5 {
2359 type Target = usart0::RegisterBlock;
2360 #[inline(always)]
2361 fn deref(&self) -> &Self::Target {
2362 unsafe { &*Self::PTR }
2363 }
2364}
2365impl core::fmt::Debug for USART5 {
2366 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2367 f.debug_struct("USART5").finish()
2368 }
2369}
2370#[doc = "USARTs"]
2371pub use usart0 as usart5;
2372#[doc = "USARTs"]
2373pub struct USART6 {
2374 _marker: PhantomData<*const ()>,
2375}
2376unsafe impl Send for USART6 {}
2377impl USART6 {
2378 #[doc = r"Pointer to the register block"]
2379 pub const PTR: *const usart0::RegisterBlock = 0x4009_7000 as *const _;
2380 #[doc = r"Return the pointer to the register block"]
2381 #[inline(always)]
2382 pub const fn ptr() -> *const usart0::RegisterBlock {
2383 Self::PTR
2384 }
2385}
2386impl Deref for USART6 {
2387 type Target = usart0::RegisterBlock;
2388 #[inline(always)]
2389 fn deref(&self) -> &Self::Target {
2390 unsafe { &*Self::PTR }
2391 }
2392}
2393impl core::fmt::Debug for USART6 {
2394 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2395 f.debug_struct("USART6").finish()
2396 }
2397}
2398#[doc = "USARTs"]
2399pub use usart0 as usart6;
2400#[doc = "USARTs"]
2401pub struct USART7 {
2402 _marker: PhantomData<*const ()>,
2403}
2404unsafe impl Send for USART7 {}
2405impl USART7 {
2406 #[doc = r"Pointer to the register block"]
2407 pub const PTR: *const usart0::RegisterBlock = 0x4009_8000 as *const _;
2408 #[doc = r"Return the pointer to the register block"]
2409 #[inline(always)]
2410 pub const fn ptr() -> *const usart0::RegisterBlock {
2411 Self::PTR
2412 }
2413}
2414impl Deref for USART7 {
2415 type Target = usart0::RegisterBlock;
2416 #[inline(always)]
2417 fn deref(&self) -> &Self::Target {
2418 unsafe { &*Self::PTR }
2419 }
2420}
2421impl core::fmt::Debug for USART7 {
2422 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2423 f.debug_struct("USART7").finish()
2424 }
2425}
2426#[doc = "USARTs"]
2427pub use usart0 as usart7;
2428#[doc = "Mailbox"]
2429pub struct MAILBOX {
2430 _marker: PhantomData<*const ()>,
2431}
2432unsafe impl Send for MAILBOX {}
2433impl MAILBOX {
2434 #[doc = r"Pointer to the register block"]
2435 pub const PTR: *const mailbox::RegisterBlock = 0x4008_b000 as *const _;
2436 #[doc = r"Return the pointer to the register block"]
2437 #[inline(always)]
2438 pub const fn ptr() -> *const mailbox::RegisterBlock {
2439 Self::PTR
2440 }
2441}
2442impl Deref for MAILBOX {
2443 type Target = mailbox::RegisterBlock;
2444 #[inline(always)]
2445 fn deref(&self) -> &Self::Target {
2446 unsafe { &*Self::PTR }
2447 }
2448}
2449impl core::fmt::Debug for MAILBOX {
2450 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2451 f.debug_struct("MAILBOX").finish()
2452 }
2453}
2454#[doc = "Mailbox"]
2455pub mod mailbox;
2456#[doc = "General Purpose I/O (GPIO)"]
2457pub struct GPIO {
2458 _marker: PhantomData<*const ()>,
2459}
2460unsafe impl Send for GPIO {}
2461impl GPIO {
2462 #[doc = r"Pointer to the register block"]
2463 pub const PTR: *const gpio::RegisterBlock = 0x4008_c000 as *const _;
2464 #[doc = r"Return the pointer to the register block"]
2465 #[inline(always)]
2466 pub const fn ptr() -> *const gpio::RegisterBlock {
2467 Self::PTR
2468 }
2469}
2470impl Deref for GPIO {
2471 type Target = gpio::RegisterBlock;
2472 #[inline(always)]
2473 fn deref(&self) -> &Self::Target {
2474 unsafe { &*Self::PTR }
2475 }
2476}
2477impl core::fmt::Debug for GPIO {
2478 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2479 f.debug_struct("GPIO").finish()
2480 }
2481}
2482#[doc = "General Purpose I/O (GPIO)"]
2483pub mod gpio;
2484#[doc = "USB1 High-speed Device Controller"]
2485pub struct USB1 {
2486 _marker: PhantomData<*const ()>,
2487}
2488unsafe impl Send for USB1 {}
2489impl USB1 {
2490 #[doc = r"Pointer to the register block"]
2491 pub const PTR: *const usb1::RegisterBlock = 0x4009_4000 as *const _;
2492 #[doc = r"Return the pointer to the register block"]
2493 #[inline(always)]
2494 pub const fn ptr() -> *const usb1::RegisterBlock {
2495 Self::PTR
2496 }
2497}
2498impl Deref for USB1 {
2499 type Target = usb1::RegisterBlock;
2500 #[inline(always)]
2501 fn deref(&self) -> &Self::Target {
2502 unsafe { &*Self::PTR }
2503 }
2504}
2505impl core::fmt::Debug for USB1 {
2506 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2507 f.debug_struct("USB1").finish()
2508 }
2509}
2510#[doc = "USB1 High-speed Device Controller"]
2511pub mod usb1;
2512#[doc = "CRC engine"]
2513pub struct CRC_ENGINE {
2514 _marker: PhantomData<*const ()>,
2515}
2516unsafe impl Send for CRC_ENGINE {}
2517impl CRC_ENGINE {
2518 #[doc = r"Pointer to the register block"]
2519 pub const PTR: *const crc_engine::RegisterBlock = 0x4009_5000 as *const _;
2520 #[doc = r"Return the pointer to the register block"]
2521 #[inline(always)]
2522 pub const fn ptr() -> *const crc_engine::RegisterBlock {
2523 Self::PTR
2524 }
2525}
2526impl Deref for CRC_ENGINE {
2527 type Target = crc_engine::RegisterBlock;
2528 #[inline(always)]
2529 fn deref(&self) -> &Self::Target {
2530 unsafe { &*Self::PTR }
2531 }
2532}
2533impl core::fmt::Debug for CRC_ENGINE {
2534 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2535 f.debug_struct("CRC_ENGINE").finish()
2536 }
2537}
2538#[doc = "CRC engine"]
2539pub mod crc_engine;
2540#[doc = "SDMMC"]
2541pub struct SDIF {
2542 _marker: PhantomData<*const ()>,
2543}
2544unsafe impl Send for SDIF {}
2545impl SDIF {
2546 #[doc = r"Pointer to the register block"]
2547 pub const PTR: *const sdif::RegisterBlock = 0x4009_b000 as *const _;
2548 #[doc = r"Return the pointer to the register block"]
2549 #[inline(always)]
2550 pub const fn ptr() -> *const sdif::RegisterBlock {
2551 Self::PTR
2552 }
2553}
2554impl Deref for SDIF {
2555 type Target = sdif::RegisterBlock;
2556 #[inline(always)]
2557 fn deref(&self) -> &Self::Target {
2558 unsafe { &*Self::PTR }
2559 }
2560}
2561impl core::fmt::Debug for SDIF {
2562 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2563 f.debug_struct("SDIF").finish()
2564 }
2565}
2566#[doc = "SDMMC"]
2567pub mod sdif;
2568#[doc = "MCU Debugger Mailbox"]
2569pub struct DBGMAILBOX {
2570 _marker: PhantomData<*const ()>,
2571}
2572unsafe impl Send for DBGMAILBOX {}
2573impl DBGMAILBOX {
2574 #[doc = r"Pointer to the register block"]
2575 pub const PTR: *const dbgmailbox::RegisterBlock = 0x4009_c000 as *const _;
2576 #[doc = r"Return the pointer to the register block"]
2577 #[inline(always)]
2578 pub const fn ptr() -> *const dbgmailbox::RegisterBlock {
2579 Self::PTR
2580 }
2581}
2582impl Deref for DBGMAILBOX {
2583 type Target = dbgmailbox::RegisterBlock;
2584 #[inline(always)]
2585 fn deref(&self) -> &Self::Target {
2586 unsafe { &*Self::PTR }
2587 }
2588}
2589impl core::fmt::Debug for DBGMAILBOX {
2590 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2591 f.debug_struct("DBGMAILBOX").finish()
2592 }
2593}
2594#[doc = "MCU Debugger Mailbox"]
2595pub mod dbgmailbox;
2596#[doc = "ADC"]
2597pub struct ADC0 {
2598 _marker: PhantomData<*const ()>,
2599}
2600unsafe impl Send for ADC0 {}
2601impl ADC0 {
2602 #[doc = r"Pointer to the register block"]
2603 pub const PTR: *const adc0::RegisterBlock = 0x400a_0000 as *const _;
2604 #[doc = r"Return the pointer to the register block"]
2605 #[inline(always)]
2606 pub const fn ptr() -> *const adc0::RegisterBlock {
2607 Self::PTR
2608 }
2609}
2610impl Deref for ADC0 {
2611 type Target = adc0::RegisterBlock;
2612 #[inline(always)]
2613 fn deref(&self) -> &Self::Target {
2614 unsafe { &*Self::PTR }
2615 }
2616}
2617impl core::fmt::Debug for ADC0 {
2618 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2619 f.debug_struct("ADC0").finish()
2620 }
2621}
2622#[doc = "ADC"]
2623pub mod adc0;
2624#[doc = "USB0 Full-speed Host controller"]
2625pub struct USBFSH {
2626 _marker: PhantomData<*const ()>,
2627}
2628unsafe impl Send for USBFSH {}
2629impl USBFSH {
2630 #[doc = r"Pointer to the register block"]
2631 pub const PTR: *const usbfsh::RegisterBlock = 0x400a_2000 as *const _;
2632 #[doc = r"Return the pointer to the register block"]
2633 #[inline(always)]
2634 pub const fn ptr() -> *const usbfsh::RegisterBlock {
2635 Self::PTR
2636 }
2637}
2638impl Deref for USBFSH {
2639 type Target = usbfsh::RegisterBlock;
2640 #[inline(always)]
2641 fn deref(&self) -> &Self::Target {
2642 unsafe { &*Self::PTR }
2643 }
2644}
2645impl core::fmt::Debug for USBFSH {
2646 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2647 f.debug_struct("USBFSH").finish()
2648 }
2649}
2650#[doc = "USB0 Full-speed Host controller"]
2651pub mod usbfsh;
2652#[doc = "USB1 High-speed Host Controller"]
2653pub struct USBHSH {
2654 _marker: PhantomData<*const ()>,
2655}
2656unsafe impl Send for USBHSH {}
2657impl USBHSH {
2658 #[doc = r"Pointer to the register block"]
2659 pub const PTR: *const usbhsh::RegisterBlock = 0x400a_3000 as *const _;
2660 #[doc = r"Return the pointer to the register block"]
2661 #[inline(always)]
2662 pub const fn ptr() -> *const usbhsh::RegisterBlock {
2663 Self::PTR
2664 }
2665}
2666impl Deref for USBHSH {
2667 type Target = usbhsh::RegisterBlock;
2668 #[inline(always)]
2669 fn deref(&self) -> &Self::Target {
2670 unsafe { &*Self::PTR }
2671 }
2672}
2673impl core::fmt::Debug for USBHSH {
2674 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2675 f.debug_struct("USBHSH").finish()
2676 }
2677}
2678#[doc = "USB1 High-speed Host Controller"]
2679pub mod usbhsh;
2680#[doc = "Hash-Crypt peripheral"]
2681pub struct HASHCRYPT {
2682 _marker: PhantomData<*const ()>,
2683}
2684unsafe impl Send for HASHCRYPT {}
2685impl HASHCRYPT {
2686 #[doc = r"Pointer to the register block"]
2687 pub const PTR: *const hashcrypt::RegisterBlock = 0x400a_4000 as *const _;
2688 #[doc = r"Return the pointer to the register block"]
2689 #[inline(always)]
2690 pub const fn ptr() -> *const hashcrypt::RegisterBlock {
2691 Self::PTR
2692 }
2693}
2694impl Deref for HASHCRYPT {
2695 type Target = hashcrypt::RegisterBlock;
2696 #[inline(always)]
2697 fn deref(&self) -> &Self::Target {
2698 unsafe { &*Self::PTR }
2699 }
2700}
2701impl core::fmt::Debug for HASHCRYPT {
2702 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2703 f.debug_struct("HASHCRYPT").finish()
2704 }
2705}
2706#[doc = "Hash-Crypt peripheral"]
2707pub mod hashcrypt;
2708#[doc = "CASPER"]
2709pub struct CASPER {
2710 _marker: PhantomData<*const ()>,
2711}
2712unsafe impl Send for CASPER {}
2713impl CASPER {
2714 #[doc = r"Pointer to the register block"]
2715 pub const PTR: *const casper::RegisterBlock = 0x400a_5000 as *const _;
2716 #[doc = r"Return the pointer to the register block"]
2717 #[inline(always)]
2718 pub const fn ptr() -> *const casper::RegisterBlock {
2719 Self::PTR
2720 }
2721}
2722impl Deref for CASPER {
2723 type Target = casper::RegisterBlock;
2724 #[inline(always)]
2725 fn deref(&self) -> &Self::Target {
2726 unsafe { &*Self::PTR }
2727 }
2728}
2729impl core::fmt::Debug for CASPER {
2730 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2731 f.debug_struct("CASPER").finish()
2732 }
2733}
2734#[doc = "CASPER"]
2735pub mod casper;
2736#[doc = "Digital Signal Co-Processing companion to a Cortex-M v8M CPU core"]
2737pub struct POWERQUAD {
2738 _marker: PhantomData<*const ()>,
2739}
2740unsafe impl Send for POWERQUAD {}
2741impl POWERQUAD {
2742 #[doc = r"Pointer to the register block"]
2743 pub const PTR: *const powerquad::RegisterBlock = 0x400a_6000 as *const _;
2744 #[doc = r"Return the pointer to the register block"]
2745 #[inline(always)]
2746 pub const fn ptr() -> *const powerquad::RegisterBlock {
2747 Self::PTR
2748 }
2749}
2750impl Deref for POWERQUAD {
2751 type Target = powerquad::RegisterBlock;
2752 #[inline(always)]
2753 fn deref(&self) -> &Self::Target {
2754 unsafe { &*Self::PTR }
2755 }
2756}
2757impl core::fmt::Debug for POWERQUAD {
2758 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2759 f.debug_struct("POWERQUAD").finish()
2760 }
2761}
2762#[doc = "Digital Signal Co-Processing companion to a Cortex-M v8M CPU core"]
2763pub mod powerquad;
2764#[doc = "General Purpose I/O (GPIO)"]
2765pub struct SECGPIO {
2766 _marker: PhantomData<*const ()>,
2767}
2768unsafe impl Send for SECGPIO {}
2769impl SECGPIO {
2770 #[doc = r"Pointer to the register block"]
2771 pub const PTR: *const secgpio::RegisterBlock = 0x400a_8000 as *const _;
2772 #[doc = r"Return the pointer to the register block"]
2773 #[inline(always)]
2774 pub const fn ptr() -> *const secgpio::RegisterBlock {
2775 Self::PTR
2776 }
2777}
2778impl Deref for SECGPIO {
2779 type Target = secgpio::RegisterBlock;
2780 #[inline(always)]
2781 fn deref(&self) -> &Self::Target {
2782 unsafe { &*Self::PTR }
2783 }
2784}
2785impl core::fmt::Debug for SECGPIO {
2786 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2787 f.debug_struct("SECGPIO").finish()
2788 }
2789}
2790#[doc = "General Purpose I/O (GPIO)"]
2791pub mod secgpio;
2792#[doc = "AHB secure controller"]
2793pub struct AHB_SECURE_CTRL {
2794 _marker: PhantomData<*const ()>,
2795}
2796unsafe impl Send for AHB_SECURE_CTRL {}
2797impl AHB_SECURE_CTRL {
2798 #[doc = r"Pointer to the register block"]
2799 pub const PTR: *const ahb_secure_ctrl::RegisterBlock = 0x400a_c000 as *const _;
2800 #[doc = r"Return the pointer to the register block"]
2801 #[inline(always)]
2802 pub const fn ptr() -> *const ahb_secure_ctrl::RegisterBlock {
2803 Self::PTR
2804 }
2805}
2806impl Deref for AHB_SECURE_CTRL {
2807 type Target = ahb_secure_ctrl::RegisterBlock;
2808 #[inline(always)]
2809 fn deref(&self) -> &Self::Target {
2810 unsafe { &*Self::PTR }
2811 }
2812}
2813impl core::fmt::Debug for AHB_SECURE_CTRL {
2814 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2815 f.debug_struct("AHB_SECURE_CTRL").finish()
2816 }
2817}
2818#[doc = "AHB secure controller"]
2819pub mod ahb_secure_ctrl;
2820#[doc = "no description available"]
2821pub struct SCNSCB {
2822 _marker: PhantomData<*const ()>,
2823}
2824unsafe impl Send for SCNSCB {}
2825impl SCNSCB {
2826 #[doc = r"Pointer to the register block"]
2827 pub const PTR: *const scn_scb::RegisterBlock = 0xe000_e000 as *const _;
2828 #[doc = r"Return the pointer to the register block"]
2829 #[inline(always)]
2830 pub const fn ptr() -> *const scn_scb::RegisterBlock {
2831 Self::PTR
2832 }
2833}
2834impl Deref for SCNSCB {
2835 type Target = scn_scb::RegisterBlock;
2836 #[inline(always)]
2837 fn deref(&self) -> &Self::Target {
2838 unsafe { &*Self::PTR }
2839 }
2840}
2841impl core::fmt::Debug for SCNSCB {
2842 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2843 f.debug_struct("SCNSCB").finish()
2844 }
2845}
2846#[doc = "no description available"]
2847pub mod scn_scb;
2848#[doc = "Security Attribution Unit"]
2849pub struct SAU {
2850 _marker: PhantomData<*const ()>,
2851}
2852unsafe impl Send for SAU {}
2853impl SAU {
2854 #[doc = r"Pointer to the register block"]
2855 pub const PTR: *const sau::RegisterBlock = 0xe000_edd0 as *const _;
2856 #[doc = r"Return the pointer to the register block"]
2857 #[inline(always)]
2858 pub const fn ptr() -> *const sau::RegisterBlock {
2859 Self::PTR
2860 }
2861}
2862impl Deref for SAU {
2863 type Target = sau::RegisterBlock;
2864 #[inline(always)]
2865 fn deref(&self) -> &Self::Target {
2866 unsafe { &*Self::PTR }
2867 }
2868}
2869impl core::fmt::Debug for SAU {
2870 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2871 f.debug_struct("SAU").finish()
2872 }
2873}
2874#[doc = "Security Attribution Unit"]
2875pub mod sau;
2876#[doc = "USB1 High-speed Device Controller"]
2877pub struct USB0 {
2878 _marker: PhantomData<*const ()>,
2879}
2880unsafe impl Send for USB0 {}
2881impl USB0 {
2882 #[doc = r"Pointer to the register block"]
2883 pub const PTR: *const usb1::RegisterBlock = 0x4008_4000 as *const _;
2884 #[doc = r"Return the pointer to the register block"]
2885 #[inline(always)]
2886 pub const fn ptr() -> *const usb1::RegisterBlock {
2887 Self::PTR
2888 }
2889}
2890impl Deref for USB0 {
2891 type Target = usb1::RegisterBlock;
2892 #[inline(always)]
2893 fn deref(&self) -> &Self::Target {
2894 unsafe { &*Self::PTR }
2895 }
2896}
2897impl core::fmt::Debug for USB0 {
2898 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2899 f.debug_struct("USB0").finish()
2900 }
2901}
2902#[doc = "USB1 High-speed Device Controller"]
2903pub use usb1 as usb0;
2904#[doc = "NXP ROM patch unit. Undocumented by NXP, this peripheral is experimentally modeled following research by Oxide Computer Company: <https://oxide.computer/blog/lpc55/>."]
2905pub struct RPU {
2906 _marker: PhantomData<*const ()>,
2907}
2908unsafe impl Send for RPU {}
2909impl RPU {
2910 #[doc = r"Pointer to the register block"]
2911 pub const PTR: *const rpu::RegisterBlock = 0x4003_e000 as *const _;
2912 #[doc = r"Return the pointer to the register block"]
2913 #[inline(always)]
2914 pub const fn ptr() -> *const rpu::RegisterBlock {
2915 Self::PTR
2916 }
2917}
2918impl Deref for RPU {
2919 type Target = rpu::RegisterBlock;
2920 #[inline(always)]
2921 fn deref(&self) -> &Self::Target {
2922 unsafe { &*Self::PTR }
2923 }
2924}
2925impl core::fmt::Debug for RPU {
2926 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2927 f.debug_struct("RPU").finish()
2928 }
2929}
2930#[doc = "NXP ROM patch unit. Undocumented by NXP, this peripheral is experimentally modeled following research by Oxide Computer Company: <https://oxide.computer/blog/lpc55/>."]
2931pub mod rpu;
2932#[no_mangle]
2933static mut DEVICE_PERIPHERALS: bool = false;
2934#[doc = r"All the peripherals"]
2935#[allow(non_snake_case)]
2936pub struct Peripherals {
2937 #[doc = "FLASH_CFPA0"]
2938 pub FLASH_CFPA0: FLASH_CFPA0,
2939 #[doc = "FLASH_CFPA_SCRATCH"]
2940 pub FLASH_CFPA_SCRATCH: FLASH_CFPA_SCRATCH,
2941 #[doc = "FLASH_CFPA1"]
2942 pub FLASH_CFPA1: FLASH_CFPA1,
2943 #[doc = "FLASH_CMPA"]
2944 pub FLASH_CMPA: FLASH_CMPA,
2945 #[doc = "FLASH_KEY_STORE"]
2946 pub FLASH_KEY_STORE: FLASH_KEY_STORE,
2947 #[doc = "SYSCON"]
2948 pub SYSCON: SYSCON,
2949 #[doc = "IOCON"]
2950 pub IOCON: IOCON,
2951 #[doc = "GINT0"]
2952 pub GINT0: GINT0,
2953 #[doc = "GINT1"]
2954 pub GINT1: GINT1,
2955 #[doc = "PINT"]
2956 pub PINT: PINT,
2957 #[doc = "SECPINT"]
2958 pub SECPINT: SECPINT,
2959 #[doc = "INPUTMUX"]
2960 pub INPUTMUX: INPUTMUX,
2961 #[doc = "CTIMER0"]
2962 pub CTIMER0: CTIMER0,
2963 #[doc = "CTIMER1"]
2964 pub CTIMER1: CTIMER1,
2965 #[doc = "CTIMER2"]
2966 pub CTIMER2: CTIMER2,
2967 #[doc = "CTIMER3"]
2968 pub CTIMER3: CTIMER3,
2969 #[doc = "CTIMER4"]
2970 pub CTIMER4: CTIMER4,
2971 #[doc = "WWDT"]
2972 pub WWDT: WWDT,
2973 #[doc = "MRT0"]
2974 pub MRT0: MRT0,
2975 #[doc = "UTICK0"]
2976 pub UTICK0: UTICK0,
2977 #[doc = "ANACTRL"]
2978 pub ANACTRL: ANACTRL,
2979 #[doc = "PMC"]
2980 pub PMC: PMC,
2981 #[doc = "SYSCTL"]
2982 pub SYSCTL: SYSCTL,
2983 #[doc = "RTC"]
2984 pub RTC: RTC,
2985 #[doc = "OSTIMER"]
2986 pub OSTIMER: OSTIMER,
2987 #[doc = "FLASH"]
2988 pub FLASH: FLASH,
2989 #[doc = "PRINCE"]
2990 pub PRINCE: PRINCE,
2991 #[doc = "USBPHY"]
2992 pub USBPHY: USBPHY,
2993 #[doc = "RNG"]
2994 pub RNG: RNG,
2995 #[doc = "PUF"]
2996 pub PUF: PUF,
2997 #[doc = "PLU"]
2998 pub PLU: PLU,
2999 #[doc = "DMA0"]
3000 pub DMA0: DMA0,
3001 #[doc = "DMA1"]
3002 pub DMA1: DMA1,
3003 #[doc = "SCT0"]
3004 pub SCT0: SCT0,
3005 #[doc = "FLEXCOMM0"]
3006 pub FLEXCOMM0: FLEXCOMM0,
3007 #[doc = "FLEXCOMM1"]
3008 pub FLEXCOMM1: FLEXCOMM1,
3009 #[doc = "FLEXCOMM2"]
3010 pub FLEXCOMM2: FLEXCOMM2,
3011 #[doc = "FLEXCOMM3"]
3012 pub FLEXCOMM3: FLEXCOMM3,
3013 #[doc = "FLEXCOMM4"]
3014 pub FLEXCOMM4: FLEXCOMM4,
3015 #[doc = "FLEXCOMM5"]
3016 pub FLEXCOMM5: FLEXCOMM5,
3017 #[doc = "FLEXCOMM6"]
3018 pub FLEXCOMM6: FLEXCOMM6,
3019 #[doc = "FLEXCOMM7"]
3020 pub FLEXCOMM7: FLEXCOMM7,
3021 #[doc = "FLEXCOMM8"]
3022 pub FLEXCOMM8: FLEXCOMM8,
3023 #[doc = "I2C0"]
3024 pub I2C0: I2C0,
3025 #[doc = "I2C1"]
3026 pub I2C1: I2C1,
3027 #[doc = "I2C2"]
3028 pub I2C2: I2C2,
3029 #[doc = "I2C3"]
3030 pub I2C3: I2C3,
3031 #[doc = "I2C4"]
3032 pub I2C4: I2C4,
3033 #[doc = "I2C5"]
3034 pub I2C5: I2C5,
3035 #[doc = "I2C6"]
3036 pub I2C6: I2C6,
3037 #[doc = "I2C7"]
3038 pub I2C7: I2C7,
3039 #[doc = "I2S0"]
3040 pub I2S0: I2S0,
3041 #[doc = "I2S1"]
3042 pub I2S1: I2S1,
3043 #[doc = "I2S2"]
3044 pub I2S2: I2S2,
3045 #[doc = "I2S3"]
3046 pub I2S3: I2S3,
3047 #[doc = "I2S4"]
3048 pub I2S4: I2S4,
3049 #[doc = "I2S5"]
3050 pub I2S5: I2S5,
3051 #[doc = "I2S6"]
3052 pub I2S6: I2S6,
3053 #[doc = "I2S7"]
3054 pub I2S7: I2S7,
3055 #[doc = "SPI0"]
3056 pub SPI0: SPI0,
3057 #[doc = "SPI1"]
3058 pub SPI1: SPI1,
3059 #[doc = "SPI2"]
3060 pub SPI2: SPI2,
3061 #[doc = "SPI3"]
3062 pub SPI3: SPI3,
3063 #[doc = "SPI4"]
3064 pub SPI4: SPI4,
3065 #[doc = "SPI5"]
3066 pub SPI5: SPI5,
3067 #[doc = "SPI6"]
3068 pub SPI6: SPI6,
3069 #[doc = "SPI7"]
3070 pub SPI7: SPI7,
3071 #[doc = "SPI8"]
3072 pub SPI8: SPI8,
3073 #[doc = "USART0"]
3074 pub USART0: USART0,
3075 #[doc = "USART1"]
3076 pub USART1: USART1,
3077 #[doc = "USART2"]
3078 pub USART2: USART2,
3079 #[doc = "USART3"]
3080 pub USART3: USART3,
3081 #[doc = "USART4"]
3082 pub USART4: USART4,
3083 #[doc = "USART5"]
3084 pub USART5: USART5,
3085 #[doc = "USART6"]
3086 pub USART6: USART6,
3087 #[doc = "USART7"]
3088 pub USART7: USART7,
3089 #[doc = "MAILBOX"]
3090 pub MAILBOX: MAILBOX,
3091 #[doc = "GPIO"]
3092 pub GPIO: GPIO,
3093 #[doc = "USB1"]
3094 pub USB1: USB1,
3095 #[doc = "CRC_ENGINE"]
3096 pub CRC_ENGINE: CRC_ENGINE,
3097 #[doc = "SDIF"]
3098 pub SDIF: SDIF,
3099 #[doc = "DBGMAILBOX"]
3100 pub DBGMAILBOX: DBGMAILBOX,
3101 #[doc = "ADC0"]
3102 pub ADC0: ADC0,
3103 #[doc = "USBFSH"]
3104 pub USBFSH: USBFSH,
3105 #[doc = "USBHSH"]
3106 pub USBHSH: USBHSH,
3107 #[doc = "HASHCRYPT"]
3108 pub HASHCRYPT: HASHCRYPT,
3109 #[doc = "CASPER"]
3110 pub CASPER: CASPER,
3111 #[doc = "POWERQUAD"]
3112 pub POWERQUAD: POWERQUAD,
3113 #[doc = "SECGPIO"]
3114 pub SECGPIO: SECGPIO,
3115 #[doc = "AHB_SECURE_CTRL"]
3116 pub AHB_SECURE_CTRL: AHB_SECURE_CTRL,
3117 #[doc = "SCNSCB"]
3118 pub SCNSCB: SCNSCB,
3119 #[doc = "SAU"]
3120 pub SAU: SAU,
3121 #[doc = "USB0"]
3122 pub USB0: USB0,
3123 #[doc = "RPU"]
3124 pub RPU: RPU,
3125}
3126impl Peripherals {
3127 #[doc = r"Returns all the peripherals *once*"]
3128 #[inline]
3129 pub fn take() -> Option<Self> {
3130 cortex_m::interrupt::free(|_| {
3131 if unsafe { DEVICE_PERIPHERALS } {
3132 None
3133 } else {
3134 Some(unsafe { Peripherals::steal() })
3135 }
3136 })
3137 }
3138 #[doc = r"Unchecked version of `Peripherals::take`"]
3139 #[inline]
3140 pub unsafe fn steal() -> Self {
3141 DEVICE_PERIPHERALS = true;
3142 Peripherals {
3143 FLASH_CFPA0: FLASH_CFPA0 {
3144 _marker: PhantomData,
3145 },
3146 FLASH_CFPA_SCRATCH: FLASH_CFPA_SCRATCH {
3147 _marker: PhantomData,
3148 },
3149 FLASH_CFPA1: FLASH_CFPA1 {
3150 _marker: PhantomData,
3151 },
3152 FLASH_CMPA: FLASH_CMPA {
3153 _marker: PhantomData,
3154 },
3155 FLASH_KEY_STORE: FLASH_KEY_STORE {
3156 _marker: PhantomData,
3157 },
3158 SYSCON: SYSCON {
3159 _marker: PhantomData,
3160 },
3161 IOCON: IOCON {
3162 _marker: PhantomData,
3163 },
3164 GINT0: GINT0 {
3165 _marker: PhantomData,
3166 },
3167 GINT1: GINT1 {
3168 _marker: PhantomData,
3169 },
3170 PINT: PINT {
3171 _marker: PhantomData,
3172 },
3173 SECPINT: SECPINT {
3174 _marker: PhantomData,
3175 },
3176 INPUTMUX: INPUTMUX {
3177 _marker: PhantomData,
3178 },
3179 CTIMER0: CTIMER0 {
3180 _marker: PhantomData,
3181 },
3182 CTIMER1: CTIMER1 {
3183 _marker: PhantomData,
3184 },
3185 CTIMER2: CTIMER2 {
3186 _marker: PhantomData,
3187 },
3188 CTIMER3: CTIMER3 {
3189 _marker: PhantomData,
3190 },
3191 CTIMER4: CTIMER4 {
3192 _marker: PhantomData,
3193 },
3194 WWDT: WWDT {
3195 _marker: PhantomData,
3196 },
3197 MRT0: MRT0 {
3198 _marker: PhantomData,
3199 },
3200 UTICK0: UTICK0 {
3201 _marker: PhantomData,
3202 },
3203 ANACTRL: ANACTRL {
3204 _marker: PhantomData,
3205 },
3206 PMC: PMC {
3207 _marker: PhantomData,
3208 },
3209 SYSCTL: SYSCTL {
3210 _marker: PhantomData,
3211 },
3212 RTC: RTC {
3213 _marker: PhantomData,
3214 },
3215 OSTIMER: OSTIMER {
3216 _marker: PhantomData,
3217 },
3218 FLASH: FLASH {
3219 _marker: PhantomData,
3220 },
3221 PRINCE: PRINCE {
3222 _marker: PhantomData,
3223 },
3224 USBPHY: USBPHY {
3225 _marker: PhantomData,
3226 },
3227 RNG: RNG {
3228 _marker: PhantomData,
3229 },
3230 PUF: PUF {
3231 _marker: PhantomData,
3232 },
3233 PLU: PLU {
3234 _marker: PhantomData,
3235 },
3236 DMA0: DMA0 {
3237 _marker: PhantomData,
3238 },
3239 DMA1: DMA1 {
3240 _marker: PhantomData,
3241 },
3242 SCT0: SCT0 {
3243 _marker: PhantomData,
3244 },
3245 FLEXCOMM0: FLEXCOMM0 {
3246 _marker: PhantomData,
3247 },
3248 FLEXCOMM1: FLEXCOMM1 {
3249 _marker: PhantomData,
3250 },
3251 FLEXCOMM2: FLEXCOMM2 {
3252 _marker: PhantomData,
3253 },
3254 FLEXCOMM3: FLEXCOMM3 {
3255 _marker: PhantomData,
3256 },
3257 FLEXCOMM4: FLEXCOMM4 {
3258 _marker: PhantomData,
3259 },
3260 FLEXCOMM5: FLEXCOMM5 {
3261 _marker: PhantomData,
3262 },
3263 FLEXCOMM6: FLEXCOMM6 {
3264 _marker: PhantomData,
3265 },
3266 FLEXCOMM7: FLEXCOMM7 {
3267 _marker: PhantomData,
3268 },
3269 FLEXCOMM8: FLEXCOMM8 {
3270 _marker: PhantomData,
3271 },
3272 I2C0: I2C0 {
3273 _marker: PhantomData,
3274 },
3275 I2C1: I2C1 {
3276 _marker: PhantomData,
3277 },
3278 I2C2: I2C2 {
3279 _marker: PhantomData,
3280 },
3281 I2C3: I2C3 {
3282 _marker: PhantomData,
3283 },
3284 I2C4: I2C4 {
3285 _marker: PhantomData,
3286 },
3287 I2C5: I2C5 {
3288 _marker: PhantomData,
3289 },
3290 I2C6: I2C6 {
3291 _marker: PhantomData,
3292 },
3293 I2C7: I2C7 {
3294 _marker: PhantomData,
3295 },
3296 I2S0: I2S0 {
3297 _marker: PhantomData,
3298 },
3299 I2S1: I2S1 {
3300 _marker: PhantomData,
3301 },
3302 I2S2: I2S2 {
3303 _marker: PhantomData,
3304 },
3305 I2S3: I2S3 {
3306 _marker: PhantomData,
3307 },
3308 I2S4: I2S4 {
3309 _marker: PhantomData,
3310 },
3311 I2S5: I2S5 {
3312 _marker: PhantomData,
3313 },
3314 I2S6: I2S6 {
3315 _marker: PhantomData,
3316 },
3317 I2S7: I2S7 {
3318 _marker: PhantomData,
3319 },
3320 SPI0: SPI0 {
3321 _marker: PhantomData,
3322 },
3323 SPI1: SPI1 {
3324 _marker: PhantomData,
3325 },
3326 SPI2: SPI2 {
3327 _marker: PhantomData,
3328 },
3329 SPI3: SPI3 {
3330 _marker: PhantomData,
3331 },
3332 SPI4: SPI4 {
3333 _marker: PhantomData,
3334 },
3335 SPI5: SPI5 {
3336 _marker: PhantomData,
3337 },
3338 SPI6: SPI6 {
3339 _marker: PhantomData,
3340 },
3341 SPI7: SPI7 {
3342 _marker: PhantomData,
3343 },
3344 SPI8: SPI8 {
3345 _marker: PhantomData,
3346 },
3347 USART0: USART0 {
3348 _marker: PhantomData,
3349 },
3350 USART1: USART1 {
3351 _marker: PhantomData,
3352 },
3353 USART2: USART2 {
3354 _marker: PhantomData,
3355 },
3356 USART3: USART3 {
3357 _marker: PhantomData,
3358 },
3359 USART4: USART4 {
3360 _marker: PhantomData,
3361 },
3362 USART5: USART5 {
3363 _marker: PhantomData,
3364 },
3365 USART6: USART6 {
3366 _marker: PhantomData,
3367 },
3368 USART7: USART7 {
3369 _marker: PhantomData,
3370 },
3371 MAILBOX: MAILBOX {
3372 _marker: PhantomData,
3373 },
3374 GPIO: GPIO {
3375 _marker: PhantomData,
3376 },
3377 USB1: USB1 {
3378 _marker: PhantomData,
3379 },
3380 CRC_ENGINE: CRC_ENGINE {
3381 _marker: PhantomData,
3382 },
3383 SDIF: SDIF {
3384 _marker: PhantomData,
3385 },
3386 DBGMAILBOX: DBGMAILBOX {
3387 _marker: PhantomData,
3388 },
3389 ADC0: ADC0 {
3390 _marker: PhantomData,
3391 },
3392 USBFSH: USBFSH {
3393 _marker: PhantomData,
3394 },
3395 USBHSH: USBHSH {
3396 _marker: PhantomData,
3397 },
3398 HASHCRYPT: HASHCRYPT {
3399 _marker: PhantomData,
3400 },
3401 CASPER: CASPER {
3402 _marker: PhantomData,
3403 },
3404 POWERQUAD: POWERQUAD {
3405 _marker: PhantomData,
3406 },
3407 SECGPIO: SECGPIO {
3408 _marker: PhantomData,
3409 },
3410 AHB_SECURE_CTRL: AHB_SECURE_CTRL {
3411 _marker: PhantomData,
3412 },
3413 SCNSCB: SCNSCB {
3414 _marker: PhantomData,
3415 },
3416 SAU: SAU {
3417 _marker: PhantomData,
3418 },
3419 USB0: USB0 {
3420 _marker: PhantomData,
3421 },
3422 RPU: RPU {
3423 _marker: PhantomData,
3424 },
3425 }
3426 }
3427}