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