1#![doc = "Peripheral access API for LPC55S69_CM33_CORE0 microcontrollers (generated using svd2rust v0.17.0)\n\nYou can find an overview of the API [here].\n\n[here]: https://docs.rs/svd2rust/0.17.0/svd2rust/#peripheral-api"]
2#![deny(const_err)]
3#![deny(dead_code)]
4#![deny(improper_ctypes)]
5#![deny(legacy_directory_ownership)]
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(plugin_as_library)]
13#![deny(private_in_public)]
14#![deny(safe_extern_statics)]
15#![deny(unconditional_recursion)]
16#![deny(unions_with_drop_fields)]
17#![deny(unused_allocation)]
18#![deny(unused_comparisons)]
19#![deny(unused_parens)]
20#![deny(while_true)]
21#![allow(non_camel_case_types)]
22#![allow(non_snake_case)]
23#![no_std]
24extern crate bare_metal;
25extern crate cortex_m;
26#[cfg(feature = "rt")]
27extern crate cortex_m_rt;
28extern crate vcell;
29use core::marker::PhantomData;
30use core::ops::Deref;
31#[doc = r"Number available in the NVIC for configuring priority"]
32pub const NVIC_PRIO_BITS: u8 = 3;
33#[cfg(feature = "rt")]
34extern "C" {
35 fn WDT_BOD();
36 fn DMA0();
37 fn GINT0();
38 fn GINT1();
39 fn PIN_INT0();
40 fn PIN_INT1();
41 fn PIN_INT2();
42 fn PIN_INT3();
43 fn UTICK0();
44 fn MRT0();
45 fn CTIMER0();
46 fn CTIMER1();
47 fn SCT0();
48 fn CTIMER3();
49 fn FLEXCOMM0();
50 fn FLEXCOMM1();
51 fn FLEXCOMM2();
52 fn FLEXCOMM3();
53 fn FLEXCOMM4();
54 fn FLEXCOMM5();
55 fn FLEXCOMM6();
56 fn FLEXCOMM7();
57 fn ADC0();
58 fn USB0_NEEDCLK();
59 fn USB0();
60 fn RTC();
61 fn MAILBOX();
62 fn PIN_INT4();
63 fn PIN_INT5();
64 fn PIN_INT6();
65 fn PIN_INT7();
66 fn CTIMER2();
67 fn CTIMER4();
68 fn OS_EVENT();
69 fn SDIO();
70 fn USB1_PHY();
71 fn USB1();
72 fn USB1_NEEDCLK();
73 fn SEC_GPIO_INT0_IRQ0();
74 fn SEC_GPIO_INT0_IRQ1();
75 fn PLU();
76 fn HASHCRYPT();
77 fn PUF();
78 fn DMA1();
79 fn FLEXCOMM8();
80}
81#[doc(hidden)]
82pub union Vector {
83 _handler: unsafe extern "C" fn(),
84 _reserved: u32,
85}
86#[cfg(feature = "rt")]
87#[doc(hidden)]
88#[link_section = ".vector_table.interrupts"]
89#[no_mangle]
90pub static __INTERRUPTS: [Vector; 60] = [
91 Vector { _handler: WDT_BOD },
92 Vector { _handler: DMA0 },
93 Vector { _handler: GINT0 },
94 Vector { _handler: GINT1 },
95 Vector { _handler: PIN_INT0 },
96 Vector { _handler: PIN_INT1 },
97 Vector { _handler: PIN_INT2 },
98 Vector { _handler: PIN_INT3 },
99 Vector { _handler: UTICK0 },
100 Vector { _handler: MRT0 },
101 Vector { _handler: CTIMER0 },
102 Vector { _handler: CTIMER1 },
103 Vector { _handler: SCT0 },
104 Vector { _handler: CTIMER3 },
105 Vector {
106 _handler: FLEXCOMM0,
107 },
108 Vector {
109 _handler: FLEXCOMM1,
110 },
111 Vector {
112 _handler: FLEXCOMM2,
113 },
114 Vector {
115 _handler: FLEXCOMM3,
116 },
117 Vector {
118 _handler: FLEXCOMM4,
119 },
120 Vector {
121 _handler: FLEXCOMM5,
122 },
123 Vector {
124 _handler: FLEXCOMM6,
125 },
126 Vector {
127 _handler: FLEXCOMM7,
128 },
129 Vector { _handler: ADC0 },
130 Vector { _reserved: 0 },
131 Vector { _reserved: 0 },
132 Vector { _reserved: 0 },
133 Vector { _reserved: 0 },
134 Vector {
135 _handler: USB0_NEEDCLK,
136 },
137 Vector { _handler: USB0 },
138 Vector { _handler: RTC },
139 Vector { _reserved: 0 },
140 Vector { _handler: MAILBOX },
141 Vector { _handler: PIN_INT4 },
142 Vector { _handler: PIN_INT5 },
143 Vector { _handler: PIN_INT6 },
144 Vector { _handler: PIN_INT7 },
145 Vector { _handler: CTIMER2 },
146 Vector { _handler: CTIMER4 },
147 Vector { _handler: OS_EVENT },
148 Vector { _reserved: 0 },
149 Vector { _reserved: 0 },
150 Vector { _reserved: 0 },
151 Vector { _handler: SDIO },
152 Vector { _reserved: 0 },
153 Vector { _reserved: 0 },
154 Vector { _reserved: 0 },
155 Vector { _handler: USB1_PHY },
156 Vector { _handler: USB1 },
157 Vector {
158 _handler: USB1_NEEDCLK,
159 },
160 Vector { _reserved: 0 },
161 Vector {
162 _handler: SEC_GPIO_INT0_IRQ0,
163 },
164 Vector {
165 _handler: SEC_GPIO_INT0_IRQ1,
166 },
167 Vector { _handler: PLU },
168 Vector { _reserved: 0 },
169 Vector {
170 _handler: HASHCRYPT,
171 },
172 Vector { _reserved: 0 },
173 Vector { _handler: PUF },
174 Vector { _reserved: 0 },
175 Vector { _handler: DMA1 },
176 Vector {
177 _handler: FLEXCOMM8,
178 },
179];
180#[doc = r"Enumeration of all the interrupts"]
181#[derive(Copy, Clone, Debug)]
182#[repr(u8)]
183pub enum Interrupt {
184 #[doc = "0 - WDT_BOD"]
185 WDT_BOD = 0,
186 #[doc = "1 - DMA0"]
187 DMA0 = 1,
188 #[doc = "2 - GINT0"]
189 GINT0 = 2,
190 #[doc = "3 - GINT1"]
191 GINT1 = 3,
192 #[doc = "4 - PIN_INT0"]
193 PIN_INT0 = 4,
194 #[doc = "5 - PIN_INT1"]
195 PIN_INT1 = 5,
196 #[doc = "6 - PIN_INT2"]
197 PIN_INT2 = 6,
198 #[doc = "7 - PIN_INT3"]
199 PIN_INT3 = 7,
200 #[doc = "8 - UTICK0"]
201 UTICK0 = 8,
202 #[doc = "9 - MRT0"]
203 MRT0 = 9,
204 #[doc = "10 - CTIMER0"]
205 CTIMER0 = 10,
206 #[doc = "11 - CTIMER1"]
207 CTIMER1 = 11,
208 #[doc = "12 - SCT0"]
209 SCT0 = 12,
210 #[doc = "13 - CTIMER3"]
211 CTIMER3 = 13,
212 #[doc = "14 - FLEXCOMM0"]
213 FLEXCOMM0 = 14,
214 #[doc = "15 - FLEXCOMM1"]
215 FLEXCOMM1 = 15,
216 #[doc = "16 - FLEXCOMM2"]
217 FLEXCOMM2 = 16,
218 #[doc = "17 - FLEXCOMM3"]
219 FLEXCOMM3 = 17,
220 #[doc = "18 - FLEXCOMM4"]
221 FLEXCOMM4 = 18,
222 #[doc = "19 - FLEXCOMM5"]
223 FLEXCOMM5 = 19,
224 #[doc = "20 - FLEXCOMM6"]
225 FLEXCOMM6 = 20,
226 #[doc = "21 - FLEXCOMM7"]
227 FLEXCOMM7 = 21,
228 #[doc = "22 - ADC0"]
229 ADC0 = 22,
230 #[doc = "27 - USB0_NEEDCLK"]
231 USB0_NEEDCLK = 27,
232 #[doc = "28 - USB0"]
233 USB0 = 28,
234 #[doc = "29 - RTC"]
235 RTC = 29,
236 #[doc = "31 - MAILBOX"]
237 MAILBOX = 31,
238 #[doc = "32 - PIN_INT4"]
239 PIN_INT4 = 32,
240 #[doc = "33 - PIN_INT5"]
241 PIN_INT5 = 33,
242 #[doc = "34 - PIN_INT6"]
243 PIN_INT6 = 34,
244 #[doc = "35 - PIN_INT7"]
245 PIN_INT7 = 35,
246 #[doc = "36 - CTIMER2"]
247 CTIMER2 = 36,
248 #[doc = "37 - CTIMER4"]
249 CTIMER4 = 37,
250 #[doc = "38 - OS_EVENT"]
251 OS_EVENT = 38,
252 #[doc = "42 - SDIO"]
253 SDIO = 42,
254 #[doc = "46 - USB1_PHY"]
255 USB1_PHY = 46,
256 #[doc = "47 - USB1"]
257 USB1 = 47,
258 #[doc = "48 - USB1_NEEDCLK"]
259 USB1_NEEDCLK = 48,
260 #[doc = "50 - SEC_GPIO_INT0_IRQ0"]
261 SEC_GPIO_INT0_IRQ0 = 50,
262 #[doc = "51 - SEC_GPIO_INT0_IRQ1"]
263 SEC_GPIO_INT0_IRQ1 = 51,
264 #[doc = "52 - PLU"]
265 PLU = 52,
266 #[doc = "54 - HASHCRYPT"]
267 HASHCRYPT = 54,
268 #[doc = "56 - PUF"]
269 PUF = 56,
270 #[doc = "58 - DMA1"]
271 DMA1 = 58,
272 #[doc = "59 - FLEXCOMM8"]
273 FLEXCOMM8 = 59,
274}
275unsafe impl bare_metal::Nr for Interrupt {
276 #[inline(always)]
277 fn nr(&self) -> u8 {
278 *self as u8
279 }
280}
281#[cfg(feature = "rt")]
282pub use self::Interrupt as interrupt;
283pub use cortex_m::peripheral::Peripherals as CorePeripherals;
284pub use cortex_m::peripheral::{CBP, CPUID, DCB, DWT, FPB, FPU, ITM, MPU, NVIC, SCB, SYST, TPIU};
285#[cfg(feature = "rt")]
286pub use cortex_m_rt::interrupt;
287#[allow(unused_imports)]
288use generic::*;
289#[doc = r"Common register and bit access and modify traits"]
290pub mod generic;
291#[doc = "FLASH_CFPA"]
292pub struct FLASH_CFPA0 {
293 _marker: PhantomData<*const ()>,
294}
295unsafe impl Send for FLASH_CFPA0 {}
296impl FLASH_CFPA0 {
297 #[doc = r"Returns a pointer to the register block"]
298 #[inline(always)]
299 pub const fn ptr() -> *const flash_cfpa0::RegisterBlock {
300 0x0009_e000 as *const _
301 }
302}
303impl Deref for FLASH_CFPA0 {
304 type Target = flash_cfpa0::RegisterBlock;
305 #[inline(always)]
306 fn deref(&self) -> &Self::Target {
307 unsafe { &*FLASH_CFPA0::ptr() }
308 }
309}
310#[doc = "FLASH_CFPA"]
311pub mod flash_cfpa0;
312#[doc = "FLASH_CFPA"]
313pub struct FLASH_CFPA_SCRATCH {
314 _marker: PhantomData<*const ()>,
315}
316unsafe impl Send for FLASH_CFPA_SCRATCH {}
317impl FLASH_CFPA_SCRATCH {
318 #[doc = r"Returns a pointer to the register block"]
319 #[inline(always)]
320 pub const fn ptr() -> *const flash_cfpa0::RegisterBlock {
321 0x0009_de00 as *const _
322 }
323}
324impl Deref for FLASH_CFPA_SCRATCH {
325 type Target = flash_cfpa0::RegisterBlock;
326 #[inline(always)]
327 fn deref(&self) -> &Self::Target {
328 unsafe { &*FLASH_CFPA_SCRATCH::ptr() }
329 }
330}
331#[doc = "FLASH_CFPA"]
332pub struct FLASH_CFPA1 {
333 _marker: PhantomData<*const ()>,
334}
335unsafe impl Send for FLASH_CFPA1 {}
336impl FLASH_CFPA1 {
337 #[doc = r"Returns a pointer to the register block"]
338 #[inline(always)]
339 pub const fn ptr() -> *const flash_cfpa0::RegisterBlock {
340 0x0009_e200 as *const _
341 }
342}
343impl Deref for FLASH_CFPA1 {
344 type Target = flash_cfpa0::RegisterBlock;
345 #[inline(always)]
346 fn deref(&self) -> &Self::Target {
347 unsafe { &*FLASH_CFPA1::ptr() }
348 }
349}
350#[doc = "FLASH_CMPA"]
351pub struct FLASH_CMPA {
352 _marker: PhantomData<*const ()>,
353}
354unsafe impl Send for FLASH_CMPA {}
355impl FLASH_CMPA {
356 #[doc = r"Returns a pointer to the register block"]
357 #[inline(always)]
358 pub const fn ptr() -> *const flash_cmpa::RegisterBlock {
359 0x0009_e400 as *const _
360 }
361}
362impl Deref for FLASH_CMPA {
363 type Target = flash_cmpa::RegisterBlock;
364 #[inline(always)]
365 fn deref(&self) -> &Self::Target {
366 unsafe { &*FLASH_CMPA::ptr() }
367 }
368}
369#[doc = "FLASH_CMPA"]
370pub mod flash_cmpa;
371#[doc = "FLASH_KEY_STORE"]
372pub struct FLASH_KEY_STORE {
373 _marker: PhantomData<*const ()>,
374}
375unsafe impl Send for FLASH_KEY_STORE {}
376impl FLASH_KEY_STORE {
377 #[doc = r"Returns a pointer to the register block"]
378 #[inline(always)]
379 pub const fn ptr() -> *const flash_key_store::RegisterBlock {
380 0x0009_e600 as *const _
381 }
382}
383impl Deref for FLASH_KEY_STORE {
384 type Target = flash_key_store::RegisterBlock;
385 #[inline(always)]
386 fn deref(&self) -> &Self::Target {
387 unsafe { &*FLASH_KEY_STORE::ptr() }
388 }
389}
390#[doc = "FLASH_KEY_STORE"]
391pub mod flash_key_store;
392#[doc = "SYSCON"]
393pub struct SYSCON {
394 _marker: PhantomData<*const ()>,
395}
396unsafe impl Send for SYSCON {}
397impl SYSCON {
398 #[doc = r"Returns a pointer to the register block"]
399 #[inline(always)]
400 pub const fn ptr() -> *const syscon::RegisterBlock {
401 0x4000_0000 as *const _
402 }
403}
404impl Deref for SYSCON {
405 type Target = syscon::RegisterBlock;
406 #[inline(always)]
407 fn deref(&self) -> &Self::Target {
408 unsafe { &*SYSCON::ptr() }
409 }
410}
411#[doc = "SYSCON"]
412pub mod syscon;
413#[doc = "I/O pin configuration (IOCON)"]
414pub struct IOCON {
415 _marker: PhantomData<*const ()>,
416}
417unsafe impl Send for IOCON {}
418impl IOCON {
419 #[doc = r"Returns a pointer to the register block"]
420 #[inline(always)]
421 pub const fn ptr() -> *const iocon::RegisterBlock {
422 0x4000_1000 as *const _
423 }
424}
425impl Deref for IOCON {
426 type Target = iocon::RegisterBlock;
427 #[inline(always)]
428 fn deref(&self) -> &Self::Target {
429 unsafe { &*IOCON::ptr() }
430 }
431}
432#[doc = "I/O pin configuration (IOCON)"]
433pub mod iocon;
434#[doc = "Group GPIO input interrupt (GINT0/1)"]
435pub struct GINT0 {
436 _marker: PhantomData<*const ()>,
437}
438unsafe impl Send for GINT0 {}
439impl GINT0 {
440 #[doc = r"Returns a pointer to the register block"]
441 #[inline(always)]
442 pub const fn ptr() -> *const gint0::RegisterBlock {
443 0x4000_2000 as *const _
444 }
445}
446impl Deref for GINT0 {
447 type Target = gint0::RegisterBlock;
448 #[inline(always)]
449 fn deref(&self) -> &Self::Target {
450 unsafe { &*GINT0::ptr() }
451 }
452}
453#[doc = "Group GPIO input interrupt (GINT0/1)"]
454pub mod gint0;
455#[doc = "Group GPIO input interrupt (GINT0/1)"]
456pub struct GINT1 {
457 _marker: PhantomData<*const ()>,
458}
459unsafe impl Send for GINT1 {}
460impl GINT1 {
461 #[doc = r"Returns a pointer to the register block"]
462 #[inline(always)]
463 pub const fn ptr() -> *const gint0::RegisterBlock {
464 0x4000_3000 as *const _
465 }
466}
467impl Deref for GINT1 {
468 type Target = gint0::RegisterBlock;
469 #[inline(always)]
470 fn deref(&self) -> &Self::Target {
471 unsafe { &*GINT1::ptr() }
472 }
473}
474#[doc = "Pin interrupt and pattern match (PINT)"]
475pub struct PINT {
476 _marker: PhantomData<*const ()>,
477}
478unsafe impl Send for PINT {}
479impl PINT {
480 #[doc = r"Returns a pointer to the register block"]
481 #[inline(always)]
482 pub const fn ptr() -> *const pint::RegisterBlock {
483 0x4000_4000 as *const _
484 }
485}
486impl Deref for PINT {
487 type Target = pint::RegisterBlock;
488 #[inline(always)]
489 fn deref(&self) -> &Self::Target {
490 unsafe { &*PINT::ptr() }
491 }
492}
493#[doc = "Pin interrupt and pattern match (PINT)"]
494pub mod pint;
495#[doc = "Pin interrupt and pattern match (PINT)"]
496pub struct SECPINT {
497 _marker: PhantomData<*const ()>,
498}
499unsafe impl Send for SECPINT {}
500impl SECPINT {
501 #[doc = r"Returns a pointer to the register block"]
502 #[inline(always)]
503 pub const fn ptr() -> *const pint::RegisterBlock {
504 0x4000_5000 as *const _
505 }
506}
507impl Deref for SECPINT {
508 type Target = pint::RegisterBlock;
509 #[inline(always)]
510 fn deref(&self) -> &Self::Target {
511 unsafe { &*SECPINT::ptr() }
512 }
513}
514#[doc = "Input multiplexing (INPUT MUX)"]
515pub struct INPUTMUX {
516 _marker: PhantomData<*const ()>,
517}
518unsafe impl Send for INPUTMUX {}
519impl INPUTMUX {
520 #[doc = r"Returns a pointer to the register block"]
521 #[inline(always)]
522 pub const fn ptr() -> *const inputmux::RegisterBlock {
523 0x4000_6000 as *const _
524 }
525}
526impl Deref for INPUTMUX {
527 type Target = inputmux::RegisterBlock;
528 #[inline(always)]
529 fn deref(&self) -> &Self::Target {
530 unsafe { &*INPUTMUX::ptr() }
531 }
532}
533#[doc = "Input multiplexing (INPUT MUX)"]
534pub mod inputmux;
535#[doc = "Standard counter/timers (CTIMER0 to 4)"]
536pub struct CTIMER0 {
537 _marker: PhantomData<*const ()>,
538}
539unsafe impl Send for CTIMER0 {}
540impl CTIMER0 {
541 #[doc = r"Returns a pointer to the register block"]
542 #[inline(always)]
543 pub const fn ptr() -> *const ctimer0::RegisterBlock {
544 0x4000_8000 as *const _
545 }
546}
547impl Deref for CTIMER0 {
548 type Target = ctimer0::RegisterBlock;
549 #[inline(always)]
550 fn deref(&self) -> &Self::Target {
551 unsafe { &*CTIMER0::ptr() }
552 }
553}
554#[doc = "Standard counter/timers (CTIMER0 to 4)"]
555pub mod ctimer0;
556#[doc = "Standard counter/timers (CTIMER0 to 4)"]
557pub struct CTIMER1 {
558 _marker: PhantomData<*const ()>,
559}
560unsafe impl Send for CTIMER1 {}
561impl CTIMER1 {
562 #[doc = r"Returns a pointer to the register block"]
563 #[inline(always)]
564 pub const fn ptr() -> *const ctimer0::RegisterBlock {
565 0x4000_9000 as *const _
566 }
567}
568impl Deref for CTIMER1 {
569 type Target = ctimer0::RegisterBlock;
570 #[inline(always)]
571 fn deref(&self) -> &Self::Target {
572 unsafe { &*CTIMER1::ptr() }
573 }
574}
575#[doc = "Standard counter/timers (CTIMER0 to 4)"]
576pub struct CTIMER2 {
577 _marker: PhantomData<*const ()>,
578}
579unsafe impl Send for CTIMER2 {}
580impl CTIMER2 {
581 #[doc = r"Returns a pointer to the register block"]
582 #[inline(always)]
583 pub const fn ptr() -> *const ctimer0::RegisterBlock {
584 0x4002_8000 as *const _
585 }
586}
587impl Deref for CTIMER2 {
588 type Target = ctimer0::RegisterBlock;
589 #[inline(always)]
590 fn deref(&self) -> &Self::Target {
591 unsafe { &*CTIMER2::ptr() }
592 }
593}
594#[doc = "Standard counter/timers (CTIMER0 to 4)"]
595pub struct CTIMER3 {
596 _marker: PhantomData<*const ()>,
597}
598unsafe impl Send for CTIMER3 {}
599impl CTIMER3 {
600 #[doc = r"Returns a pointer to the register block"]
601 #[inline(always)]
602 pub const fn ptr() -> *const ctimer0::RegisterBlock {
603 0x4002_9000 as *const _
604 }
605}
606impl Deref for CTIMER3 {
607 type Target = ctimer0::RegisterBlock;
608 #[inline(always)]
609 fn deref(&self) -> &Self::Target {
610 unsafe { &*CTIMER3::ptr() }
611 }
612}
613#[doc = "Standard counter/timers (CTIMER0 to 4)"]
614pub struct CTIMER4 {
615 _marker: PhantomData<*const ()>,
616}
617unsafe impl Send for CTIMER4 {}
618impl CTIMER4 {
619 #[doc = r"Returns a pointer to the register block"]
620 #[inline(always)]
621 pub const fn ptr() -> *const ctimer0::RegisterBlock {
622 0x4002_a000 as *const _
623 }
624}
625impl Deref for CTIMER4 {
626 type Target = ctimer0::RegisterBlock;
627 #[inline(always)]
628 fn deref(&self) -> &Self::Target {
629 unsafe { &*CTIMER4::ptr() }
630 }
631}
632#[doc = "Windowed Watchdog Timer (WWDT)"]
633pub struct WWDT {
634 _marker: PhantomData<*const ()>,
635}
636unsafe impl Send for WWDT {}
637impl WWDT {
638 #[doc = r"Returns a pointer to the register block"]
639 #[inline(always)]
640 pub const fn ptr() -> *const wwdt::RegisterBlock {
641 0x4000_c000 as *const _
642 }
643}
644impl Deref for WWDT {
645 type Target = wwdt::RegisterBlock;
646 #[inline(always)]
647 fn deref(&self) -> &Self::Target {
648 unsafe { &*WWDT::ptr() }
649 }
650}
651#[doc = "Windowed Watchdog Timer (WWDT)"]
652pub mod wwdt;
653#[doc = "Multi-Rate Timer (MRT)"]
654pub struct MRT0 {
655 _marker: PhantomData<*const ()>,
656}
657unsafe impl Send for MRT0 {}
658impl MRT0 {
659 #[doc = r"Returns a pointer to the register block"]
660 #[inline(always)]
661 pub const fn ptr() -> *const mrt0::RegisterBlock {
662 0x4000_d000 as *const _
663 }
664}
665impl Deref for MRT0 {
666 type Target = mrt0::RegisterBlock;
667 #[inline(always)]
668 fn deref(&self) -> &Self::Target {
669 unsafe { &*MRT0::ptr() }
670 }
671}
672#[doc = "Multi-Rate Timer (MRT)"]
673pub mod mrt0;
674#[doc = "Micro-tick Timer (UTICK)"]
675pub struct UTICK0 {
676 _marker: PhantomData<*const ()>,
677}
678unsafe impl Send for UTICK0 {}
679impl UTICK0 {
680 #[doc = r"Returns a pointer to the register block"]
681 #[inline(always)]
682 pub const fn ptr() -> *const utick0::RegisterBlock {
683 0x4000_e000 as *const _
684 }
685}
686impl Deref for UTICK0 {
687 type Target = utick0::RegisterBlock;
688 #[inline(always)]
689 fn deref(&self) -> &Self::Target {
690 unsafe { &*UTICK0::ptr() }
691 }
692}
693#[doc = "Micro-tick Timer (UTICK)"]
694pub mod utick0;
695#[doc = "ANALOGCTRL"]
696pub struct ANACTRL {
697 _marker: PhantomData<*const ()>,
698}
699unsafe impl Send for ANACTRL {}
700impl ANACTRL {
701 #[doc = r"Returns a pointer to the register block"]
702 #[inline(always)]
703 pub const fn ptr() -> *const anactrl::RegisterBlock {
704 0x4001_3000 as *const _
705 }
706}
707impl Deref for ANACTRL {
708 type Target = anactrl::RegisterBlock;
709 #[inline(always)]
710 fn deref(&self) -> &Self::Target {
711 unsafe { &*ANACTRL::ptr() }
712 }
713}
714#[doc = "ANALOGCTRL"]
715pub mod anactrl;
716#[doc = "PMC"]
717pub struct PMC {
718 _marker: PhantomData<*const ()>,
719}
720unsafe impl Send for PMC {}
721impl PMC {
722 #[doc = r"Returns a pointer to the register block"]
723 #[inline(always)]
724 pub const fn ptr() -> *const pmc::RegisterBlock {
725 0x4002_0000 as *const _
726 }
727}
728impl Deref for PMC {
729 type Target = pmc::RegisterBlock;
730 #[inline(always)]
731 fn deref(&self) -> &Self::Target {
732 unsafe { &*PMC::ptr() }
733 }
734}
735#[doc = "PMC"]
736pub mod pmc;
737#[doc = "system controller"]
738pub struct SYSCTL {
739 _marker: PhantomData<*const ()>,
740}
741unsafe impl Send for SYSCTL {}
742impl SYSCTL {
743 #[doc = r"Returns a pointer to the register block"]
744 #[inline(always)]
745 pub const fn ptr() -> *const sysctl::RegisterBlock {
746 0x4002_3000 as *const _
747 }
748}
749impl Deref for SYSCTL {
750 type Target = sysctl::RegisterBlock;
751 #[inline(always)]
752 fn deref(&self) -> &Self::Target {
753 unsafe { &*SYSCTL::ptr() }
754 }
755}
756#[doc = "system controller"]
757pub mod sysctl;
758#[doc = "Real-Time Clock (RTC)"]
759pub struct RTC {
760 _marker: PhantomData<*const ()>,
761}
762unsafe impl Send for RTC {}
763impl RTC {
764 #[doc = r"Returns a pointer to the register block"]
765 #[inline(always)]
766 pub const fn ptr() -> *const rtc::RegisterBlock {
767 0x4002_c000 as *const _
768 }
769}
770impl Deref for RTC {
771 type Target = rtc::RegisterBlock;
772 #[inline(always)]
773 fn deref(&self) -> &Self::Target {
774 unsafe { &*RTC::ptr() }
775 }
776}
777#[doc = "Real-Time Clock (RTC)"]
778pub mod rtc;
779#[doc = "Synchronous OS/Event timer with Wakeup Timer"]
780pub struct OSTIMER {
781 _marker: PhantomData<*const ()>,
782}
783unsafe impl Send for OSTIMER {}
784impl OSTIMER {
785 #[doc = r"Returns a pointer to the register block"]
786 #[inline(always)]
787 pub const fn ptr() -> *const ostimer::RegisterBlock {
788 0x4002_d000 as *const _
789 }
790}
791impl Deref for OSTIMER {
792 type Target = ostimer::RegisterBlock;
793 #[inline(always)]
794 fn deref(&self) -> &Self::Target {
795 unsafe { &*OSTIMER::ptr() }
796 }
797}
798#[doc = "Synchronous OS/Event timer with Wakeup Timer"]
799pub mod ostimer;
800#[doc = "FLASH"]
801pub struct FLASH {
802 _marker: PhantomData<*const ()>,
803}
804unsafe impl Send for FLASH {}
805impl FLASH {
806 #[doc = r"Returns a pointer to the register block"]
807 #[inline(always)]
808 pub const fn ptr() -> *const flash::RegisterBlock {
809 0x4003_4000 as *const _
810 }
811}
812impl Deref for FLASH {
813 type Target = flash::RegisterBlock;
814 #[inline(always)]
815 fn deref(&self) -> &Self::Target {
816 unsafe { &*FLASH::ptr() }
817 }
818}
819#[doc = "FLASH"]
820pub mod flash;
821#[doc = "PRINCE"]
822pub struct PRINCE {
823 _marker: PhantomData<*const ()>,
824}
825unsafe impl Send for PRINCE {}
826impl PRINCE {
827 #[doc = r"Returns a pointer to the register block"]
828 #[inline(always)]
829 pub const fn ptr() -> *const prince::RegisterBlock {
830 0x4003_5000 as *const _
831 }
832}
833impl Deref for PRINCE {
834 type Target = prince::RegisterBlock;
835 #[inline(always)]
836 fn deref(&self) -> &Self::Target {
837 unsafe { &*PRINCE::ptr() }
838 }
839}
840#[doc = "PRINCE"]
841pub mod prince;
842#[doc = "Universal System Bus Physical Layer"]
843pub struct USBPHY {
844 _marker: PhantomData<*const ()>,
845}
846unsafe impl Send for USBPHY {}
847impl USBPHY {
848 #[doc = r"Returns a pointer to the register block"]
849 #[inline(always)]
850 pub const fn ptr() -> *const usbphy::RegisterBlock {
851 0x4003_8000 as *const _
852 }
853}
854impl Deref for USBPHY {
855 type Target = usbphy::RegisterBlock;
856 #[inline(always)]
857 fn deref(&self) -> &Self::Target {
858 unsafe { &*USBPHY::ptr() }
859 }
860}
861#[doc = "Universal System Bus Physical Layer"]
862pub mod usbphy;
863#[doc = "RNG"]
864pub struct RNG {
865 _marker: PhantomData<*const ()>,
866}
867unsafe impl Send for RNG {}
868impl RNG {
869 #[doc = r"Returns a pointer to the register block"]
870 #[inline(always)]
871 pub const fn ptr() -> *const rng::RegisterBlock {
872 0x4003_a000 as *const _
873 }
874}
875impl Deref for RNG {
876 type Target = rng::RegisterBlock;
877 #[inline(always)]
878 fn deref(&self) -> &Self::Target {
879 unsafe { &*RNG::ptr() }
880 }
881}
882#[doc = "RNG"]
883pub mod rng;
884#[doc = "PUFCTRL"]
885pub struct PUF {
886 _marker: PhantomData<*const ()>,
887}
888unsafe impl Send for PUF {}
889impl PUF {
890 #[doc = r"Returns a pointer to the register block"]
891 #[inline(always)]
892 pub const fn ptr() -> *const puf::RegisterBlock {
893 0x4003_b000 as *const _
894 }
895}
896impl Deref for PUF {
897 type Target = puf::RegisterBlock;
898 #[inline(always)]
899 fn deref(&self) -> &Self::Target {
900 unsafe { &*PUF::ptr() }
901 }
902}
903#[doc = "PUFCTRL"]
904pub mod puf;
905#[doc = "LPC80X Programmable Logic Unit (PLU)"]
906pub struct PLU {
907 _marker: PhantomData<*const ()>,
908}
909unsafe impl Send for PLU {}
910impl PLU {
911 #[doc = r"Returns a pointer to the register block"]
912 #[inline(always)]
913 pub const fn ptr() -> *const plu::RegisterBlock {
914 0x4003_d000 as *const _
915 }
916}
917impl Deref for PLU {
918 type Target = plu::RegisterBlock;
919 #[inline(always)]
920 fn deref(&self) -> &Self::Target {
921 unsafe { &*PLU::ptr() }
922 }
923}
924#[doc = "LPC80X Programmable Logic Unit (PLU)"]
925pub mod plu;
926#[doc = "DMA controller"]
927pub struct DMA0 {
928 _marker: PhantomData<*const ()>,
929}
930unsafe impl Send for DMA0 {}
931impl DMA0 {
932 #[doc = r"Returns a pointer to the register block"]
933 #[inline(always)]
934 pub const fn ptr() -> *const dma0::RegisterBlock {
935 0x4008_2000 as *const _
936 }
937}
938impl Deref for DMA0 {
939 type Target = dma0::RegisterBlock;
940 #[inline(always)]
941 fn deref(&self) -> &Self::Target {
942 unsafe { &*DMA0::ptr() }
943 }
944}
945#[doc = "DMA controller"]
946pub mod dma0;
947#[doc = "DMA controller"]
948pub struct DMA1 {
949 _marker: PhantomData<*const ()>,
950}
951unsafe impl Send for DMA1 {}
952impl DMA1 {
953 #[doc = r"Returns a pointer to the register block"]
954 #[inline(always)]
955 pub const fn ptr() -> *const dma0::RegisterBlock {
956 0x400a_7000 as *const _
957 }
958}
959impl Deref for DMA1 {
960 type Target = dma0::RegisterBlock;
961 #[inline(always)]
962 fn deref(&self) -> &Self::Target {
963 unsafe { &*DMA1::ptr() }
964 }
965}
966#[doc = "USB 2.0 Device Controller"]
967pub struct USB0 {
968 _marker: PhantomData<*const ()>,
969}
970unsafe impl Send for USB0 {}
971impl USB0 {
972 #[doc = r"Returns a pointer to the register block"]
973 #[inline(always)]
974 pub const fn ptr() -> *const usb0::RegisterBlock {
975 0x4008_4000 as *const _
976 }
977}
978impl Deref for USB0 {
979 type Target = usb0::RegisterBlock;
980 #[inline(always)]
981 fn deref(&self) -> &Self::Target {
982 unsafe { &*USB0::ptr() }
983 }
984}
985#[doc = "USB 2.0 Device Controller"]
986pub mod usb0;
987#[doc = "SCTimer/PWM (SCT)"]
988pub struct SCT0 {
989 _marker: PhantomData<*const ()>,
990}
991unsafe impl Send for SCT0 {}
992impl SCT0 {
993 #[doc = r"Returns a pointer to the register block"]
994 #[inline(always)]
995 pub const fn ptr() -> *const sct0::RegisterBlock {
996 0x4008_5000 as *const _
997 }
998}
999impl Deref for SCT0 {
1000 type Target = sct0::RegisterBlock;
1001 #[inline(always)]
1002 fn deref(&self) -> &Self::Target {
1003 unsafe { &*SCT0::ptr() }
1004 }
1005}
1006#[doc = "SCTimer/PWM (SCT)"]
1007pub mod sct0;
1008#[doc = "Flexcomm serial communication"]
1009pub struct FLEXCOMM0 {
1010 _marker: PhantomData<*const ()>,
1011}
1012unsafe impl Send for FLEXCOMM0 {}
1013impl FLEXCOMM0 {
1014 #[doc = r"Returns a pointer to the register block"]
1015 #[inline(always)]
1016 pub const fn ptr() -> *const flexcomm0::RegisterBlock {
1017 0x4008_6000 as *const _
1018 }
1019}
1020impl Deref for FLEXCOMM0 {
1021 type Target = flexcomm0::RegisterBlock;
1022 #[inline(always)]
1023 fn deref(&self) -> &Self::Target {
1024 unsafe { &*FLEXCOMM0::ptr() }
1025 }
1026}
1027#[doc = "Flexcomm serial communication"]
1028pub mod flexcomm0;
1029#[doc = "Flexcomm serial communication"]
1030pub struct FLEXCOMM1 {
1031 _marker: PhantomData<*const ()>,
1032}
1033unsafe impl Send for FLEXCOMM1 {}
1034impl FLEXCOMM1 {
1035 #[doc = r"Returns a pointer to the register block"]
1036 #[inline(always)]
1037 pub const fn ptr() -> *const flexcomm0::RegisterBlock {
1038 0x4008_7000 as *const _
1039 }
1040}
1041impl Deref for FLEXCOMM1 {
1042 type Target = flexcomm0::RegisterBlock;
1043 #[inline(always)]
1044 fn deref(&self) -> &Self::Target {
1045 unsafe { &*FLEXCOMM1::ptr() }
1046 }
1047}
1048#[doc = "Flexcomm serial communication"]
1049pub struct FLEXCOMM2 {
1050 _marker: PhantomData<*const ()>,
1051}
1052unsafe impl Send for FLEXCOMM2 {}
1053impl FLEXCOMM2 {
1054 #[doc = r"Returns a pointer to the register block"]
1055 #[inline(always)]
1056 pub const fn ptr() -> *const flexcomm0::RegisterBlock {
1057 0x4008_8000 as *const _
1058 }
1059}
1060impl Deref for FLEXCOMM2 {
1061 type Target = flexcomm0::RegisterBlock;
1062 #[inline(always)]
1063 fn deref(&self) -> &Self::Target {
1064 unsafe { &*FLEXCOMM2::ptr() }
1065 }
1066}
1067#[doc = "Flexcomm serial communication"]
1068pub struct FLEXCOMM3 {
1069 _marker: PhantomData<*const ()>,
1070}
1071unsafe impl Send for FLEXCOMM3 {}
1072impl FLEXCOMM3 {
1073 #[doc = r"Returns a pointer to the register block"]
1074 #[inline(always)]
1075 pub const fn ptr() -> *const flexcomm0::RegisterBlock {
1076 0x4008_9000 as *const _
1077 }
1078}
1079impl Deref for FLEXCOMM3 {
1080 type Target = flexcomm0::RegisterBlock;
1081 #[inline(always)]
1082 fn deref(&self) -> &Self::Target {
1083 unsafe { &*FLEXCOMM3::ptr() }
1084 }
1085}
1086#[doc = "Flexcomm serial communication"]
1087pub struct FLEXCOMM4 {
1088 _marker: PhantomData<*const ()>,
1089}
1090unsafe impl Send for FLEXCOMM4 {}
1091impl FLEXCOMM4 {
1092 #[doc = r"Returns a pointer to the register block"]
1093 #[inline(always)]
1094 pub const fn ptr() -> *const flexcomm0::RegisterBlock {
1095 0x4008_a000 as *const _
1096 }
1097}
1098impl Deref for FLEXCOMM4 {
1099 type Target = flexcomm0::RegisterBlock;
1100 #[inline(always)]
1101 fn deref(&self) -> &Self::Target {
1102 unsafe { &*FLEXCOMM4::ptr() }
1103 }
1104}
1105#[doc = "Flexcomm serial communication"]
1106pub struct FLEXCOMM5 {
1107 _marker: PhantomData<*const ()>,
1108}
1109unsafe impl Send for FLEXCOMM5 {}
1110impl FLEXCOMM5 {
1111 #[doc = r"Returns a pointer to the register block"]
1112 #[inline(always)]
1113 pub const fn ptr() -> *const flexcomm0::RegisterBlock {
1114 0x4009_6000 as *const _
1115 }
1116}
1117impl Deref for FLEXCOMM5 {
1118 type Target = flexcomm0::RegisterBlock;
1119 #[inline(always)]
1120 fn deref(&self) -> &Self::Target {
1121 unsafe { &*FLEXCOMM5::ptr() }
1122 }
1123}
1124#[doc = "Flexcomm serial communication"]
1125pub struct FLEXCOMM6 {
1126 _marker: PhantomData<*const ()>,
1127}
1128unsafe impl Send for FLEXCOMM6 {}
1129impl FLEXCOMM6 {
1130 #[doc = r"Returns a pointer to the register block"]
1131 #[inline(always)]
1132 pub const fn ptr() -> *const flexcomm0::RegisterBlock {
1133 0x4009_7000 as *const _
1134 }
1135}
1136impl Deref for FLEXCOMM6 {
1137 type Target = flexcomm0::RegisterBlock;
1138 #[inline(always)]
1139 fn deref(&self) -> &Self::Target {
1140 unsafe { &*FLEXCOMM6::ptr() }
1141 }
1142}
1143#[doc = "Flexcomm serial communication"]
1144pub struct FLEXCOMM7 {
1145 _marker: PhantomData<*const ()>,
1146}
1147unsafe impl Send for FLEXCOMM7 {}
1148impl FLEXCOMM7 {
1149 #[doc = r"Returns a pointer to the register block"]
1150 #[inline(always)]
1151 pub const fn ptr() -> *const flexcomm0::RegisterBlock {
1152 0x4009_8000 as *const _
1153 }
1154}
1155impl Deref for FLEXCOMM7 {
1156 type Target = flexcomm0::RegisterBlock;
1157 #[inline(always)]
1158 fn deref(&self) -> &Self::Target {
1159 unsafe { &*FLEXCOMM7::ptr() }
1160 }
1161}
1162#[doc = "Flexcomm serial communication"]
1163pub struct FLEXCOMM8 {
1164 _marker: PhantomData<*const ()>,
1165}
1166unsafe impl Send for FLEXCOMM8 {}
1167impl FLEXCOMM8 {
1168 #[doc = r"Returns a pointer to the register block"]
1169 #[inline(always)]
1170 pub const fn ptr() -> *const flexcomm0::RegisterBlock {
1171 0x4009_f000 as *const _
1172 }
1173}
1174impl Deref for FLEXCOMM8 {
1175 type Target = flexcomm0::RegisterBlock;
1176 #[inline(always)]
1177 fn deref(&self) -> &Self::Target {
1178 unsafe { &*FLEXCOMM8::ptr() }
1179 }
1180}
1181#[doc = "I2C-bus interfaces"]
1182pub struct I2C0 {
1183 _marker: PhantomData<*const ()>,
1184}
1185unsafe impl Send for I2C0 {}
1186impl I2C0 {
1187 #[doc = r"Returns a pointer to the register block"]
1188 #[inline(always)]
1189 pub const fn ptr() -> *const i2c0::RegisterBlock {
1190 0x4008_6000 as *const _
1191 }
1192}
1193impl Deref for I2C0 {
1194 type Target = i2c0::RegisterBlock;
1195 #[inline(always)]
1196 fn deref(&self) -> &Self::Target {
1197 unsafe { &*I2C0::ptr() }
1198 }
1199}
1200#[doc = "I2C-bus interfaces"]
1201pub mod i2c0;
1202#[doc = "I2C-bus interfaces"]
1203pub struct I2C1 {
1204 _marker: PhantomData<*const ()>,
1205}
1206unsafe impl Send for I2C1 {}
1207impl I2C1 {
1208 #[doc = r"Returns a pointer to the register block"]
1209 #[inline(always)]
1210 pub const fn ptr() -> *const i2c0::RegisterBlock {
1211 0x4008_7000 as *const _
1212 }
1213}
1214impl Deref for I2C1 {
1215 type Target = i2c0::RegisterBlock;
1216 #[inline(always)]
1217 fn deref(&self) -> &Self::Target {
1218 unsafe { &*I2C1::ptr() }
1219 }
1220}
1221#[doc = "I2C-bus interfaces"]
1222pub struct I2C2 {
1223 _marker: PhantomData<*const ()>,
1224}
1225unsafe impl Send for I2C2 {}
1226impl I2C2 {
1227 #[doc = r"Returns a pointer to the register block"]
1228 #[inline(always)]
1229 pub const fn ptr() -> *const i2c0::RegisterBlock {
1230 0x4008_8000 as *const _
1231 }
1232}
1233impl Deref for I2C2 {
1234 type Target = i2c0::RegisterBlock;
1235 #[inline(always)]
1236 fn deref(&self) -> &Self::Target {
1237 unsafe { &*I2C2::ptr() }
1238 }
1239}
1240#[doc = "I2C-bus interfaces"]
1241pub struct I2C3 {
1242 _marker: PhantomData<*const ()>,
1243}
1244unsafe impl Send for I2C3 {}
1245impl I2C3 {
1246 #[doc = r"Returns a pointer to the register block"]
1247 #[inline(always)]
1248 pub const fn ptr() -> *const i2c0::RegisterBlock {
1249 0x4008_9000 as *const _
1250 }
1251}
1252impl Deref for I2C3 {
1253 type Target = i2c0::RegisterBlock;
1254 #[inline(always)]
1255 fn deref(&self) -> &Self::Target {
1256 unsafe { &*I2C3::ptr() }
1257 }
1258}
1259#[doc = "I2C-bus interfaces"]
1260pub struct I2C4 {
1261 _marker: PhantomData<*const ()>,
1262}
1263unsafe impl Send for I2C4 {}
1264impl I2C4 {
1265 #[doc = r"Returns a pointer to the register block"]
1266 #[inline(always)]
1267 pub const fn ptr() -> *const i2c0::RegisterBlock {
1268 0x4008_a000 as *const _
1269 }
1270}
1271impl Deref for I2C4 {
1272 type Target = i2c0::RegisterBlock;
1273 #[inline(always)]
1274 fn deref(&self) -> &Self::Target {
1275 unsafe { &*I2C4::ptr() }
1276 }
1277}
1278#[doc = "I2C-bus interfaces"]
1279pub struct I2C5 {
1280 _marker: PhantomData<*const ()>,
1281}
1282unsafe impl Send for I2C5 {}
1283impl I2C5 {
1284 #[doc = r"Returns a pointer to the register block"]
1285 #[inline(always)]
1286 pub const fn ptr() -> *const i2c0::RegisterBlock {
1287 0x4009_6000 as *const _
1288 }
1289}
1290impl Deref for I2C5 {
1291 type Target = i2c0::RegisterBlock;
1292 #[inline(always)]
1293 fn deref(&self) -> &Self::Target {
1294 unsafe { &*I2C5::ptr() }
1295 }
1296}
1297#[doc = "I2C-bus interfaces"]
1298pub struct I2C6 {
1299 _marker: PhantomData<*const ()>,
1300}
1301unsafe impl Send for I2C6 {}
1302impl I2C6 {
1303 #[doc = r"Returns a pointer to the register block"]
1304 #[inline(always)]
1305 pub const fn ptr() -> *const i2c0::RegisterBlock {
1306 0x4009_7000 as *const _
1307 }
1308}
1309impl Deref for I2C6 {
1310 type Target = i2c0::RegisterBlock;
1311 #[inline(always)]
1312 fn deref(&self) -> &Self::Target {
1313 unsafe { &*I2C6::ptr() }
1314 }
1315}
1316#[doc = "I2C-bus interfaces"]
1317pub struct I2C7 {
1318 _marker: PhantomData<*const ()>,
1319}
1320unsafe impl Send for I2C7 {}
1321impl I2C7 {
1322 #[doc = r"Returns a pointer to the register block"]
1323 #[inline(always)]
1324 pub const fn ptr() -> *const i2c0::RegisterBlock {
1325 0x4009_8000 as *const _
1326 }
1327}
1328impl Deref for I2C7 {
1329 type Target = i2c0::RegisterBlock;
1330 #[inline(always)]
1331 fn deref(&self) -> &Self::Target {
1332 unsafe { &*I2C7::ptr() }
1333 }
1334}
1335#[doc = "I2S interface"]
1336pub struct I2S0 {
1337 _marker: PhantomData<*const ()>,
1338}
1339unsafe impl Send for I2S0 {}
1340impl I2S0 {
1341 #[doc = r"Returns a pointer to the register block"]
1342 #[inline(always)]
1343 pub const fn ptr() -> *const i2s0::RegisterBlock {
1344 0x4008_6000 as *const _
1345 }
1346}
1347impl Deref for I2S0 {
1348 type Target = i2s0::RegisterBlock;
1349 #[inline(always)]
1350 fn deref(&self) -> &Self::Target {
1351 unsafe { &*I2S0::ptr() }
1352 }
1353}
1354#[doc = "I2S interface"]
1355pub mod i2s0;
1356#[doc = "I2S interface"]
1357pub struct I2S1 {
1358 _marker: PhantomData<*const ()>,
1359}
1360unsafe impl Send for I2S1 {}
1361impl I2S1 {
1362 #[doc = r"Returns a pointer to the register block"]
1363 #[inline(always)]
1364 pub const fn ptr() -> *const i2s0::RegisterBlock {
1365 0x4008_7000 as *const _
1366 }
1367}
1368impl Deref for I2S1 {
1369 type Target = i2s0::RegisterBlock;
1370 #[inline(always)]
1371 fn deref(&self) -> &Self::Target {
1372 unsafe { &*I2S1::ptr() }
1373 }
1374}
1375#[doc = "I2S interface"]
1376pub struct I2S2 {
1377 _marker: PhantomData<*const ()>,
1378}
1379unsafe impl Send for I2S2 {}
1380impl I2S2 {
1381 #[doc = r"Returns a pointer to the register block"]
1382 #[inline(always)]
1383 pub const fn ptr() -> *const i2s0::RegisterBlock {
1384 0x4008_8000 as *const _
1385 }
1386}
1387impl Deref for I2S2 {
1388 type Target = i2s0::RegisterBlock;
1389 #[inline(always)]
1390 fn deref(&self) -> &Self::Target {
1391 unsafe { &*I2S2::ptr() }
1392 }
1393}
1394#[doc = "I2S interface"]
1395pub struct I2S3 {
1396 _marker: PhantomData<*const ()>,
1397}
1398unsafe impl Send for I2S3 {}
1399impl I2S3 {
1400 #[doc = r"Returns a pointer to the register block"]
1401 #[inline(always)]
1402 pub const fn ptr() -> *const i2s0::RegisterBlock {
1403 0x4008_9000 as *const _
1404 }
1405}
1406impl Deref for I2S3 {
1407 type Target = i2s0::RegisterBlock;
1408 #[inline(always)]
1409 fn deref(&self) -> &Self::Target {
1410 unsafe { &*I2S3::ptr() }
1411 }
1412}
1413#[doc = "I2S interface"]
1414pub struct I2S4 {
1415 _marker: PhantomData<*const ()>,
1416}
1417unsafe impl Send for I2S4 {}
1418impl I2S4 {
1419 #[doc = r"Returns a pointer to the register block"]
1420 #[inline(always)]
1421 pub const fn ptr() -> *const i2s0::RegisterBlock {
1422 0x4008_a000 as *const _
1423 }
1424}
1425impl Deref for I2S4 {
1426 type Target = i2s0::RegisterBlock;
1427 #[inline(always)]
1428 fn deref(&self) -> &Self::Target {
1429 unsafe { &*I2S4::ptr() }
1430 }
1431}
1432#[doc = "I2S interface"]
1433pub struct I2S5 {
1434 _marker: PhantomData<*const ()>,
1435}
1436unsafe impl Send for I2S5 {}
1437impl I2S5 {
1438 #[doc = r"Returns a pointer to the register block"]
1439 #[inline(always)]
1440 pub const fn ptr() -> *const i2s0::RegisterBlock {
1441 0x4009_6000 as *const _
1442 }
1443}
1444impl Deref for I2S5 {
1445 type Target = i2s0::RegisterBlock;
1446 #[inline(always)]
1447 fn deref(&self) -> &Self::Target {
1448 unsafe { &*I2S5::ptr() }
1449 }
1450}
1451#[doc = "I2S interface"]
1452pub struct I2S6 {
1453 _marker: PhantomData<*const ()>,
1454}
1455unsafe impl Send for I2S6 {}
1456impl I2S6 {
1457 #[doc = r"Returns a pointer to the register block"]
1458 #[inline(always)]
1459 pub const fn ptr() -> *const i2s0::RegisterBlock {
1460 0x4009_7000 as *const _
1461 }
1462}
1463impl Deref for I2S6 {
1464 type Target = i2s0::RegisterBlock;
1465 #[inline(always)]
1466 fn deref(&self) -> &Self::Target {
1467 unsafe { &*I2S6::ptr() }
1468 }
1469}
1470#[doc = "I2S interface"]
1471pub struct I2S7 {
1472 _marker: PhantomData<*const ()>,
1473}
1474unsafe impl Send for I2S7 {}
1475impl I2S7 {
1476 #[doc = r"Returns a pointer to the register block"]
1477 #[inline(always)]
1478 pub const fn ptr() -> *const i2s0::RegisterBlock {
1479 0x4009_8000 as *const _
1480 }
1481}
1482impl Deref for I2S7 {
1483 type Target = i2s0::RegisterBlock;
1484 #[inline(always)]
1485 fn deref(&self) -> &Self::Target {
1486 unsafe { &*I2S7::ptr() }
1487 }
1488}
1489#[doc = "Serial Peripheral Interfaces (SPI)"]
1490pub struct SPI0 {
1491 _marker: PhantomData<*const ()>,
1492}
1493unsafe impl Send for SPI0 {}
1494impl SPI0 {
1495 #[doc = r"Returns a pointer to the register block"]
1496 #[inline(always)]
1497 pub const fn ptr() -> *const spi0::RegisterBlock {
1498 0x4008_6000 as *const _
1499 }
1500}
1501impl Deref for SPI0 {
1502 type Target = spi0::RegisterBlock;
1503 #[inline(always)]
1504 fn deref(&self) -> &Self::Target {
1505 unsafe { &*SPI0::ptr() }
1506 }
1507}
1508#[doc = "Serial Peripheral Interfaces (SPI)"]
1509pub mod spi0;
1510#[doc = "Serial Peripheral Interfaces (SPI)"]
1511pub struct SPI1 {
1512 _marker: PhantomData<*const ()>,
1513}
1514unsafe impl Send for SPI1 {}
1515impl SPI1 {
1516 #[doc = r"Returns a pointer to the register block"]
1517 #[inline(always)]
1518 pub const fn ptr() -> *const spi0::RegisterBlock {
1519 0x4008_7000 as *const _
1520 }
1521}
1522impl Deref for SPI1 {
1523 type Target = spi0::RegisterBlock;
1524 #[inline(always)]
1525 fn deref(&self) -> &Self::Target {
1526 unsafe { &*SPI1::ptr() }
1527 }
1528}
1529#[doc = "Serial Peripheral Interfaces (SPI)"]
1530pub struct SPI2 {
1531 _marker: PhantomData<*const ()>,
1532}
1533unsafe impl Send for SPI2 {}
1534impl SPI2 {
1535 #[doc = r"Returns a pointer to the register block"]
1536 #[inline(always)]
1537 pub const fn ptr() -> *const spi0::RegisterBlock {
1538 0x4008_8000 as *const _
1539 }
1540}
1541impl Deref for SPI2 {
1542 type Target = spi0::RegisterBlock;
1543 #[inline(always)]
1544 fn deref(&self) -> &Self::Target {
1545 unsafe { &*SPI2::ptr() }
1546 }
1547}
1548#[doc = "Serial Peripheral Interfaces (SPI)"]
1549pub struct SPI3 {
1550 _marker: PhantomData<*const ()>,
1551}
1552unsafe impl Send for SPI3 {}
1553impl SPI3 {
1554 #[doc = r"Returns a pointer to the register block"]
1555 #[inline(always)]
1556 pub const fn ptr() -> *const spi0::RegisterBlock {
1557 0x4008_9000 as *const _
1558 }
1559}
1560impl Deref for SPI3 {
1561 type Target = spi0::RegisterBlock;
1562 #[inline(always)]
1563 fn deref(&self) -> &Self::Target {
1564 unsafe { &*SPI3::ptr() }
1565 }
1566}
1567#[doc = "Serial Peripheral Interfaces (SPI)"]
1568pub struct SPI4 {
1569 _marker: PhantomData<*const ()>,
1570}
1571unsafe impl Send for SPI4 {}
1572impl SPI4 {
1573 #[doc = r"Returns a pointer to the register block"]
1574 #[inline(always)]
1575 pub const fn ptr() -> *const spi0::RegisterBlock {
1576 0x4008_a000 as *const _
1577 }
1578}
1579impl Deref for SPI4 {
1580 type Target = spi0::RegisterBlock;
1581 #[inline(always)]
1582 fn deref(&self) -> &Self::Target {
1583 unsafe { &*SPI4::ptr() }
1584 }
1585}
1586#[doc = "Serial Peripheral Interfaces (SPI)"]
1587pub struct SPI5 {
1588 _marker: PhantomData<*const ()>,
1589}
1590unsafe impl Send for SPI5 {}
1591impl SPI5 {
1592 #[doc = r"Returns a pointer to the register block"]
1593 #[inline(always)]
1594 pub const fn ptr() -> *const spi0::RegisterBlock {
1595 0x4009_6000 as *const _
1596 }
1597}
1598impl Deref for SPI5 {
1599 type Target = spi0::RegisterBlock;
1600 #[inline(always)]
1601 fn deref(&self) -> &Self::Target {
1602 unsafe { &*SPI5::ptr() }
1603 }
1604}
1605#[doc = "Serial Peripheral Interfaces (SPI)"]
1606pub struct SPI6 {
1607 _marker: PhantomData<*const ()>,
1608}
1609unsafe impl Send for SPI6 {}
1610impl SPI6 {
1611 #[doc = r"Returns a pointer to the register block"]
1612 #[inline(always)]
1613 pub const fn ptr() -> *const spi0::RegisterBlock {
1614 0x4009_7000 as *const _
1615 }
1616}
1617impl Deref for SPI6 {
1618 type Target = spi0::RegisterBlock;
1619 #[inline(always)]
1620 fn deref(&self) -> &Self::Target {
1621 unsafe { &*SPI6::ptr() }
1622 }
1623}
1624#[doc = "Serial Peripheral Interfaces (SPI)"]
1625pub struct SPI7 {
1626 _marker: PhantomData<*const ()>,
1627}
1628unsafe impl Send for SPI7 {}
1629impl SPI7 {
1630 #[doc = r"Returns a pointer to the register block"]
1631 #[inline(always)]
1632 pub const fn ptr() -> *const spi0::RegisterBlock {
1633 0x4009_8000 as *const _
1634 }
1635}
1636impl Deref for SPI7 {
1637 type Target = spi0::RegisterBlock;
1638 #[inline(always)]
1639 fn deref(&self) -> &Self::Target {
1640 unsafe { &*SPI7::ptr() }
1641 }
1642}
1643#[doc = "Serial Peripheral Interfaces (SPI)"]
1644pub struct SPI8 {
1645 _marker: PhantomData<*const ()>,
1646}
1647unsafe impl Send for SPI8 {}
1648impl SPI8 {
1649 #[doc = r"Returns a pointer to the register block"]
1650 #[inline(always)]
1651 pub const fn ptr() -> *const spi0::RegisterBlock {
1652 0x4009_f000 as *const _
1653 }
1654}
1655impl Deref for SPI8 {
1656 type Target = spi0::RegisterBlock;
1657 #[inline(always)]
1658 fn deref(&self) -> &Self::Target {
1659 unsafe { &*SPI8::ptr() }
1660 }
1661}
1662#[doc = "USARTs"]
1663pub struct USART0 {
1664 _marker: PhantomData<*const ()>,
1665}
1666unsafe impl Send for USART0 {}
1667impl USART0 {
1668 #[doc = r"Returns a pointer to the register block"]
1669 #[inline(always)]
1670 pub const fn ptr() -> *const usart0::RegisterBlock {
1671 0x4008_6000 as *const _
1672 }
1673}
1674impl Deref for USART0 {
1675 type Target = usart0::RegisterBlock;
1676 #[inline(always)]
1677 fn deref(&self) -> &Self::Target {
1678 unsafe { &*USART0::ptr() }
1679 }
1680}
1681#[doc = "USARTs"]
1682pub mod usart0;
1683#[doc = "USARTs"]
1684pub struct USART1 {
1685 _marker: PhantomData<*const ()>,
1686}
1687unsafe impl Send for USART1 {}
1688impl USART1 {
1689 #[doc = r"Returns a pointer to the register block"]
1690 #[inline(always)]
1691 pub const fn ptr() -> *const usart0::RegisterBlock {
1692 0x4008_7000 as *const _
1693 }
1694}
1695impl Deref for USART1 {
1696 type Target = usart0::RegisterBlock;
1697 #[inline(always)]
1698 fn deref(&self) -> &Self::Target {
1699 unsafe { &*USART1::ptr() }
1700 }
1701}
1702#[doc = "USARTs"]
1703pub struct USART2 {
1704 _marker: PhantomData<*const ()>,
1705}
1706unsafe impl Send for USART2 {}
1707impl USART2 {
1708 #[doc = r"Returns a pointer to the register block"]
1709 #[inline(always)]
1710 pub const fn ptr() -> *const usart0::RegisterBlock {
1711 0x4008_8000 as *const _
1712 }
1713}
1714impl Deref for USART2 {
1715 type Target = usart0::RegisterBlock;
1716 #[inline(always)]
1717 fn deref(&self) -> &Self::Target {
1718 unsafe { &*USART2::ptr() }
1719 }
1720}
1721#[doc = "USARTs"]
1722pub struct USART3 {
1723 _marker: PhantomData<*const ()>,
1724}
1725unsafe impl Send for USART3 {}
1726impl USART3 {
1727 #[doc = r"Returns a pointer to the register block"]
1728 #[inline(always)]
1729 pub const fn ptr() -> *const usart0::RegisterBlock {
1730 0x4008_9000 as *const _
1731 }
1732}
1733impl Deref for USART3 {
1734 type Target = usart0::RegisterBlock;
1735 #[inline(always)]
1736 fn deref(&self) -> &Self::Target {
1737 unsafe { &*USART3::ptr() }
1738 }
1739}
1740#[doc = "USARTs"]
1741pub struct USART4 {
1742 _marker: PhantomData<*const ()>,
1743}
1744unsafe impl Send for USART4 {}
1745impl USART4 {
1746 #[doc = r"Returns a pointer to the register block"]
1747 #[inline(always)]
1748 pub const fn ptr() -> *const usart0::RegisterBlock {
1749 0x4008_a000 as *const _
1750 }
1751}
1752impl Deref for USART4 {
1753 type Target = usart0::RegisterBlock;
1754 #[inline(always)]
1755 fn deref(&self) -> &Self::Target {
1756 unsafe { &*USART4::ptr() }
1757 }
1758}
1759#[doc = "USARTs"]
1760pub struct USART5 {
1761 _marker: PhantomData<*const ()>,
1762}
1763unsafe impl Send for USART5 {}
1764impl USART5 {
1765 #[doc = r"Returns a pointer to the register block"]
1766 #[inline(always)]
1767 pub const fn ptr() -> *const usart0::RegisterBlock {
1768 0x4009_6000 as *const _
1769 }
1770}
1771impl Deref for USART5 {
1772 type Target = usart0::RegisterBlock;
1773 #[inline(always)]
1774 fn deref(&self) -> &Self::Target {
1775 unsafe { &*USART5::ptr() }
1776 }
1777}
1778#[doc = "USARTs"]
1779pub struct USART6 {
1780 _marker: PhantomData<*const ()>,
1781}
1782unsafe impl Send for USART6 {}
1783impl USART6 {
1784 #[doc = r"Returns a pointer to the register block"]
1785 #[inline(always)]
1786 pub const fn ptr() -> *const usart0::RegisterBlock {
1787 0x4009_7000 as *const _
1788 }
1789}
1790impl Deref for USART6 {
1791 type Target = usart0::RegisterBlock;
1792 #[inline(always)]
1793 fn deref(&self) -> &Self::Target {
1794 unsafe { &*USART6::ptr() }
1795 }
1796}
1797#[doc = "USARTs"]
1798pub struct USART7 {
1799 _marker: PhantomData<*const ()>,
1800}
1801unsafe impl Send for USART7 {}
1802impl USART7 {
1803 #[doc = r"Returns a pointer to the register block"]
1804 #[inline(always)]
1805 pub const fn ptr() -> *const usart0::RegisterBlock {
1806 0x4009_8000 as *const _
1807 }
1808}
1809impl Deref for USART7 {
1810 type Target = usart0::RegisterBlock;
1811 #[inline(always)]
1812 fn deref(&self) -> &Self::Target {
1813 unsafe { &*USART7::ptr() }
1814 }
1815}
1816#[doc = "Mailbox"]
1817pub struct MAILBOX {
1818 _marker: PhantomData<*const ()>,
1819}
1820unsafe impl Send for MAILBOX {}
1821impl MAILBOX {
1822 #[doc = r"Returns a pointer to the register block"]
1823 #[inline(always)]
1824 pub const fn ptr() -> *const mailbox::RegisterBlock {
1825 0x4008_b000 as *const _
1826 }
1827}
1828impl Deref for MAILBOX {
1829 type Target = mailbox::RegisterBlock;
1830 #[inline(always)]
1831 fn deref(&self) -> &Self::Target {
1832 unsafe { &*MAILBOX::ptr() }
1833 }
1834}
1835#[doc = "Mailbox"]
1836pub mod mailbox;
1837#[doc = "General Purpose I/O (GPIO)"]
1838pub struct GPIO {
1839 _marker: PhantomData<*const ()>,
1840}
1841unsafe impl Send for GPIO {}
1842impl GPIO {
1843 #[doc = r"Returns a pointer to the register block"]
1844 #[inline(always)]
1845 pub const fn ptr() -> *const gpio::RegisterBlock {
1846 0x4008_c000 as *const _
1847 }
1848}
1849impl Deref for GPIO {
1850 type Target = gpio::RegisterBlock;
1851 #[inline(always)]
1852 fn deref(&self) -> &Self::Target {
1853 unsafe { &*GPIO::ptr() }
1854 }
1855}
1856#[doc = "General Purpose I/O (GPIO)"]
1857pub mod gpio;
1858#[doc = "USB1 High-speed Device Controller"]
1859pub struct USBHSD {
1860 _marker: PhantomData<*const ()>,
1861}
1862unsafe impl Send for USBHSD {}
1863impl USBHSD {
1864 #[doc = r"Returns a pointer to the register block"]
1865 #[inline(always)]
1866 pub const fn ptr() -> *const usbhsd::RegisterBlock {
1867 0x4009_4000 as *const _
1868 }
1869}
1870impl Deref for USBHSD {
1871 type Target = usbhsd::RegisterBlock;
1872 #[inline(always)]
1873 fn deref(&self) -> &Self::Target {
1874 unsafe { &*USBHSD::ptr() }
1875 }
1876}
1877#[doc = "USB1 High-speed Device Controller"]
1878pub mod usbhsd;
1879#[doc = "CRC engine"]
1880pub struct CRC_ENGINE {
1881 _marker: PhantomData<*const ()>,
1882}
1883unsafe impl Send for CRC_ENGINE {}
1884impl CRC_ENGINE {
1885 #[doc = r"Returns a pointer to the register block"]
1886 #[inline(always)]
1887 pub const fn ptr() -> *const crc_engine::RegisterBlock {
1888 0x4009_5000 as *const _
1889 }
1890}
1891impl Deref for CRC_ENGINE {
1892 type Target = crc_engine::RegisterBlock;
1893 #[inline(always)]
1894 fn deref(&self) -> &Self::Target {
1895 unsafe { &*CRC_ENGINE::ptr() }
1896 }
1897}
1898#[doc = "CRC engine"]
1899pub mod crc_engine;
1900#[doc = "SDMMC"]
1901pub struct SDIF {
1902 _marker: PhantomData<*const ()>,
1903}
1904unsafe impl Send for SDIF {}
1905impl SDIF {
1906 #[doc = r"Returns a pointer to the register block"]
1907 #[inline(always)]
1908 pub const fn ptr() -> *const sdif::RegisterBlock {
1909 0x4009_b000 as *const _
1910 }
1911}
1912impl Deref for SDIF {
1913 type Target = sdif::RegisterBlock;
1914 #[inline(always)]
1915 fn deref(&self) -> &Self::Target {
1916 unsafe { &*SDIF::ptr() }
1917 }
1918}
1919#[doc = "SDMMC"]
1920pub mod sdif;
1921#[doc = "MCU Debugger Mailbox"]
1922pub struct DBGMAILBOX {
1923 _marker: PhantomData<*const ()>,
1924}
1925unsafe impl Send for DBGMAILBOX {}
1926impl DBGMAILBOX {
1927 #[doc = r"Returns a pointer to the register block"]
1928 #[inline(always)]
1929 pub const fn ptr() -> *const dbgmailbox::RegisterBlock {
1930 0x4009_c000 as *const _
1931 }
1932}
1933impl Deref for DBGMAILBOX {
1934 type Target = dbgmailbox::RegisterBlock;
1935 #[inline(always)]
1936 fn deref(&self) -> &Self::Target {
1937 unsafe { &*DBGMAILBOX::ptr() }
1938 }
1939}
1940#[doc = "MCU Debugger Mailbox"]
1941pub mod dbgmailbox;
1942#[doc = "ADC"]
1943pub struct ADC0 {
1944 _marker: PhantomData<*const ()>,
1945}
1946unsafe impl Send for ADC0 {}
1947impl ADC0 {
1948 #[doc = r"Returns a pointer to the register block"]
1949 #[inline(always)]
1950 pub const fn ptr() -> *const adc0::RegisterBlock {
1951 0x400a_0000 as *const _
1952 }
1953}
1954impl Deref for ADC0 {
1955 type Target = adc0::RegisterBlock;
1956 #[inline(always)]
1957 fn deref(&self) -> &Self::Target {
1958 unsafe { &*ADC0::ptr() }
1959 }
1960}
1961#[doc = "ADC"]
1962pub mod adc0;
1963#[doc = "USB0 Full-speed Host controller"]
1964pub struct USBFSH {
1965 _marker: PhantomData<*const ()>,
1966}
1967unsafe impl Send for USBFSH {}
1968impl USBFSH {
1969 #[doc = r"Returns a pointer to the register block"]
1970 #[inline(always)]
1971 pub const fn ptr() -> *const usbfsh::RegisterBlock {
1972 0x400a_2000 as *const _
1973 }
1974}
1975impl Deref for USBFSH {
1976 type Target = usbfsh::RegisterBlock;
1977 #[inline(always)]
1978 fn deref(&self) -> &Self::Target {
1979 unsafe { &*USBFSH::ptr() }
1980 }
1981}
1982#[doc = "USB0 Full-speed Host controller"]
1983pub mod usbfsh;
1984#[doc = "USB1 High-speed Host Controller"]
1985pub struct USBHSH {
1986 _marker: PhantomData<*const ()>,
1987}
1988unsafe impl Send for USBHSH {}
1989impl USBHSH {
1990 #[doc = r"Returns a pointer to the register block"]
1991 #[inline(always)]
1992 pub const fn ptr() -> *const usbhsh::RegisterBlock {
1993 0x400a_3000 as *const _
1994 }
1995}
1996impl Deref for USBHSH {
1997 type Target = usbhsh::RegisterBlock;
1998 #[inline(always)]
1999 fn deref(&self) -> &Self::Target {
2000 unsafe { &*USBHSH::ptr() }
2001 }
2002}
2003#[doc = "USB1 High-speed Host Controller"]
2004pub mod usbhsh;
2005#[doc = "Hash-Crypt peripheral"]
2006pub struct HASHCRYPT {
2007 _marker: PhantomData<*const ()>,
2008}
2009unsafe impl Send for HASHCRYPT {}
2010impl HASHCRYPT {
2011 #[doc = r"Returns a pointer to the register block"]
2012 #[inline(always)]
2013 pub const fn ptr() -> *const hashcrypt::RegisterBlock {
2014 0x400a_4000 as *const _
2015 }
2016}
2017impl Deref for HASHCRYPT {
2018 type Target = hashcrypt::RegisterBlock;
2019 #[inline(always)]
2020 fn deref(&self) -> &Self::Target {
2021 unsafe { &*HASHCRYPT::ptr() }
2022 }
2023}
2024#[doc = "Hash-Crypt peripheral"]
2025pub mod hashcrypt;
2026#[doc = "CASPER"]
2027pub struct CASPER {
2028 _marker: PhantomData<*const ()>,
2029}
2030unsafe impl Send for CASPER {}
2031impl CASPER {
2032 #[doc = r"Returns a pointer to the register block"]
2033 #[inline(always)]
2034 pub const fn ptr() -> *const casper::RegisterBlock {
2035 0x400a_5000 as *const _
2036 }
2037}
2038impl Deref for CASPER {
2039 type Target = casper::RegisterBlock;
2040 #[inline(always)]
2041 fn deref(&self) -> &Self::Target {
2042 unsafe { &*CASPER::ptr() }
2043 }
2044}
2045#[doc = "CASPER"]
2046pub mod casper;
2047#[doc = "Digital Signal Co-Processing companion to a Cortex-M v8M CPU core"]
2048pub struct POWERQUAD {
2049 _marker: PhantomData<*const ()>,
2050}
2051unsafe impl Send for POWERQUAD {}
2052impl POWERQUAD {
2053 #[doc = r"Returns a pointer to the register block"]
2054 #[inline(always)]
2055 pub const fn ptr() -> *const powerquad::RegisterBlock {
2056 0x400a_6000 as *const _
2057 }
2058}
2059impl Deref for POWERQUAD {
2060 type Target = powerquad::RegisterBlock;
2061 #[inline(always)]
2062 fn deref(&self) -> &Self::Target {
2063 unsafe { &*POWERQUAD::ptr() }
2064 }
2065}
2066#[doc = "Digital Signal Co-Processing companion to a Cortex-M v8M CPU core"]
2067pub mod powerquad;
2068#[doc = "General Purpose I/O (GPIO)"]
2069pub struct SECGPIO {
2070 _marker: PhantomData<*const ()>,
2071}
2072unsafe impl Send for SECGPIO {}
2073impl SECGPIO {
2074 #[doc = r"Returns a pointer to the register block"]
2075 #[inline(always)]
2076 pub const fn ptr() -> *const secgpio::RegisterBlock {
2077 0x400a_8000 as *const _
2078 }
2079}
2080impl Deref for SECGPIO {
2081 type Target = secgpio::RegisterBlock;
2082 #[inline(always)]
2083 fn deref(&self) -> &Self::Target {
2084 unsafe { &*SECGPIO::ptr() }
2085 }
2086}
2087#[doc = "General Purpose I/O (GPIO)"]
2088pub mod secgpio;
2089#[doc = "AHB secure controller"]
2090pub struct AHB_SECURE_CTRL {
2091 _marker: PhantomData<*const ()>,
2092}
2093unsafe impl Send for AHB_SECURE_CTRL {}
2094impl AHB_SECURE_CTRL {
2095 #[doc = r"Returns a pointer to the register block"]
2096 #[inline(always)]
2097 pub const fn ptr() -> *const ahb_secure_ctrl::RegisterBlock {
2098 0x400a_c000 as *const _
2099 }
2100}
2101impl Deref for AHB_SECURE_CTRL {
2102 type Target = ahb_secure_ctrl::RegisterBlock;
2103 #[inline(always)]
2104 fn deref(&self) -> &Self::Target {
2105 unsafe { &*AHB_SECURE_CTRL::ptr() }
2106 }
2107}
2108#[doc = "AHB secure controller"]
2109pub mod ahb_secure_ctrl;
2110#[doc = "no description available"]
2111pub struct SCNSCB {
2112 _marker: PhantomData<*const ()>,
2113}
2114unsafe impl Send for SCNSCB {}
2115impl SCNSCB {
2116 #[doc = r"Returns a pointer to the register block"]
2117 #[inline(always)]
2118 pub const fn ptr() -> *const scn_scb::RegisterBlock {
2119 0xe000_e000 as *const _
2120 }
2121}
2122impl Deref for SCNSCB {
2123 type Target = scn_scb::RegisterBlock;
2124 #[inline(always)]
2125 fn deref(&self) -> &Self::Target {
2126 unsafe { &*SCNSCB::ptr() }
2127 }
2128}
2129#[doc = "no description available"]
2130pub mod scn_scb;
2131#[doc = "no description available"]
2132pub struct SAU {
2133 _marker: PhantomData<*const ()>,
2134}
2135unsafe impl Send for SAU {}
2136impl SAU {
2137 #[doc = r"Returns a pointer to the register block"]
2138 #[inline(always)]
2139 pub const fn ptr() -> *const sau::RegisterBlock {
2140 0xe000_edd0 as *const _
2141 }
2142}
2143impl Deref for SAU {
2144 type Target = sau::RegisterBlock;
2145 #[inline(always)]
2146 fn deref(&self) -> &Self::Target {
2147 unsafe { &*SAU::ptr() }
2148 }
2149}
2150#[doc = "no description available"]
2151pub mod sau;
2152#[no_mangle]
2153static mut DEVICE_PERIPHERALS: bool = false;
2154#[doc = r"All the peripherals"]
2155#[allow(non_snake_case)]
2156pub struct Peripherals {
2157 #[doc = "FLASH_CFPA0"]
2158 pub FLASH_CFPA0: FLASH_CFPA0,
2159 #[doc = "FLASH_CFPA_SCRATCH"]
2160 pub FLASH_CFPA_SCRATCH: FLASH_CFPA_SCRATCH,
2161 #[doc = "FLASH_CFPA1"]
2162 pub FLASH_CFPA1: FLASH_CFPA1,
2163 #[doc = "FLASH_CMPA"]
2164 pub FLASH_CMPA: FLASH_CMPA,
2165 #[doc = "FLASH_KEY_STORE"]
2166 pub FLASH_KEY_STORE: FLASH_KEY_STORE,
2167 #[doc = "SYSCON"]
2168 pub SYSCON: SYSCON,
2169 #[doc = "IOCON"]
2170 pub IOCON: IOCON,
2171 #[doc = "GINT0"]
2172 pub GINT0: GINT0,
2173 #[doc = "GINT1"]
2174 pub GINT1: GINT1,
2175 #[doc = "PINT"]
2176 pub PINT: PINT,
2177 #[doc = "SECPINT"]
2178 pub SECPINT: SECPINT,
2179 #[doc = "INPUTMUX"]
2180 pub INPUTMUX: INPUTMUX,
2181 #[doc = "CTIMER0"]
2182 pub CTIMER0: CTIMER0,
2183 #[doc = "CTIMER1"]
2184 pub CTIMER1: CTIMER1,
2185 #[doc = "CTIMER2"]
2186 pub CTIMER2: CTIMER2,
2187 #[doc = "CTIMER3"]
2188 pub CTIMER3: CTIMER3,
2189 #[doc = "CTIMER4"]
2190 pub CTIMER4: CTIMER4,
2191 #[doc = "WWDT"]
2192 pub WWDT: WWDT,
2193 #[doc = "MRT0"]
2194 pub MRT0: MRT0,
2195 #[doc = "UTICK0"]
2196 pub UTICK0: UTICK0,
2197 #[doc = "ANACTRL"]
2198 pub ANACTRL: ANACTRL,
2199 #[doc = "PMC"]
2200 pub PMC: PMC,
2201 #[doc = "SYSCTL"]
2202 pub SYSCTL: SYSCTL,
2203 #[doc = "RTC"]
2204 pub RTC: RTC,
2205 #[doc = "OSTIMER"]
2206 pub OSTIMER: OSTIMER,
2207 #[doc = "FLASH"]
2208 pub FLASH: FLASH,
2209 #[doc = "PRINCE"]
2210 pub PRINCE: PRINCE,
2211 #[doc = "USBPHY"]
2212 pub USBPHY: USBPHY,
2213 #[doc = "RNG"]
2214 pub RNG: RNG,
2215 #[doc = "PUF"]
2216 pub PUF: PUF,
2217 #[doc = "PLU"]
2218 pub PLU: PLU,
2219 #[doc = "DMA0"]
2220 pub DMA0: DMA0,
2221 #[doc = "DMA1"]
2222 pub DMA1: DMA1,
2223 #[doc = "USB0"]
2224 pub USB0: USB0,
2225 #[doc = "SCT0"]
2226 pub SCT0: SCT0,
2227 #[doc = "FLEXCOMM0"]
2228 pub FLEXCOMM0: FLEXCOMM0,
2229 #[doc = "FLEXCOMM1"]
2230 pub FLEXCOMM1: FLEXCOMM1,
2231 #[doc = "FLEXCOMM2"]
2232 pub FLEXCOMM2: FLEXCOMM2,
2233 #[doc = "FLEXCOMM3"]
2234 pub FLEXCOMM3: FLEXCOMM3,
2235 #[doc = "FLEXCOMM4"]
2236 pub FLEXCOMM4: FLEXCOMM4,
2237 #[doc = "FLEXCOMM5"]
2238 pub FLEXCOMM5: FLEXCOMM5,
2239 #[doc = "FLEXCOMM6"]
2240 pub FLEXCOMM6: FLEXCOMM6,
2241 #[doc = "FLEXCOMM7"]
2242 pub FLEXCOMM7: FLEXCOMM7,
2243 #[doc = "FLEXCOMM8"]
2244 pub FLEXCOMM8: FLEXCOMM8,
2245 #[doc = "I2C0"]
2246 pub I2C0: I2C0,
2247 #[doc = "I2C1"]
2248 pub I2C1: I2C1,
2249 #[doc = "I2C2"]
2250 pub I2C2: I2C2,
2251 #[doc = "I2C3"]
2252 pub I2C3: I2C3,
2253 #[doc = "I2C4"]
2254 pub I2C4: I2C4,
2255 #[doc = "I2C5"]
2256 pub I2C5: I2C5,
2257 #[doc = "I2C6"]
2258 pub I2C6: I2C6,
2259 #[doc = "I2C7"]
2260 pub I2C7: I2C7,
2261 #[doc = "I2S0"]
2262 pub I2S0: I2S0,
2263 #[doc = "I2S1"]
2264 pub I2S1: I2S1,
2265 #[doc = "I2S2"]
2266 pub I2S2: I2S2,
2267 #[doc = "I2S3"]
2268 pub I2S3: I2S3,
2269 #[doc = "I2S4"]
2270 pub I2S4: I2S4,
2271 #[doc = "I2S5"]
2272 pub I2S5: I2S5,
2273 #[doc = "I2S6"]
2274 pub I2S6: I2S6,
2275 #[doc = "I2S7"]
2276 pub I2S7: I2S7,
2277 #[doc = "SPI0"]
2278 pub SPI0: SPI0,
2279 #[doc = "SPI1"]
2280 pub SPI1: SPI1,
2281 #[doc = "SPI2"]
2282 pub SPI2: SPI2,
2283 #[doc = "SPI3"]
2284 pub SPI3: SPI3,
2285 #[doc = "SPI4"]
2286 pub SPI4: SPI4,
2287 #[doc = "SPI5"]
2288 pub SPI5: SPI5,
2289 #[doc = "SPI6"]
2290 pub SPI6: SPI6,
2291 #[doc = "SPI7"]
2292 pub SPI7: SPI7,
2293 #[doc = "SPI8"]
2294 pub SPI8: SPI8,
2295 #[doc = "USART0"]
2296 pub USART0: USART0,
2297 #[doc = "USART1"]
2298 pub USART1: USART1,
2299 #[doc = "USART2"]
2300 pub USART2: USART2,
2301 #[doc = "USART3"]
2302 pub USART3: USART3,
2303 #[doc = "USART4"]
2304 pub USART4: USART4,
2305 #[doc = "USART5"]
2306 pub USART5: USART5,
2307 #[doc = "USART6"]
2308 pub USART6: USART6,
2309 #[doc = "USART7"]
2310 pub USART7: USART7,
2311 #[doc = "MAILBOX"]
2312 pub MAILBOX: MAILBOX,
2313 #[doc = "GPIO"]
2314 pub GPIO: GPIO,
2315 #[doc = "USBHSD"]
2316 pub USBHSD: USBHSD,
2317 #[doc = "CRC_ENGINE"]
2318 pub CRC_ENGINE: CRC_ENGINE,
2319 #[doc = "SDIF"]
2320 pub SDIF: SDIF,
2321 #[doc = "DBGMAILBOX"]
2322 pub DBGMAILBOX: DBGMAILBOX,
2323 #[doc = "ADC0"]
2324 pub ADC0: ADC0,
2325 #[doc = "USBFSH"]
2326 pub USBFSH: USBFSH,
2327 #[doc = "USBHSH"]
2328 pub USBHSH: USBHSH,
2329 #[doc = "HASHCRYPT"]
2330 pub HASHCRYPT: HASHCRYPT,
2331 #[doc = "CASPER"]
2332 pub CASPER: CASPER,
2333 #[doc = "POWERQUAD"]
2334 pub POWERQUAD: POWERQUAD,
2335 #[doc = "SECGPIO"]
2336 pub SECGPIO: SECGPIO,
2337 #[doc = "AHB_SECURE_CTRL"]
2338 pub AHB_SECURE_CTRL: AHB_SECURE_CTRL,
2339 #[doc = "SCNSCB"]
2340 pub SCNSCB: SCNSCB,
2341 #[doc = "SAU"]
2342 pub SAU: SAU,
2343}
2344impl Peripherals {
2345 #[doc = r"Returns all the peripherals *once*"]
2346 #[inline]
2347 pub fn take() -> Option<Self> {
2348 cortex_m::interrupt::free(|_| {
2349 if unsafe { DEVICE_PERIPHERALS } {
2350 None
2351 } else {
2352 Some(unsafe { Peripherals::steal() })
2353 }
2354 })
2355 }
2356 #[doc = r"Unchecked version of `Peripherals::take`"]
2357 #[inline]
2358 pub unsafe fn steal() -> Self {
2359 DEVICE_PERIPHERALS = true;
2360 Peripherals {
2361 FLASH_CFPA0: FLASH_CFPA0 {
2362 _marker: PhantomData,
2363 },
2364 FLASH_CFPA_SCRATCH: FLASH_CFPA_SCRATCH {
2365 _marker: PhantomData,
2366 },
2367 FLASH_CFPA1: FLASH_CFPA1 {
2368 _marker: PhantomData,
2369 },
2370 FLASH_CMPA: FLASH_CMPA {
2371 _marker: PhantomData,
2372 },
2373 FLASH_KEY_STORE: FLASH_KEY_STORE {
2374 _marker: PhantomData,
2375 },
2376 SYSCON: SYSCON {
2377 _marker: PhantomData,
2378 },
2379 IOCON: IOCON {
2380 _marker: PhantomData,
2381 },
2382 GINT0: GINT0 {
2383 _marker: PhantomData,
2384 },
2385 GINT1: GINT1 {
2386 _marker: PhantomData,
2387 },
2388 PINT: PINT {
2389 _marker: PhantomData,
2390 },
2391 SECPINT: SECPINT {
2392 _marker: PhantomData,
2393 },
2394 INPUTMUX: INPUTMUX {
2395 _marker: PhantomData,
2396 },
2397 CTIMER0: CTIMER0 {
2398 _marker: PhantomData,
2399 },
2400 CTIMER1: CTIMER1 {
2401 _marker: PhantomData,
2402 },
2403 CTIMER2: CTIMER2 {
2404 _marker: PhantomData,
2405 },
2406 CTIMER3: CTIMER3 {
2407 _marker: PhantomData,
2408 },
2409 CTIMER4: CTIMER4 {
2410 _marker: PhantomData,
2411 },
2412 WWDT: WWDT {
2413 _marker: PhantomData,
2414 },
2415 MRT0: MRT0 {
2416 _marker: PhantomData,
2417 },
2418 UTICK0: UTICK0 {
2419 _marker: PhantomData,
2420 },
2421 ANACTRL: ANACTRL {
2422 _marker: PhantomData,
2423 },
2424 PMC: PMC {
2425 _marker: PhantomData,
2426 },
2427 SYSCTL: SYSCTL {
2428 _marker: PhantomData,
2429 },
2430 RTC: RTC {
2431 _marker: PhantomData,
2432 },
2433 OSTIMER: OSTIMER {
2434 _marker: PhantomData,
2435 },
2436 FLASH: FLASH {
2437 _marker: PhantomData,
2438 },
2439 PRINCE: PRINCE {
2440 _marker: PhantomData,
2441 },
2442 USBPHY: USBPHY {
2443 _marker: PhantomData,
2444 },
2445 RNG: RNG {
2446 _marker: PhantomData,
2447 },
2448 PUF: PUF {
2449 _marker: PhantomData,
2450 },
2451 PLU: PLU {
2452 _marker: PhantomData,
2453 },
2454 DMA0: DMA0 {
2455 _marker: PhantomData,
2456 },
2457 DMA1: DMA1 {
2458 _marker: PhantomData,
2459 },
2460 USB0: USB0 {
2461 _marker: PhantomData,
2462 },
2463 SCT0: SCT0 {
2464 _marker: PhantomData,
2465 },
2466 FLEXCOMM0: FLEXCOMM0 {
2467 _marker: PhantomData,
2468 },
2469 FLEXCOMM1: FLEXCOMM1 {
2470 _marker: PhantomData,
2471 },
2472 FLEXCOMM2: FLEXCOMM2 {
2473 _marker: PhantomData,
2474 },
2475 FLEXCOMM3: FLEXCOMM3 {
2476 _marker: PhantomData,
2477 },
2478 FLEXCOMM4: FLEXCOMM4 {
2479 _marker: PhantomData,
2480 },
2481 FLEXCOMM5: FLEXCOMM5 {
2482 _marker: PhantomData,
2483 },
2484 FLEXCOMM6: FLEXCOMM6 {
2485 _marker: PhantomData,
2486 },
2487 FLEXCOMM7: FLEXCOMM7 {
2488 _marker: PhantomData,
2489 },
2490 FLEXCOMM8: FLEXCOMM8 {
2491 _marker: PhantomData,
2492 },
2493 I2C0: I2C0 {
2494 _marker: PhantomData,
2495 },
2496 I2C1: I2C1 {
2497 _marker: PhantomData,
2498 },
2499 I2C2: I2C2 {
2500 _marker: PhantomData,
2501 },
2502 I2C3: I2C3 {
2503 _marker: PhantomData,
2504 },
2505 I2C4: I2C4 {
2506 _marker: PhantomData,
2507 },
2508 I2C5: I2C5 {
2509 _marker: PhantomData,
2510 },
2511 I2C6: I2C6 {
2512 _marker: PhantomData,
2513 },
2514 I2C7: I2C7 {
2515 _marker: PhantomData,
2516 },
2517 I2S0: I2S0 {
2518 _marker: PhantomData,
2519 },
2520 I2S1: I2S1 {
2521 _marker: PhantomData,
2522 },
2523 I2S2: I2S2 {
2524 _marker: PhantomData,
2525 },
2526 I2S3: I2S3 {
2527 _marker: PhantomData,
2528 },
2529 I2S4: I2S4 {
2530 _marker: PhantomData,
2531 },
2532 I2S5: I2S5 {
2533 _marker: PhantomData,
2534 },
2535 I2S6: I2S6 {
2536 _marker: PhantomData,
2537 },
2538 I2S7: I2S7 {
2539 _marker: PhantomData,
2540 },
2541 SPI0: SPI0 {
2542 _marker: PhantomData,
2543 },
2544 SPI1: SPI1 {
2545 _marker: PhantomData,
2546 },
2547 SPI2: SPI2 {
2548 _marker: PhantomData,
2549 },
2550 SPI3: SPI3 {
2551 _marker: PhantomData,
2552 },
2553 SPI4: SPI4 {
2554 _marker: PhantomData,
2555 },
2556 SPI5: SPI5 {
2557 _marker: PhantomData,
2558 },
2559 SPI6: SPI6 {
2560 _marker: PhantomData,
2561 },
2562 SPI7: SPI7 {
2563 _marker: PhantomData,
2564 },
2565 SPI8: SPI8 {
2566 _marker: PhantomData,
2567 },
2568 USART0: USART0 {
2569 _marker: PhantomData,
2570 },
2571 USART1: USART1 {
2572 _marker: PhantomData,
2573 },
2574 USART2: USART2 {
2575 _marker: PhantomData,
2576 },
2577 USART3: USART3 {
2578 _marker: PhantomData,
2579 },
2580 USART4: USART4 {
2581 _marker: PhantomData,
2582 },
2583 USART5: USART5 {
2584 _marker: PhantomData,
2585 },
2586 USART6: USART6 {
2587 _marker: PhantomData,
2588 },
2589 USART7: USART7 {
2590 _marker: PhantomData,
2591 },
2592 MAILBOX: MAILBOX {
2593 _marker: PhantomData,
2594 },
2595 GPIO: GPIO {
2596 _marker: PhantomData,
2597 },
2598 USBHSD: USBHSD {
2599 _marker: PhantomData,
2600 },
2601 CRC_ENGINE: CRC_ENGINE {
2602 _marker: PhantomData,
2603 },
2604 SDIF: SDIF {
2605 _marker: PhantomData,
2606 },
2607 DBGMAILBOX: DBGMAILBOX {
2608 _marker: PhantomData,
2609 },
2610 ADC0: ADC0 {
2611 _marker: PhantomData,
2612 },
2613 USBFSH: USBFSH {
2614 _marker: PhantomData,
2615 },
2616 USBHSH: USBHSH {
2617 _marker: PhantomData,
2618 },
2619 HASHCRYPT: HASHCRYPT {
2620 _marker: PhantomData,
2621 },
2622 CASPER: CASPER {
2623 _marker: PhantomData,
2624 },
2625 POWERQUAD: POWERQUAD {
2626 _marker: PhantomData,
2627 },
2628 SECGPIO: SECGPIO {
2629 _marker: PhantomData,
2630 },
2631 AHB_SECURE_CTRL: AHB_SECURE_CTRL {
2632 _marker: PhantomData,
2633 },
2634 SCNSCB: SCNSCB {
2635 _marker: PhantomData,
2636 },
2637 SAU: SAU {
2638 _marker: PhantomData,
2639 },
2640 }
2641 }
2642}