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