1#[derive(Copy, Clone, Debug, PartialEq, Eq)]
2pub enum Interrupt {
3 #[doc = "0 - DMA0"]
4 DMA0 = 0,
5 #[doc = "1 - DMA1"]
6 DMA1 = 1,
7 #[doc = "2 - DMA2"]
8 DMA2 = 2,
9 #[doc = "3 - DMA3"]
10 DMA3 = 3,
11 #[doc = "4 - DMA4"]
12 DMA4 = 4,
13 #[doc = "5 - DMA5"]
14 DMA5 = 5,
15 #[doc = "6 - DMA6"]
16 DMA6 = 6,
17 #[doc = "7 - DMA7"]
18 DMA7 = 7,
19 #[doc = "8 - DMA8"]
20 DMA8 = 8,
21 #[doc = "9 - DMA9"]
22 DMA9 = 9,
23 #[doc = "10 - DMA10"]
24 DMA10 = 10,
25 #[doc = "11 - DMA11"]
26 DMA11 = 11,
27 #[doc = "12 - DMA12"]
28 DMA12 = 12,
29 #[doc = "13 - DMA13"]
30 DMA13 = 13,
31 #[doc = "14 - DMA14"]
32 DMA14 = 14,
33 #[doc = "15 - DMA15"]
34 DMA15 = 15,
35 #[doc = "16 - DMA_ERROR"]
36 DMA_ERROR = 16,
37 #[doc = "20 - LPUART1"]
38 LPUART1 = 20,
39 #[doc = "21 - LPUART2"]
40 LPUART2 = 21,
41 #[doc = "22 - LPUART3"]
42 LPUART3 = 22,
43 #[doc = "23 - LPUART4"]
44 LPUART4 = 23,
45 #[doc = "24 - PIT"]
46 PIT = 24,
47 #[doc = "25 - USB_OTG1"]
48 USB_OTG1 = 25,
49 #[doc = "26 - FLEXSPI"]
50 FLEXSPI = 26,
51 #[doc = "27 - FLEXRAM"]
52 FLEXRAM = 27,
53 #[doc = "28 - LPI2C1"]
54 LPI2C1 = 28,
55 #[doc = "29 - LPI2C2"]
56 LPI2C2 = 29,
57 #[doc = "30 - GPT1"]
58 GPT1 = 30,
59 #[doc = "31 - GPT2"]
60 GPT2 = 31,
61 #[doc = "32 - LPSPI1"]
62 LPSPI1 = 32,
63 #[doc = "33 - LPSPI2"]
64 LPSPI2 = 33,
65 #[doc = "34 - PWM1_0"]
66 PWM1_0 = 34,
67 #[doc = "35 - PWM1_1"]
68 PWM1_1 = 35,
69 #[doc = "36 - PWM1_2"]
70 PWM1_2 = 36,
71 #[doc = "37 - PWM1_3"]
72 PWM1_3 = 37,
73 #[doc = "38 - PWM1_FAULT"]
74 PWM1_FAULT = 38,
75 #[doc = "39 - KPP"]
76 KPP = 39,
77 #[doc = "40 - SRC"]
78 SRC = 40,
79 #[doc = "41 - GPR (aka \"GPC\") interrupt request"]
80 GPR_IRQ = 41,
81 #[doc = "42 - CCM_1"]
82 CCM_1 = 42,
83 #[doc = "43 - CCM_2"]
84 CCM_2 = 43,
85 #[doc = "44 - EWM"]
86 EWM = 44,
87 #[doc = "45 - WDOG2"]
88 WDOG2 = 45,
89 #[doc = "46 - SNVS_HP_WRAPPER"]
90 SNVS_HP_WRAPPER = 46,
91 #[doc = "47 - SNVS_HP_WRAPPER_TZ"]
92 SNVS_HP_WRAPPER_TZ = 47,
93 #[doc = "48 - SNVS_LP_WRAPPER"]
94 SNVS_LP_WRAPPER = 48,
95 #[doc = "49 - CSU"]
96 CSU = 49,
97 #[doc = "50 - DCP"]
98 DCP = 50,
99 #[doc = "51 - DCP_VMI"]
100 DCP_VMI = 51,
101 #[doc = "53 - TRNG"]
102 TRNG = 53,
103 #[doc = "56 - SAI1"]
104 SAI1 = 56,
105 #[doc = "57 - RTWDOG"]
106 RTWDOG = 57,
107 #[doc = "58 - SAI3_RX"]
108 SAI3_RX = 58,
109 #[doc = "59 - SAI3_TX"]
110 SAI3_TX = 59,
111 #[doc = "60 - SPDIF"]
112 SPDIF = 60,
113 #[doc = "61 - PMU"]
114 PMU = 61,
115 #[doc = "62 - XBAR1_IRQ_0_1_2_3"]
116 XBAR1_IRQ_0_1_2_3 = 62,
117 #[doc = "63 - TEMP_LOW_HIGH"]
118 TEMP_LOW_HIGH = 63,
119 #[doc = "64 - TEMP_PANIC"]
120 TEMP_PANIC = 64,
121 #[doc = "65 - USB_PHY"]
122 USB_PHY = 65,
123 #[doc = "66 - GPC"]
124 GPC = 66,
125 #[doc = "67 - ADC1"]
126 ADC1 = 67,
127 #[doc = "68 - FLEXIO1"]
128 FLEXIO1 = 68,
129 #[doc = "69 - DCDC"]
130 DCDC = 69,
131 #[doc = "70 - GPIO1_COMBINED_0_15"]
132 GPIO1_COMBINED_0_15 = 70,
133 #[doc = "71 - GPIO1_COMBINED_16_31"]
134 GPIO1_COMBINED_16_31 = 71,
135 #[doc = "72 - GPIO2_COMBINED_0_15"]
136 GPIO2_COMBINED_0_15 = 72,
137 #[doc = "73 - GPIO5_COMBINED_0_15"]
138 GPIO5_COMBINED_0_15 = 73,
139 #[doc = "74 - WDOG1"]
140 WDOG1 = 74,
141 #[doc = "75 - ADC_ETC_IRQ0"]
142 ADC_ETC_IRQ0 = 75,
143 #[doc = "76 - ADC_ETC_IRQ1"]
144 ADC_ETC_IRQ1 = 76,
145 #[doc = "77 - ADC_ETC_IRQ2"]
146 ADC_ETC_IRQ2 = 77,
147 #[doc = "78 - ADC_ETC_IRQ3"]
148 ADC_ETC_IRQ3 = 78,
149 #[doc = "79 - ADC_ETC_ERROR_IRQ"]
150 ADC_ETC_ERROR_IRQ = 79,
151}
152pub type interrupt = Interrupt;
153unsafe impl cortex_m::interrupt::InterruptNumber for Interrupt {
154 #[inline(always)]
155 fn number(self) -> u16 {
156 self as u16
157 }
158}
159#[cfg(all(feature = "rt", target_os = "none"))]
160mod _vectors {
161 extern "C" {
162 fn DMA0();
163 fn DMA1();
164 fn DMA2();
165 fn DMA3();
166 fn DMA4();
167 fn DMA5();
168 fn DMA6();
169 fn DMA7();
170 fn DMA8();
171 fn DMA9();
172 fn DMA10();
173 fn DMA11();
174 fn DMA12();
175 fn DMA13();
176 fn DMA14();
177 fn DMA15();
178 fn DMA_ERROR();
179 fn LPUART1();
180 fn LPUART2();
181 fn LPUART3();
182 fn LPUART4();
183 fn PIT();
184 fn USB_OTG1();
185 fn FLEXSPI();
186 fn FLEXRAM();
187 fn LPI2C1();
188 fn LPI2C2();
189 fn GPT1();
190 fn GPT2();
191 fn LPSPI1();
192 fn LPSPI2();
193 fn PWM1_0();
194 fn PWM1_1();
195 fn PWM1_2();
196 fn PWM1_3();
197 fn PWM1_FAULT();
198 fn KPP();
199 fn SRC();
200 fn GPR_IRQ();
201 fn CCM_1();
202 fn CCM_2();
203 fn EWM();
204 fn WDOG2();
205 fn SNVS_HP_WRAPPER();
206 fn SNVS_HP_WRAPPER_TZ();
207 fn SNVS_LP_WRAPPER();
208 fn CSU();
209 fn DCP();
210 fn DCP_VMI();
211 fn TRNG();
212 fn SAI1();
213 fn RTWDOG();
214 fn SAI3_RX();
215 fn SAI3_TX();
216 fn SPDIF();
217 fn PMU();
218 fn XBAR1_IRQ_0_1_2_3();
219 fn TEMP_LOW_HIGH();
220 fn TEMP_PANIC();
221 fn USB_PHY();
222 fn GPC();
223 fn ADC1();
224 fn FLEXIO1();
225 fn DCDC();
226 fn GPIO1_COMBINED_0_15();
227 fn GPIO1_COMBINED_16_31();
228 fn GPIO2_COMBINED_0_15();
229 fn GPIO5_COMBINED_0_15();
230 fn WDOG1();
231 fn ADC_ETC_IRQ0();
232 fn ADC_ETC_IRQ1();
233 fn ADC_ETC_IRQ2();
234 fn ADC_ETC_IRQ3();
235 fn ADC_ETC_ERROR_IRQ();
236 }
237 pub union Vector {
238 _handler: unsafe extern "C" fn(),
239 _reserved: u32,
240 }
241 #[cfg_attr(target_os = "none", link_section = ".vector_table.interrupts")]
242 #[no_mangle]
243 pub static __INTERRUPTS: [Vector; 80] = [
244 Vector { _handler: DMA0 },
245 Vector { _handler: DMA1 },
246 Vector { _handler: DMA2 },
247 Vector { _handler: DMA3 },
248 Vector { _handler: DMA4 },
249 Vector { _handler: DMA5 },
250 Vector { _handler: DMA6 },
251 Vector { _handler: DMA7 },
252 Vector { _handler: DMA8 },
253 Vector { _handler: DMA9 },
254 Vector { _handler: DMA10 },
255 Vector { _handler: DMA11 },
256 Vector { _handler: DMA12 },
257 Vector { _handler: DMA13 },
258 Vector { _handler: DMA14 },
259 Vector { _handler: DMA15 },
260 Vector {
261 _handler: DMA_ERROR,
262 },
263 Vector { _reserved: 0 },
264 Vector { _reserved: 0 },
265 Vector { _reserved: 0 },
266 Vector { _handler: LPUART1 },
267 Vector { _handler: LPUART2 },
268 Vector { _handler: LPUART3 },
269 Vector { _handler: LPUART4 },
270 Vector { _handler: PIT },
271 Vector { _handler: USB_OTG1 },
272 Vector { _handler: FLEXSPI },
273 Vector { _handler: FLEXRAM },
274 Vector { _handler: LPI2C1 },
275 Vector { _handler: LPI2C2 },
276 Vector { _handler: GPT1 },
277 Vector { _handler: GPT2 },
278 Vector { _handler: LPSPI1 },
279 Vector { _handler: LPSPI2 },
280 Vector { _handler: PWM1_0 },
281 Vector { _handler: PWM1_1 },
282 Vector { _handler: PWM1_2 },
283 Vector { _handler: PWM1_3 },
284 Vector {
285 _handler: PWM1_FAULT,
286 },
287 Vector { _handler: KPP },
288 Vector { _handler: SRC },
289 Vector { _handler: GPR_IRQ },
290 Vector { _handler: CCM_1 },
291 Vector { _handler: CCM_2 },
292 Vector { _handler: EWM },
293 Vector { _handler: WDOG2 },
294 Vector {
295 _handler: SNVS_HP_WRAPPER,
296 },
297 Vector {
298 _handler: SNVS_HP_WRAPPER_TZ,
299 },
300 Vector {
301 _handler: SNVS_LP_WRAPPER,
302 },
303 Vector { _handler: CSU },
304 Vector { _handler: DCP },
305 Vector { _handler: DCP_VMI },
306 Vector { _reserved: 0 },
307 Vector { _handler: TRNG },
308 Vector { _reserved: 0 },
309 Vector { _reserved: 0 },
310 Vector { _handler: SAI1 },
311 Vector { _handler: RTWDOG },
312 Vector { _handler: SAI3_RX },
313 Vector { _handler: SAI3_TX },
314 Vector { _handler: SPDIF },
315 Vector { _handler: PMU },
316 Vector {
317 _handler: XBAR1_IRQ_0_1_2_3,
318 },
319 Vector {
320 _handler: TEMP_LOW_HIGH,
321 },
322 Vector {
323 _handler: TEMP_PANIC,
324 },
325 Vector { _handler: USB_PHY },
326 Vector { _handler: GPC },
327 Vector { _handler: ADC1 },
328 Vector { _handler: FLEXIO1 },
329 Vector { _handler: DCDC },
330 Vector {
331 _handler: GPIO1_COMBINED_0_15,
332 },
333 Vector {
334 _handler: GPIO1_COMBINED_16_31,
335 },
336 Vector {
337 _handler: GPIO2_COMBINED_0_15,
338 },
339 Vector {
340 _handler: GPIO5_COMBINED_0_15,
341 },
342 Vector { _handler: WDOG1 },
343 Vector {
344 _handler: ADC_ETC_IRQ0,
345 },
346 Vector {
347 _handler: ADC_ETC_IRQ1,
348 },
349 Vector {
350 _handler: ADC_ETC_IRQ2,
351 },
352 Vector {
353 _handler: ADC_ETC_IRQ3,
354 },
355 Vector {
356 _handler: ADC_ETC_ERROR_IRQ,
357 },
358 ];
359}
360#[path = "."]
361pub mod adc {
362 #[doc = "Analog-to-Digital Converter"]
363 pub const ADC: *const RegisterBlock = 0x400c_4000 as *const RegisterBlock;
364 #[path = "blocks/imxrt1011/adc.rs"]
365 mod blocks;
366 pub use blocks::*;
367 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
368 pub type ADC = Instance<{ crate::SOLE_INSTANCE }>;
369 impl crate::private::Sealed for ADC {}
370 impl crate::Valid for ADC {}
371 impl ADC {
372 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
373 #[doc = r""]
374 #[doc = r" # Safety"]
375 #[doc = r""]
376 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
377 #[inline]
378 pub const unsafe fn instance() -> Self {
379 Instance::new(ADC)
380 }
381 }
382 #[doc = r" Returns the instance number `N` for a peripheral instance."]
383 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
384 core::ptr::eq(rb, ADC).then_some(0)
385 }
386}
387#[path = "."]
388pub mod adc_etc {
389 #[doc = "ADC_ETC"]
390 pub const ADC_ETC: *const RegisterBlock = 0x4008_8000 as *const RegisterBlock;
391 #[path = "blocks/imxrt1011/adc_etc.rs"]
392 mod blocks;
393 pub use blocks::*;
394 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
395 pub type ADC_ETC = Instance<{ crate::SOLE_INSTANCE }>;
396 impl crate::private::Sealed for ADC_ETC {}
397 impl crate::Valid for ADC_ETC {}
398 impl ADC_ETC {
399 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
400 #[doc = r""]
401 #[doc = r" # Safety"]
402 #[doc = r""]
403 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
404 #[inline]
405 pub const unsafe fn instance() -> Self {
406 Instance::new(ADC_ETC)
407 }
408 }
409 #[doc = r" Returns the instance number `N` for a peripheral instance."]
410 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
411 core::ptr::eq(rb, ADC_ETC).then_some(0)
412 }
413}
414#[path = "."]
415pub mod aipstz {
416 #[doc = "AIPSTZ Control Registers"]
417 pub const AIPSTZ1: *const RegisterBlock = 0x4007_c000 as *const RegisterBlock;
418 #[doc = "AIPSTZ Control Registers"]
419 pub const AIPSTZ2: *const RegisterBlock = 0x4017_c000 as *const RegisterBlock;
420 #[path = "blocks/imxrt1011/aipstz.rs"]
421 mod blocks;
422 pub use blocks::*;
423 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
424 pub type AIPSTZ1 = Instance<1>;
425 impl crate::private::Sealed for AIPSTZ1 {}
426 impl crate::Valid for AIPSTZ1 {}
427 impl AIPSTZ1 {
428 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
429 #[doc = r""]
430 #[doc = r" # Safety"]
431 #[doc = r""]
432 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
433 #[inline]
434 pub const unsafe fn instance() -> Self {
435 Instance::new(AIPSTZ1)
436 }
437 }
438 pub type AIPSTZ2 = Instance<2>;
439 impl crate::private::Sealed for AIPSTZ2 {}
440 impl crate::Valid for AIPSTZ2 {}
441 impl AIPSTZ2 {
442 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
443 #[doc = r""]
444 #[doc = r" # Safety"]
445 #[doc = r""]
446 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
447 #[inline]
448 pub const unsafe fn instance() -> Self {
449 Instance::new(AIPSTZ2)
450 }
451 }
452 #[doc = r" Returns the instance number `N` for a peripheral instance."]
453 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
454 [(AIPSTZ1, 1), (AIPSTZ2, 2)]
455 .into_iter()
456 .find(|(ptr, _)| core::ptr::eq(rb, *ptr))
457 .map(|(_, inst)| inst)
458 }
459}
460#[path = "."]
461pub mod aoi {
462 #[doc = "AND/OR/INVERT module"]
463 pub const AOI: *const RegisterBlock = 0x4009_4000 as *const RegisterBlock;
464 #[path = "blocks/imxrt1011/aoi.rs"]
465 mod blocks;
466 pub use blocks::*;
467 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
468 pub type AOI = Instance<{ crate::SOLE_INSTANCE }>;
469 impl crate::private::Sealed for AOI {}
470 impl crate::Valid for AOI {}
471 impl AOI {
472 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
473 #[doc = r""]
474 #[doc = r" # Safety"]
475 #[doc = r""]
476 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
477 #[inline]
478 pub const unsafe fn instance() -> Self {
479 Instance::new(AOI)
480 }
481 }
482 #[doc = r" Returns the instance number `N` for a peripheral instance."]
483 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
484 core::ptr::eq(rb, AOI).then_some(0)
485 }
486}
487#[path = "."]
488pub mod ccm {
489 #[doc = "CCM"]
490 pub const CCM: *const RegisterBlock = 0x400f_c000 as *const RegisterBlock;
491 #[path = "blocks/imxrt1011/ccm.rs"]
492 mod blocks;
493 pub use blocks::*;
494 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
495 pub type CCM = Instance<{ crate::SOLE_INSTANCE }>;
496 impl crate::private::Sealed for CCM {}
497 impl crate::Valid for CCM {}
498 impl CCM {
499 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
500 #[doc = r""]
501 #[doc = r" # Safety"]
502 #[doc = r""]
503 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
504 #[inline]
505 pub const unsafe fn instance() -> Self {
506 Instance::new(CCM)
507 }
508 }
509 #[doc = r" Returns the instance number `N` for a peripheral instance."]
510 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
511 core::ptr::eq(rb, CCM).then_some(0)
512 }
513}
514#[path = "."]
515pub mod ccm_analog {
516 #[doc = "CCM_ANALOG"]
517 pub const CCM_ANALOG: *const RegisterBlock = 0x400d_8000 as *const RegisterBlock;
518 #[path = "blocks/imxrt1011/ccm_analog.rs"]
519 mod blocks;
520 pub use blocks::*;
521 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
522 pub type CCM_ANALOG = Instance<{ crate::SOLE_INSTANCE }>;
523 impl crate::private::Sealed for CCM_ANALOG {}
524 impl crate::Valid for CCM_ANALOG {}
525 impl CCM_ANALOG {
526 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
527 #[doc = r""]
528 #[doc = r" # Safety"]
529 #[doc = r""]
530 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
531 #[inline]
532 pub const unsafe fn instance() -> Self {
533 Instance::new(CCM_ANALOG)
534 }
535 }
536 #[doc = r" Returns the instance number `N` for a peripheral instance."]
537 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
538 core::ptr::eq(rb, CCM_ANALOG).then_some(0)
539 }
540}
541#[path = "."]
542pub mod csu {
543 #[doc = "CSU registers"]
544 pub const CSU: *const RegisterBlock = 0x400d_c000 as *const RegisterBlock;
545 #[path = "blocks/imxrt1011/csu.rs"]
546 mod blocks;
547 pub use blocks::*;
548 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
549 pub type CSU = Instance<{ crate::SOLE_INSTANCE }>;
550 impl crate::private::Sealed for CSU {}
551 impl crate::Valid for CSU {}
552 impl CSU {
553 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
554 #[doc = r""]
555 #[doc = r" # Safety"]
556 #[doc = r""]
557 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
558 #[inline]
559 pub const unsafe fn instance() -> Self {
560 Instance::new(CSU)
561 }
562 }
563 #[doc = r" Returns the instance number `N` for a peripheral instance."]
564 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
565 core::ptr::eq(rb, CSU).then_some(0)
566 }
567}
568#[path = "."]
569pub mod dcdc {
570 #[doc = "DCDC"]
571 pub const DCDC: *const RegisterBlock = 0x4008_0000 as *const RegisterBlock;
572 #[path = "blocks/imxrt1011/dcdc.rs"]
573 mod blocks;
574 pub use blocks::*;
575 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
576 pub type DCDC = Instance<{ crate::SOLE_INSTANCE }>;
577 impl crate::private::Sealed for DCDC {}
578 impl crate::Valid for DCDC {}
579 impl DCDC {
580 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
581 #[doc = r""]
582 #[doc = r" # Safety"]
583 #[doc = r""]
584 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
585 #[inline]
586 pub const unsafe fn instance() -> Self {
587 Instance::new(DCDC)
588 }
589 }
590 #[doc = r" Returns the instance number `N` for a peripheral instance."]
591 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
592 core::ptr::eq(rb, DCDC).then_some(0)
593 }
594}
595#[path = "."]
596pub mod dcp {
597 #[doc = "DCP register reference index"]
598 pub const DCP: *const RegisterBlock = 0x400f_0000 as *const RegisterBlock;
599 #[path = "blocks/imxrt1011/dcp.rs"]
600 mod blocks;
601 pub use blocks::*;
602 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
603 pub type DCP = Instance<{ crate::SOLE_INSTANCE }>;
604 impl crate::private::Sealed for DCP {}
605 impl crate::Valid for DCP {}
606 impl DCP {
607 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
608 #[doc = r""]
609 #[doc = r" # Safety"]
610 #[doc = r""]
611 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
612 #[inline]
613 pub const unsafe fn instance() -> Self {
614 Instance::new(DCP)
615 }
616 }
617 #[doc = r" Returns the instance number `N` for a peripheral instance."]
618 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
619 core::ptr::eq(rb, DCP).then_some(0)
620 }
621}
622#[path = "."]
623pub mod dma {
624 #[doc = "DMA"]
625 pub const DMA: *const RegisterBlock = 0x400e_8000 as *const RegisterBlock;
626 #[path = "blocks/imxrt1011/dma.rs"]
627 mod blocks;
628 pub use blocks::*;
629 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
630 pub type DMA = Instance<{ crate::SOLE_INSTANCE }>;
631 impl crate::private::Sealed for DMA {}
632 impl crate::Valid for DMA {}
633 impl DMA {
634 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
635 #[doc = r""]
636 #[doc = r" # Safety"]
637 #[doc = r""]
638 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
639 #[inline]
640 pub const unsafe fn instance() -> Self {
641 Instance::new(DMA)
642 }
643 }
644 #[doc = r" Returns the instance number `N` for a peripheral instance."]
645 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
646 core::ptr::eq(rb, DMA).then_some(0)
647 }
648}
649#[path = "."]
650pub mod dmamux {
651 #[doc = "DMAMUX"]
652 pub const DMAMUX: *const RegisterBlock = 0x400e_c000 as *const RegisterBlock;
653 #[path = "blocks/imxrt1011/dmamux.rs"]
654 mod blocks;
655 pub use blocks::*;
656 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
657 pub type DMAMUX = Instance<{ crate::SOLE_INSTANCE }>;
658 impl crate::private::Sealed for DMAMUX {}
659 impl crate::Valid for DMAMUX {}
660 impl DMAMUX {
661 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
662 #[doc = r""]
663 #[doc = r" # Safety"]
664 #[doc = r""]
665 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
666 #[inline]
667 pub const unsafe fn instance() -> Self {
668 Instance::new(DMAMUX)
669 }
670 }
671 #[doc = r" Returns the instance number `N` for a peripheral instance."]
672 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
673 core::ptr::eq(rb, DMAMUX).then_some(0)
674 }
675}
676#[path = "."]
677pub mod ewm {
678 #[doc = "EWM"]
679 pub const EWM: *const RegisterBlock = 0x400b_4000 as *const RegisterBlock;
680 #[path = "blocks/imxrt1011/ewm.rs"]
681 mod blocks;
682 pub use blocks::*;
683 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
684 pub type EWM = Instance<{ crate::SOLE_INSTANCE }>;
685 impl crate::private::Sealed for EWM {}
686 impl crate::Valid for EWM {}
687 impl EWM {
688 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
689 #[doc = r""]
690 #[doc = r" # Safety"]
691 #[doc = r""]
692 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
693 #[inline]
694 pub const unsafe fn instance() -> Self {
695 Instance::new(EWM)
696 }
697 }
698 #[doc = r" Returns the instance number `N` for a peripheral instance."]
699 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
700 core::ptr::eq(rb, EWM).then_some(0)
701 }
702}
703#[path = "."]
704pub mod flexio {
705 #[doc = "FLEXIO"]
706 pub const FLEXIO: *const RegisterBlock = 0x401a_c000 as *const RegisterBlock;
707 #[path = "blocks/imxrt1011/flexio.rs"]
708 pub(super) mod blocks;
709 pub use blocks::*;
710 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
711 pub type FLEXIO = Instance<{ crate::SOLE_INSTANCE }>;
712 impl crate::private::Sealed for FLEXIO {}
713 impl crate::Valid for FLEXIO {}
714 impl FLEXIO {
715 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
716 #[doc = r""]
717 #[doc = r" # Safety"]
718 #[doc = r""]
719 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
720 #[inline]
721 pub const unsafe fn instance() -> Self {
722 Instance::new(FLEXIO)
723 }
724 }
725 #[doc = r" Returns the instance number `N` for a peripheral instance."]
726 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
727 core::ptr::eq(rb, FLEXIO).then_some(0)
728 }
729}
730#[deprecated(since = "0.5.1", note = "Use 'flexio'")]
731pub mod flexio1 {
732 pub use super::flexio::{blocks::*, number, Instance, FLEXIO as FLEXIO1};
733}
734#[path = "."]
735pub mod flexram {
736 #[doc = "FLEXRAM"]
737 pub const FLEXRAM: *const RegisterBlock = 0x400b_0000 as *const RegisterBlock;
738 #[path = "blocks/imxrt1011/flexram.rs"]
739 mod blocks;
740 pub use blocks::*;
741 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
742 pub type FLEXRAM = Instance<{ crate::SOLE_INSTANCE }>;
743 impl crate::private::Sealed for FLEXRAM {}
744 impl crate::Valid for FLEXRAM {}
745 impl FLEXRAM {
746 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
747 #[doc = r""]
748 #[doc = r" # Safety"]
749 #[doc = r""]
750 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
751 #[inline]
752 pub const unsafe fn instance() -> Self {
753 Instance::new(FLEXRAM)
754 }
755 }
756 #[doc = r" Returns the instance number `N` for a peripheral instance."]
757 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
758 core::ptr::eq(rb, FLEXRAM).then_some(0)
759 }
760}
761#[path = "."]
762pub mod flexspi {
763 #[doc = "FlexSPI"]
764 pub const FLEXSPI: *const RegisterBlock = 0x400a_0000 as *const RegisterBlock;
765 #[path = "blocks/imxrt1011/flexspi.rs"]
766 mod blocks;
767 pub use blocks::*;
768 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
769 pub type FLEXSPI = Instance<{ crate::SOLE_INSTANCE }>;
770 impl crate::private::Sealed for FLEXSPI {}
771 impl crate::Valid for FLEXSPI {}
772 impl FLEXSPI {
773 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
774 #[doc = r""]
775 #[doc = r" # Safety"]
776 #[doc = r""]
777 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
778 #[inline]
779 pub const unsafe fn instance() -> Self {
780 Instance::new(FLEXSPI)
781 }
782 }
783 #[doc = r" Returns the instance number `N` for a peripheral instance."]
784 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
785 core::ptr::eq(rb, FLEXSPI).then_some(0)
786 }
787}
788#[path = "."]
789pub mod gpc {
790 #[doc = "GPC"]
791 pub const GPC: *const RegisterBlock = 0x400f_4000 as *const RegisterBlock;
792 #[path = "blocks/imxrt1011/gpc.rs"]
793 mod blocks;
794 pub use blocks::*;
795 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
796 pub type GPC = Instance<{ crate::SOLE_INSTANCE }>;
797 impl crate::private::Sealed for GPC {}
798 impl crate::Valid for GPC {}
799 impl GPC {
800 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
801 #[doc = r""]
802 #[doc = r" # Safety"]
803 #[doc = r""]
804 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
805 #[inline]
806 pub const unsafe fn instance() -> Self {
807 Instance::new(GPC)
808 }
809 }
810 #[doc = r" Returns the instance number `N` for a peripheral instance."]
811 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
812 core::ptr::eq(rb, GPC).then_some(0)
813 }
814}
815#[path = "."]
816pub mod gpio {
817 #[doc = "GPIO"]
818 pub const GPIO1: *const RegisterBlock = 0x401b_8000 as *const RegisterBlock;
819 #[doc = "GPIO"]
820 pub const GPIO5: *const RegisterBlock = 0x400c_0000 as *const RegisterBlock;
821 #[doc = "GPIO"]
822 pub const GPIO2: *const RegisterBlock = 0x4200_0000 as *const RegisterBlock;
823 #[path = "blocks/imxrt1011/gpio.rs"]
824 mod blocks;
825 pub use blocks::*;
826 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
827 pub type GPIO1 = Instance<1>;
828 impl crate::private::Sealed for GPIO1 {}
829 impl crate::Valid for GPIO1 {}
830 impl GPIO1 {
831 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
832 #[doc = r""]
833 #[doc = r" # Safety"]
834 #[doc = r""]
835 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
836 #[inline]
837 pub const unsafe fn instance() -> Self {
838 Instance::new(GPIO1)
839 }
840 }
841 pub type GPIO5 = Instance<5>;
842 impl crate::private::Sealed for GPIO5 {}
843 impl crate::Valid for GPIO5 {}
844 impl GPIO5 {
845 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
846 #[doc = r""]
847 #[doc = r" # Safety"]
848 #[doc = r""]
849 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
850 #[inline]
851 pub const unsafe fn instance() -> Self {
852 Instance::new(GPIO5)
853 }
854 }
855 pub type GPIO2 = Instance<2>;
856 impl crate::private::Sealed for GPIO2 {}
857 impl crate::Valid for GPIO2 {}
858 impl GPIO2 {
859 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
860 #[doc = r""]
861 #[doc = r" # Safety"]
862 #[doc = r""]
863 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
864 #[inline]
865 pub const unsafe fn instance() -> Self {
866 Instance::new(GPIO2)
867 }
868 }
869 #[doc = r" Returns the instance number `N` for a peripheral instance."]
870 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
871 [(GPIO1, 1), (GPIO5, 5), (GPIO2, 2)]
872 .into_iter()
873 .find(|(ptr, _)| core::ptr::eq(rb, *ptr))
874 .map(|(_, inst)| inst)
875 }
876}
877#[path = "."]
878pub mod gpt {
879 #[doc = "GPT"]
880 pub const GPT1: *const RegisterBlock = 0x401e_c000 as *const RegisterBlock;
881 #[doc = "GPT"]
882 pub const GPT2: *const RegisterBlock = 0x401f_0000 as *const RegisterBlock;
883 #[path = "blocks/imxrt1011/gpt.rs"]
884 mod blocks;
885 pub use blocks::*;
886 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
887 pub type GPT1 = Instance<1>;
888 impl crate::private::Sealed for GPT1 {}
889 impl crate::Valid for GPT1 {}
890 impl GPT1 {
891 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
892 #[doc = r""]
893 #[doc = r" # Safety"]
894 #[doc = r""]
895 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
896 #[inline]
897 pub const unsafe fn instance() -> Self {
898 Instance::new(GPT1)
899 }
900 }
901 pub type GPT2 = Instance<2>;
902 impl crate::private::Sealed for GPT2 {}
903 impl crate::Valid for GPT2 {}
904 impl GPT2 {
905 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
906 #[doc = r""]
907 #[doc = r" # Safety"]
908 #[doc = r""]
909 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
910 #[inline]
911 pub const unsafe fn instance() -> Self {
912 Instance::new(GPT2)
913 }
914 }
915 #[doc = r" Returns the instance number `N` for a peripheral instance."]
916 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
917 [(GPT1, 1), (GPT2, 2)]
918 .into_iter()
919 .find(|(ptr, _)| core::ptr::eq(rb, *ptr))
920 .map(|(_, inst)| inst)
921 }
922}
923#[path = "."]
924pub mod iomuxc {
925 #[doc = "IOMUXC"]
926 pub const IOMUXC: *const RegisterBlock = 0x401f_8000 as *const RegisterBlock;
927 #[path = "blocks/imxrt1011/iomuxc.rs"]
928 mod blocks;
929 pub use blocks::*;
930 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
931 pub type IOMUXC = Instance<{ crate::SOLE_INSTANCE }>;
932 impl crate::private::Sealed for IOMUXC {}
933 impl crate::Valid for IOMUXC {}
934 impl IOMUXC {
935 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
936 #[doc = r""]
937 #[doc = r" # Safety"]
938 #[doc = r""]
939 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
940 #[inline]
941 pub const unsafe fn instance() -> Self {
942 Instance::new(IOMUXC)
943 }
944 }
945 #[doc = r" Returns the instance number `N` for a peripheral instance."]
946 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
947 core::ptr::eq(rb, IOMUXC).then_some(0)
948 }
949}
950#[path = "."]
951pub mod iomuxc_gpr {
952 #[doc = "IOMUXC_GPR"]
953 pub const IOMUXC_GPR: *const RegisterBlock = 0x400a_c000 as *const RegisterBlock;
954 #[path = "blocks/imxrt1011/iomuxc_gpr.rs"]
955 mod blocks;
956 pub use blocks::*;
957 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
958 pub type IOMUXC_GPR = Instance<{ crate::SOLE_INSTANCE }>;
959 impl crate::private::Sealed for IOMUXC_GPR {}
960 impl crate::Valid for IOMUXC_GPR {}
961 impl IOMUXC_GPR {
962 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
963 #[doc = r""]
964 #[doc = r" # Safety"]
965 #[doc = r""]
966 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
967 #[inline]
968 pub const unsafe fn instance() -> Self {
969 Instance::new(IOMUXC_GPR)
970 }
971 }
972 #[doc = r" Returns the instance number `N` for a peripheral instance."]
973 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
974 core::ptr::eq(rb, IOMUXC_GPR).then_some(0)
975 }
976}
977#[path = "."]
978pub mod iomuxc_snvs {
979 #[doc = "IOMUXC_SNVS"]
980 pub const IOMUXC_SNVS: *const RegisterBlock = 0x400a_8000 as *const RegisterBlock;
981 #[path = "blocks/imxrt1011/iomuxc_snvs.rs"]
982 mod blocks;
983 pub use blocks::*;
984 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
985 pub type IOMUXC_SNVS = Instance<{ crate::SOLE_INSTANCE }>;
986 impl crate::private::Sealed for IOMUXC_SNVS {}
987 impl crate::Valid for IOMUXC_SNVS {}
988 impl IOMUXC_SNVS {
989 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
990 #[doc = r""]
991 #[doc = r" # Safety"]
992 #[doc = r""]
993 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
994 #[inline]
995 pub const unsafe fn instance() -> Self {
996 Instance::new(IOMUXC_SNVS)
997 }
998 }
999 #[doc = r" Returns the instance number `N` for a peripheral instance."]
1000 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
1001 core::ptr::eq(rb, IOMUXC_SNVS).then_some(0)
1002 }
1003}
1004#[path = "."]
1005pub mod iomuxc_snvs_gpr {
1006 #[doc = "IOMUXC"]
1007 pub const IOMUXC_SNVS_GPR: *const RegisterBlock = 0x400a_4000 as *const RegisterBlock;
1008 #[path = "blocks/imxrt1011/iomuxc_snvs_gpr.rs"]
1009 mod blocks;
1010 pub use blocks::*;
1011 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
1012 pub type IOMUXC_SNVS_GPR = Instance<{ crate::SOLE_INSTANCE }>;
1013 impl crate::private::Sealed for IOMUXC_SNVS_GPR {}
1014 impl crate::Valid for IOMUXC_SNVS_GPR {}
1015 impl IOMUXC_SNVS_GPR {
1016 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1017 #[doc = r""]
1018 #[doc = r" # Safety"]
1019 #[doc = r""]
1020 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1021 #[inline]
1022 pub const unsafe fn instance() -> Self {
1023 Instance::new(IOMUXC_SNVS_GPR)
1024 }
1025 }
1026 #[doc = r" Returns the instance number `N` for a peripheral instance."]
1027 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
1028 core::ptr::eq(rb, IOMUXC_SNVS_GPR).then_some(0)
1029 }
1030}
1031#[path = "."]
1032pub mod kpp {
1033 #[doc = "KPP Registers"]
1034 pub const KPP: *const RegisterBlock = 0x401f_c000 as *const RegisterBlock;
1035 #[path = "blocks/imxrt1011/kpp.rs"]
1036 mod blocks;
1037 pub use blocks::*;
1038 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
1039 pub type KPP = Instance<{ crate::SOLE_INSTANCE }>;
1040 impl crate::private::Sealed for KPP {}
1041 impl crate::Valid for KPP {}
1042 impl KPP {
1043 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1044 #[doc = r""]
1045 #[doc = r" # Safety"]
1046 #[doc = r""]
1047 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1048 #[inline]
1049 pub const unsafe fn instance() -> Self {
1050 Instance::new(KPP)
1051 }
1052 }
1053 #[doc = r" Returns the instance number `N` for a peripheral instance."]
1054 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
1055 core::ptr::eq(rb, KPP).then_some(0)
1056 }
1057}
1058#[path = "."]
1059pub mod lpi2c {
1060 #[doc = "LPI2C"]
1061 pub const LPI2C1: *const RegisterBlock = 0x401a_4000 as *const RegisterBlock;
1062 #[doc = "LPI2C"]
1063 pub const LPI2C2: *const RegisterBlock = 0x401a_8000 as *const RegisterBlock;
1064 #[path = "blocks/imxrt1011/lpi2c.rs"]
1065 mod blocks;
1066 pub use blocks::*;
1067 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
1068 pub type LPI2C1 = Instance<1>;
1069 impl crate::private::Sealed for LPI2C1 {}
1070 impl crate::Valid for LPI2C1 {}
1071 impl LPI2C1 {
1072 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1073 #[doc = r""]
1074 #[doc = r" # Safety"]
1075 #[doc = r""]
1076 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1077 #[inline]
1078 pub const unsafe fn instance() -> Self {
1079 Instance::new(LPI2C1)
1080 }
1081 }
1082 pub type LPI2C2 = Instance<2>;
1083 impl crate::private::Sealed for LPI2C2 {}
1084 impl crate::Valid for LPI2C2 {}
1085 impl LPI2C2 {
1086 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1087 #[doc = r""]
1088 #[doc = r" # Safety"]
1089 #[doc = r""]
1090 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1091 #[inline]
1092 pub const unsafe fn instance() -> Self {
1093 Instance::new(LPI2C2)
1094 }
1095 }
1096 #[doc = r" Returns the instance number `N` for a peripheral instance."]
1097 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
1098 [(LPI2C1, 1), (LPI2C2, 2)]
1099 .into_iter()
1100 .find(|(ptr, _)| core::ptr::eq(rb, *ptr))
1101 .map(|(_, inst)| inst)
1102 }
1103}
1104#[path = "."]
1105pub mod lpspi {
1106 #[doc = "LPSPI"]
1107 pub const LPSPI1: *const RegisterBlock = 0x4019_4000 as *const RegisterBlock;
1108 #[doc = "LPSPI"]
1109 pub const LPSPI2: *const RegisterBlock = 0x4019_8000 as *const RegisterBlock;
1110 #[path = "blocks/imxrt1011/lpspi.rs"]
1111 mod blocks;
1112 pub use blocks::*;
1113 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
1114 pub type LPSPI1 = Instance<1>;
1115 impl crate::private::Sealed for LPSPI1 {}
1116 impl crate::Valid for LPSPI1 {}
1117 impl LPSPI1 {
1118 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1119 #[doc = r""]
1120 #[doc = r" # Safety"]
1121 #[doc = r""]
1122 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1123 #[inline]
1124 pub const unsafe fn instance() -> Self {
1125 Instance::new(LPSPI1)
1126 }
1127 }
1128 pub type LPSPI2 = Instance<2>;
1129 impl crate::private::Sealed for LPSPI2 {}
1130 impl crate::Valid for LPSPI2 {}
1131 impl LPSPI2 {
1132 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1133 #[doc = r""]
1134 #[doc = r" # Safety"]
1135 #[doc = r""]
1136 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1137 #[inline]
1138 pub const unsafe fn instance() -> Self {
1139 Instance::new(LPSPI2)
1140 }
1141 }
1142 #[doc = r" Returns the instance number `N` for a peripheral instance."]
1143 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
1144 [(LPSPI1, 1), (LPSPI2, 2)]
1145 .into_iter()
1146 .find(|(ptr, _)| core::ptr::eq(rb, *ptr))
1147 .map(|(_, inst)| inst)
1148 }
1149}
1150#[path = "."]
1151pub mod lpuart {
1152 #[doc = "LPUART"]
1153 pub const LPUART1: *const RegisterBlock = 0x4018_4000 as *const RegisterBlock;
1154 #[doc = "LPUART"]
1155 pub const LPUART2: *const RegisterBlock = 0x4018_8000 as *const RegisterBlock;
1156 #[doc = "LPUART"]
1157 pub const LPUART3: *const RegisterBlock = 0x4018_c000 as *const RegisterBlock;
1158 #[doc = "LPUART"]
1159 pub const LPUART4: *const RegisterBlock = 0x4019_0000 as *const RegisterBlock;
1160 #[path = "blocks/imxrt1011/lpuart.rs"]
1161 mod blocks;
1162 pub use blocks::*;
1163 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
1164 pub type LPUART1 = Instance<1>;
1165 impl crate::private::Sealed for LPUART1 {}
1166 impl crate::Valid for LPUART1 {}
1167 impl LPUART1 {
1168 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1169 #[doc = r""]
1170 #[doc = r" # Safety"]
1171 #[doc = r""]
1172 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1173 #[inline]
1174 pub const unsafe fn instance() -> Self {
1175 Instance::new(LPUART1)
1176 }
1177 }
1178 pub type LPUART2 = Instance<2>;
1179 impl crate::private::Sealed for LPUART2 {}
1180 impl crate::Valid for LPUART2 {}
1181 impl LPUART2 {
1182 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1183 #[doc = r""]
1184 #[doc = r" # Safety"]
1185 #[doc = r""]
1186 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1187 #[inline]
1188 pub const unsafe fn instance() -> Self {
1189 Instance::new(LPUART2)
1190 }
1191 }
1192 pub type LPUART3 = Instance<3>;
1193 impl crate::private::Sealed for LPUART3 {}
1194 impl crate::Valid for LPUART3 {}
1195 impl LPUART3 {
1196 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1197 #[doc = r""]
1198 #[doc = r" # Safety"]
1199 #[doc = r""]
1200 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1201 #[inline]
1202 pub const unsafe fn instance() -> Self {
1203 Instance::new(LPUART3)
1204 }
1205 }
1206 pub type LPUART4 = Instance<4>;
1207 impl crate::private::Sealed for LPUART4 {}
1208 impl crate::Valid for LPUART4 {}
1209 impl LPUART4 {
1210 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1211 #[doc = r""]
1212 #[doc = r" # Safety"]
1213 #[doc = r""]
1214 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1215 #[inline]
1216 pub const unsafe fn instance() -> Self {
1217 Instance::new(LPUART4)
1218 }
1219 }
1220 #[doc = r" Returns the instance number `N` for a peripheral instance."]
1221 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
1222 [(LPUART1, 1), (LPUART2, 2), (LPUART3, 3), (LPUART4, 4)]
1223 .into_iter()
1224 .find(|(ptr, _)| core::ptr::eq(rb, *ptr))
1225 .map(|(_, inst)| inst)
1226 }
1227}
1228#[path = "."]
1229pub mod ocotp {
1230 #[doc = "no description available"]
1231 pub const OCOTP: *const RegisterBlock = 0x401f_4000 as *const RegisterBlock;
1232 #[path = "blocks/imxrt1011/ocotp.rs"]
1233 mod blocks;
1234 pub use blocks::*;
1235 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
1236 pub type OCOTP = Instance<{ crate::SOLE_INSTANCE }>;
1237 impl crate::private::Sealed for OCOTP {}
1238 impl crate::Valid for OCOTP {}
1239 impl OCOTP {
1240 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1241 #[doc = r""]
1242 #[doc = r" # Safety"]
1243 #[doc = r""]
1244 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1245 #[inline]
1246 pub const unsafe fn instance() -> Self {
1247 Instance::new(OCOTP)
1248 }
1249 }
1250 #[doc = r" Returns the instance number `N` for a peripheral instance."]
1251 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
1252 core::ptr::eq(rb, OCOTP).then_some(0)
1253 }
1254}
1255#[path = "."]
1256pub mod otfad {
1257 #[doc = "OTFAD"]
1258 pub const OTFAD: *const RegisterBlock = 0x400a_0000 as *const RegisterBlock;
1259 #[path = "blocks/imxrt1011/otfad.rs"]
1260 mod blocks;
1261 pub use blocks::*;
1262 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
1263 pub type OTFAD = Instance<{ crate::SOLE_INSTANCE }>;
1264 impl crate::private::Sealed for OTFAD {}
1265 impl crate::Valid for OTFAD {}
1266 impl OTFAD {
1267 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1268 #[doc = r""]
1269 #[doc = r" # Safety"]
1270 #[doc = r""]
1271 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1272 #[inline]
1273 pub const unsafe fn instance() -> Self {
1274 Instance::new(OTFAD)
1275 }
1276 }
1277 #[doc = r" Returns the instance number `N` for a peripheral instance."]
1278 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
1279 core::ptr::eq(rb, OTFAD).then_some(0)
1280 }
1281}
1282#[path = "."]
1283pub mod pgc {
1284 #[doc = "PGC"]
1285 pub const PGC: *const RegisterBlock = 0x400f_4000 as *const RegisterBlock;
1286 #[path = "blocks/imxrt1011/pgc.rs"]
1287 mod blocks;
1288 pub use blocks::*;
1289 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
1290 pub type PGC = Instance<{ crate::SOLE_INSTANCE }>;
1291 impl crate::private::Sealed for PGC {}
1292 impl crate::Valid for PGC {}
1293 impl PGC {
1294 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1295 #[doc = r""]
1296 #[doc = r" # Safety"]
1297 #[doc = r""]
1298 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1299 #[inline]
1300 pub const unsafe fn instance() -> Self {
1301 Instance::new(PGC)
1302 }
1303 }
1304 #[doc = r" Returns the instance number `N` for a peripheral instance."]
1305 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
1306 core::ptr::eq(rb, PGC).then_some(0)
1307 }
1308}
1309#[path = "."]
1310pub mod pit {
1311 #[doc = "PIT"]
1312 pub const PIT: *const RegisterBlock = 0x4008_4000 as *const RegisterBlock;
1313 #[path = "blocks/imxrt1011/pit.rs"]
1314 mod blocks;
1315 pub use blocks::*;
1316 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
1317 pub type PIT = Instance<{ crate::SOLE_INSTANCE }>;
1318 impl crate::private::Sealed for PIT {}
1319 impl crate::Valid for PIT {}
1320 impl PIT {
1321 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1322 #[doc = r""]
1323 #[doc = r" # Safety"]
1324 #[doc = r""]
1325 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1326 #[inline]
1327 pub const unsafe fn instance() -> Self {
1328 Instance::new(PIT)
1329 }
1330 }
1331 #[doc = r" Returns the instance number `N` for a peripheral instance."]
1332 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
1333 core::ptr::eq(rb, PIT).then_some(0)
1334 }
1335}
1336#[path = "."]
1337pub mod pmu {
1338 #[doc = "PMU"]
1339 pub const PMU: *const RegisterBlock = 0x400d_8000 as *const RegisterBlock;
1340 #[path = "blocks/imxrt1011/pmu.rs"]
1341 mod blocks;
1342 pub use blocks::*;
1343 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
1344 pub type PMU = Instance<{ crate::SOLE_INSTANCE }>;
1345 impl crate::private::Sealed for PMU {}
1346 impl crate::Valid for PMU {}
1347 impl PMU {
1348 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1349 #[doc = r""]
1350 #[doc = r" # Safety"]
1351 #[doc = r""]
1352 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1353 #[inline]
1354 pub const unsafe fn instance() -> Self {
1355 Instance::new(PMU)
1356 }
1357 }
1358 #[doc = r" Returns the instance number `N` for a peripheral instance."]
1359 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
1360 core::ptr::eq(rb, PMU).then_some(0)
1361 }
1362}
1363#[path = "."]
1364pub mod pwm {
1365 #[doc = "PWM"]
1366 pub const PWM: *const RegisterBlock = 0x401c_c000 as *const RegisterBlock;
1367 #[path = "blocks/imxrt1011/pwm.rs"]
1368 mod blocks;
1369 pub use blocks::*;
1370 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
1371 pub type PWM = Instance<{ crate::SOLE_INSTANCE }>;
1372 impl crate::private::Sealed for PWM {}
1373 impl crate::Valid for PWM {}
1374 impl PWM {
1375 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1376 #[doc = r""]
1377 #[doc = r" # Safety"]
1378 #[doc = r""]
1379 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1380 #[inline]
1381 pub const unsafe fn instance() -> Self {
1382 Instance::new(PWM)
1383 }
1384 }
1385 #[doc = r" Returns the instance number `N` for a peripheral instance."]
1386 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
1387 core::ptr::eq(rb, PWM).then_some(0)
1388 }
1389}
1390#[path = "."]
1391pub mod romc {
1392 #[doc = "ROMC"]
1393 pub const ROMC: *const RegisterBlock = 0x4018_0000 as *const RegisterBlock;
1394 #[path = "blocks/imxrt1011/romc.rs"]
1395 mod blocks;
1396 pub use blocks::*;
1397 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
1398 pub type ROMC = Instance<{ crate::SOLE_INSTANCE }>;
1399 impl crate::private::Sealed for ROMC {}
1400 impl crate::Valid for ROMC {}
1401 impl ROMC {
1402 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1403 #[doc = r""]
1404 #[doc = r" # Safety"]
1405 #[doc = r""]
1406 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1407 #[inline]
1408 pub const unsafe fn instance() -> Self {
1409 Instance::new(ROMC)
1410 }
1411 }
1412 #[doc = r" Returns the instance number `N` for a peripheral instance."]
1413 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
1414 core::ptr::eq(rb, ROMC).then_some(0)
1415 }
1416}
1417#[path = "."]
1418pub mod rtwdog {
1419 #[doc = "WDOG"]
1420 pub const RTWDOG: *const RegisterBlock = 0x400b_c000 as *const RegisterBlock;
1421 #[path = "blocks/imxrt1011/rtwdog.rs"]
1422 mod blocks;
1423 pub use blocks::*;
1424 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
1425 pub type RTWDOG = Instance<{ crate::SOLE_INSTANCE }>;
1426 impl crate::private::Sealed for RTWDOG {}
1427 impl crate::Valid for RTWDOG {}
1428 impl RTWDOG {
1429 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1430 #[doc = r""]
1431 #[doc = r" # Safety"]
1432 #[doc = r""]
1433 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1434 #[inline]
1435 pub const unsafe fn instance() -> Self {
1436 Instance::new(RTWDOG)
1437 }
1438 }
1439 #[doc = r" Returns the instance number `N` for a peripheral instance."]
1440 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
1441 core::ptr::eq(rb, RTWDOG).then_some(0)
1442 }
1443}
1444#[path = "."]
1445pub mod sai {
1446 #[doc = "I2S"]
1447 pub const SAI1: *const RegisterBlock = 0x401e_0000 as *const RegisterBlock;
1448 #[doc = "I2S"]
1449 pub const SAI3: *const RegisterBlock = 0x401e_8000 as *const RegisterBlock;
1450 #[path = "blocks/imxrt1011/sai.rs"]
1451 mod blocks;
1452 pub use blocks::*;
1453 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
1454 pub type SAI1 = Instance<1>;
1455 impl crate::private::Sealed for SAI1 {}
1456 impl crate::Valid for SAI1 {}
1457 impl SAI1 {
1458 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1459 #[doc = r""]
1460 #[doc = r" # Safety"]
1461 #[doc = r""]
1462 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1463 #[inline]
1464 pub const unsafe fn instance() -> Self {
1465 Instance::new(SAI1)
1466 }
1467 }
1468 pub type SAI3 = Instance<3>;
1469 impl crate::private::Sealed for SAI3 {}
1470 impl crate::Valid for SAI3 {}
1471 impl SAI3 {
1472 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1473 #[doc = r""]
1474 #[doc = r" # Safety"]
1475 #[doc = r""]
1476 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1477 #[inline]
1478 pub const unsafe fn instance() -> Self {
1479 Instance::new(SAI3)
1480 }
1481 }
1482 #[doc = r" Returns the instance number `N` for a peripheral instance."]
1483 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
1484 [(SAI1, 1), (SAI3, 3)]
1485 .into_iter()
1486 .find(|(ptr, _)| core::ptr::eq(rb, *ptr))
1487 .map(|(_, inst)| inst)
1488 }
1489}
1490#[path = "."]
1491pub mod snvs {
1492 #[doc = "SNVS"]
1493 pub const SNVS: *const RegisterBlock = 0x400d_4000 as *const RegisterBlock;
1494 #[path = "blocks/imxrt1011/snvs.rs"]
1495 mod blocks;
1496 pub use blocks::*;
1497 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
1498 pub type SNVS = Instance<{ crate::SOLE_INSTANCE }>;
1499 impl crate::private::Sealed for SNVS {}
1500 impl crate::Valid for SNVS {}
1501 impl SNVS {
1502 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1503 #[doc = r""]
1504 #[doc = r" # Safety"]
1505 #[doc = r""]
1506 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1507 #[inline]
1508 pub const unsafe fn instance() -> Self {
1509 Instance::new(SNVS)
1510 }
1511 }
1512 #[doc = r" Returns the instance number `N` for a peripheral instance."]
1513 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
1514 core::ptr::eq(rb, SNVS).then_some(0)
1515 }
1516}
1517#[path = "."]
1518pub mod spdif {
1519 #[doc = "SPDIF"]
1520 pub const SPDIF: *const RegisterBlock = 0x401d_c000 as *const RegisterBlock;
1521 #[path = "blocks/imxrt1011/spdif.rs"]
1522 mod blocks;
1523 pub use blocks::*;
1524 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
1525 pub type SPDIF = Instance<{ crate::SOLE_INSTANCE }>;
1526 impl crate::private::Sealed for SPDIF {}
1527 impl crate::Valid for SPDIF {}
1528 impl SPDIF {
1529 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1530 #[doc = r""]
1531 #[doc = r" # Safety"]
1532 #[doc = r""]
1533 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1534 #[inline]
1535 pub const unsafe fn instance() -> Self {
1536 Instance::new(SPDIF)
1537 }
1538 }
1539 #[doc = r" Returns the instance number `N` for a peripheral instance."]
1540 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
1541 core::ptr::eq(rb, SPDIF).then_some(0)
1542 }
1543}
1544#[path = "."]
1545pub mod src {
1546 #[doc = "SRC"]
1547 pub const SRC: *const RegisterBlock = 0x400f_8000 as *const RegisterBlock;
1548 #[path = "blocks/imxrt1011/src.rs"]
1549 mod blocks;
1550 pub use blocks::*;
1551 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
1552 pub type SRC = Instance<{ crate::SOLE_INSTANCE }>;
1553 impl crate::private::Sealed for SRC {}
1554 impl crate::Valid for SRC {}
1555 impl SRC {
1556 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1557 #[doc = r""]
1558 #[doc = r" # Safety"]
1559 #[doc = r""]
1560 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1561 #[inline]
1562 pub const unsafe fn instance() -> Self {
1563 Instance::new(SRC)
1564 }
1565 }
1566 #[doc = r" Returns the instance number `N` for a peripheral instance."]
1567 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
1568 core::ptr::eq(rb, SRC).then_some(0)
1569 }
1570}
1571#[path = "."]
1572pub mod tempmon {
1573 #[doc = "Temperature Monitor"]
1574 pub const TEMPMON: *const RegisterBlock = 0x400d_8000 as *const RegisterBlock;
1575 #[path = "blocks/imxrt1011/tempmon.rs"]
1576 mod blocks;
1577 pub use blocks::*;
1578 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
1579 pub type TEMPMON = Instance<{ crate::SOLE_INSTANCE }>;
1580 impl crate::private::Sealed for TEMPMON {}
1581 impl crate::Valid for TEMPMON {}
1582 impl TEMPMON {
1583 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1584 #[doc = r""]
1585 #[doc = r" # Safety"]
1586 #[doc = r""]
1587 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1588 #[inline]
1589 pub const unsafe fn instance() -> Self {
1590 Instance::new(TEMPMON)
1591 }
1592 }
1593 #[doc = r" Returns the instance number `N` for a peripheral instance."]
1594 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
1595 core::ptr::eq(rb, TEMPMON).then_some(0)
1596 }
1597}
1598#[path = "."]
1599pub mod trng {
1600 #[doc = "TRNG"]
1601 pub const TRNG: *const RegisterBlock = 0x400c_c000 as *const RegisterBlock;
1602 #[path = "blocks/imxrt1011/trng.rs"]
1603 mod blocks;
1604 pub use blocks::*;
1605 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
1606 pub type TRNG = Instance<{ crate::SOLE_INSTANCE }>;
1607 impl crate::private::Sealed for TRNG {}
1608 impl crate::Valid for TRNG {}
1609 impl TRNG {
1610 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1611 #[doc = r""]
1612 #[doc = r" # Safety"]
1613 #[doc = r""]
1614 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1615 #[inline]
1616 pub const unsafe fn instance() -> Self {
1617 Instance::new(TRNG)
1618 }
1619 }
1620 #[doc = r" Returns the instance number `N` for a peripheral instance."]
1621 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
1622 core::ptr::eq(rb, TRNG).then_some(0)
1623 }
1624}
1625#[path = "."]
1626pub mod usb {
1627 #[doc = "USB"]
1628 pub const USB: *const RegisterBlock = 0x400e_4000 as *const RegisterBlock;
1629 #[path = "blocks/imxrt1011/usb.rs"]
1630 mod blocks;
1631 pub use blocks::*;
1632 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
1633 pub type USB = Instance<{ crate::SOLE_INSTANCE }>;
1634 impl crate::private::Sealed for USB {}
1635 impl crate::Valid for USB {}
1636 impl USB {
1637 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1638 #[doc = r""]
1639 #[doc = r" # Safety"]
1640 #[doc = r""]
1641 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1642 #[inline]
1643 pub const unsafe fn instance() -> Self {
1644 Instance::new(USB)
1645 }
1646 }
1647 #[doc = r" Returns the instance number `N` for a peripheral instance."]
1648 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
1649 core::ptr::eq(rb, USB).then_some(0)
1650 }
1651}
1652#[path = "."]
1653pub mod usb_analog {
1654 #[doc = "USB Analog"]
1655 pub const USB_ANALOG: *const RegisterBlock = 0x400d_8000 as *const RegisterBlock;
1656 #[path = "blocks/imxrt1011/usb_analog.rs"]
1657 mod blocks;
1658 pub use blocks::*;
1659 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
1660 pub type USB_ANALOG = Instance<{ crate::SOLE_INSTANCE }>;
1661 impl crate::private::Sealed for USB_ANALOG {}
1662 impl crate::Valid for USB_ANALOG {}
1663 impl USB_ANALOG {
1664 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1665 #[doc = r""]
1666 #[doc = r" # Safety"]
1667 #[doc = r""]
1668 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1669 #[inline]
1670 pub const unsafe fn instance() -> Self {
1671 Instance::new(USB_ANALOG)
1672 }
1673 }
1674 #[doc = r" Returns the instance number `N` for a peripheral instance."]
1675 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
1676 core::ptr::eq(rb, USB_ANALOG).then_some(0)
1677 }
1678}
1679#[path = "."]
1680pub mod usbnc {
1681 #[doc = "USB"]
1682 pub const USBNC: *const RegisterBlock = 0x400e_4000 as *const RegisterBlock;
1683 #[path = "blocks/imxrt1011/usbnc.rs"]
1684 mod blocks;
1685 pub use blocks::*;
1686 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
1687 pub type USBNC = Instance<{ crate::SOLE_INSTANCE }>;
1688 impl crate::private::Sealed for USBNC {}
1689 impl crate::Valid for USBNC {}
1690 impl USBNC {
1691 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1692 #[doc = r""]
1693 #[doc = r" # Safety"]
1694 #[doc = r""]
1695 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1696 #[inline]
1697 pub const unsafe fn instance() -> Self {
1698 Instance::new(USBNC)
1699 }
1700 }
1701 #[doc = r" Returns the instance number `N` for a peripheral instance."]
1702 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
1703 core::ptr::eq(rb, USBNC).then_some(0)
1704 }
1705}
1706#[path = "."]
1707pub mod usbphy {
1708 #[doc = "USBPHY Register Reference Index"]
1709 pub const USBPHY: *const RegisterBlock = 0x400d_9000 as *const RegisterBlock;
1710 #[path = "blocks/imxrt1011/usbphy.rs"]
1711 mod blocks;
1712 pub use blocks::*;
1713 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
1714 pub type USBPHY = Instance<{ crate::SOLE_INSTANCE }>;
1715 impl crate::private::Sealed for USBPHY {}
1716 impl crate::Valid for USBPHY {}
1717 impl USBPHY {
1718 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1719 #[doc = r""]
1720 #[doc = r" # Safety"]
1721 #[doc = r""]
1722 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1723 #[inline]
1724 pub const unsafe fn instance() -> Self {
1725 Instance::new(USBPHY)
1726 }
1727 }
1728 #[doc = r" Returns the instance number `N` for a peripheral instance."]
1729 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
1730 core::ptr::eq(rb, USBPHY).then_some(0)
1731 }
1732}
1733#[path = "."]
1734pub mod wdog {
1735 #[doc = "WDOG"]
1736 pub const WDOG1: *const RegisterBlock = 0x400b_8000 as *const RegisterBlock;
1737 #[doc = "WDOG"]
1738 pub const WDOG2: *const RegisterBlock = 0x400d_0000 as *const RegisterBlock;
1739 #[path = "blocks/imxrt1011/wdog.rs"]
1740 mod blocks;
1741 pub use blocks::*;
1742 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
1743 pub type WDOG1 = Instance<1>;
1744 impl crate::private::Sealed for WDOG1 {}
1745 impl crate::Valid for WDOG1 {}
1746 impl WDOG1 {
1747 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1748 #[doc = r""]
1749 #[doc = r" # Safety"]
1750 #[doc = r""]
1751 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1752 #[inline]
1753 pub const unsafe fn instance() -> Self {
1754 Instance::new(WDOG1)
1755 }
1756 }
1757 pub type WDOG2 = Instance<2>;
1758 impl crate::private::Sealed for WDOG2 {}
1759 impl crate::Valid for WDOG2 {}
1760 impl WDOG2 {
1761 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1762 #[doc = r""]
1763 #[doc = r" # Safety"]
1764 #[doc = r""]
1765 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1766 #[inline]
1767 pub const unsafe fn instance() -> Self {
1768 Instance::new(WDOG2)
1769 }
1770 }
1771 #[doc = r" Returns the instance number `N` for a peripheral instance."]
1772 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
1773 [(WDOG1, 1), (WDOG2, 2)]
1774 .into_iter()
1775 .find(|(ptr, _)| core::ptr::eq(rb, *ptr))
1776 .map(|(_, inst)| inst)
1777 }
1778}
1779#[path = "."]
1780pub mod xbara {
1781 #[doc = "Crossbar Switch"]
1782 pub const XBARA: *const RegisterBlock = 0x4009_8000 as *const RegisterBlock;
1783 #[path = "blocks/imxrt1011/xbara.rs"]
1784 mod blocks;
1785 pub use blocks::*;
1786 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
1787 pub type XBARA = Instance<{ crate::SOLE_INSTANCE }>;
1788 impl crate::private::Sealed for XBARA {}
1789 impl crate::Valid for XBARA {}
1790 impl XBARA {
1791 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1792 #[doc = r""]
1793 #[doc = r" # Safety"]
1794 #[doc = r""]
1795 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1796 #[inline]
1797 pub const unsafe fn instance() -> Self {
1798 Instance::new(XBARA)
1799 }
1800 }
1801 #[doc = r" Returns the instance number `N` for a peripheral instance."]
1802 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
1803 core::ptr::eq(rb, XBARA).then_some(0)
1804 }
1805}
1806#[path = "."]
1807pub mod xtalosc24m {
1808 #[doc = "XTALOSC24M"]
1809 pub const XTALOSC24M: *const RegisterBlock = 0x400d_8000 as *const RegisterBlock;
1810 #[path = "blocks/imxrt1011/xtalosc24m.rs"]
1811 mod blocks;
1812 pub use blocks::*;
1813 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
1814 pub type XTALOSC24M = Instance<{ crate::SOLE_INSTANCE }>;
1815 impl crate::private::Sealed for XTALOSC24M {}
1816 impl crate::Valid for XTALOSC24M {}
1817 impl XTALOSC24M {
1818 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1819 #[doc = r""]
1820 #[doc = r" # Safety"]
1821 #[doc = r""]
1822 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1823 #[inline]
1824 pub const unsafe fn instance() -> Self {
1825 Instance::new(XTALOSC24M)
1826 }
1827 }
1828 #[doc = r" Returns the instance number `N` for a peripheral instance."]
1829 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
1830 core::ptr::eq(rb, XTALOSC24M).then_some(0)
1831 }
1832}
1833#[doc = r"Number available in the NVIC for configuring priority"]
1834pub const NVIC_PRIO_BITS: u8 = 4;
1835#[doc = r" Instances for all of this device's peripherals."]
1836#[doc = r""]
1837#[doc = r" Use this if you want a single way to acquire *all* instances"]
1838#[doc = r" for your device."]
1839pub struct Instances {
1840 pub ADC: adc::ADC,
1841 pub ADC_ETC: adc_etc::ADC_ETC,
1842 pub AIPSTZ1: aipstz::AIPSTZ1,
1843 pub AIPSTZ2: aipstz::AIPSTZ2,
1844 pub AOI: aoi::AOI,
1845 pub CCM: ccm::CCM,
1846 pub CCM_ANALOG: ccm_analog::CCM_ANALOG,
1847 pub CSU: csu::CSU,
1848 pub DCDC: dcdc::DCDC,
1849 pub DCP: dcp::DCP,
1850 pub DMA: dma::DMA,
1851 pub DMAMUX: dmamux::DMAMUX,
1852 pub EWM: ewm::EWM,
1853 pub FLEXIO1: flexio1::FLEXIO1,
1854 pub FLEXRAM: flexram::FLEXRAM,
1855 pub FLEXSPI: flexspi::FLEXSPI,
1856 pub GPC: gpc::GPC,
1857 pub GPIO1: gpio::GPIO1,
1858 pub GPIO5: gpio::GPIO5,
1859 pub GPIO2: gpio::GPIO2,
1860 pub GPT1: gpt::GPT1,
1861 pub GPT2: gpt::GPT2,
1862 pub IOMUXC: iomuxc::IOMUXC,
1863 pub IOMUXC_GPR: iomuxc_gpr::IOMUXC_GPR,
1864 pub IOMUXC_SNVS: iomuxc_snvs::IOMUXC_SNVS,
1865 pub IOMUXC_SNVS_GPR: iomuxc_snvs_gpr::IOMUXC_SNVS_GPR,
1866 pub KPP: kpp::KPP,
1867 pub LPI2C1: lpi2c::LPI2C1,
1868 pub LPI2C2: lpi2c::LPI2C2,
1869 pub LPSPI1: lpspi::LPSPI1,
1870 pub LPSPI2: lpspi::LPSPI2,
1871 pub LPUART1: lpuart::LPUART1,
1872 pub LPUART2: lpuart::LPUART2,
1873 pub LPUART3: lpuart::LPUART3,
1874 pub LPUART4: lpuart::LPUART4,
1875 pub OCOTP: ocotp::OCOTP,
1876 pub OTFAD: otfad::OTFAD,
1877 pub PGC: pgc::PGC,
1878 pub PIT: pit::PIT,
1879 pub PMU: pmu::PMU,
1880 pub PWM: pwm::PWM,
1881 pub ROMC: romc::ROMC,
1882 pub RTWDOG: rtwdog::RTWDOG,
1883 pub SAI1: sai::SAI1,
1884 pub SAI3: sai::SAI3,
1885 pub SNVS: snvs::SNVS,
1886 pub SPDIF: spdif::SPDIF,
1887 pub SRC: src::SRC,
1888 pub TEMPMON: tempmon::TEMPMON,
1889 pub TRNG: trng::TRNG,
1890 pub USB: usb::USB,
1891 pub USB_ANALOG: usb_analog::USB_ANALOG,
1892 pub USBNC: usbnc::USBNC,
1893 pub USBPHY: usbphy::USBPHY,
1894 pub WDOG1: wdog::WDOG1,
1895 pub WDOG2: wdog::WDOG2,
1896 pub XBARA: xbara::XBARA,
1897 pub XTALOSC24M: xtalosc24m::XTALOSC24M,
1898}
1899impl Instances {
1900 #[doc = r" Acquire all peripheral instances."]
1901 #[doc = r""]
1902 #[doc = r" # Safety"]
1903 #[doc = r""]
1904 #[doc = r" Since this calls `instance()` to initialize each of its members,"]
1905 #[doc = r" the `instance()` safety contract applies. See [the `Instance` safety"]
1906 #[doc = r" documentation](crate::Instance) for more information."]
1907 #[inline]
1908 pub const unsafe fn instances() -> Self {
1909 Self {
1910 ADC: adc::ADC::instance(),
1911 ADC_ETC: adc_etc::ADC_ETC::instance(),
1912 AIPSTZ1: aipstz::AIPSTZ1::instance(),
1913 AIPSTZ2: aipstz::AIPSTZ2::instance(),
1914 AOI: aoi::AOI::instance(),
1915 CCM: ccm::CCM::instance(),
1916 CCM_ANALOG: ccm_analog::CCM_ANALOG::instance(),
1917 CSU: csu::CSU::instance(),
1918 DCDC: dcdc::DCDC::instance(),
1919 DCP: dcp::DCP::instance(),
1920 DMA: dma::DMA::instance(),
1921 DMAMUX: dmamux::DMAMUX::instance(),
1922 EWM: ewm::EWM::instance(),
1923 FLEXIO1: flexio1::FLEXIO1::instance(),
1924 FLEXRAM: flexram::FLEXRAM::instance(),
1925 FLEXSPI: flexspi::FLEXSPI::instance(),
1926 GPC: gpc::GPC::instance(),
1927 GPIO1: gpio::GPIO1::instance(),
1928 GPIO5: gpio::GPIO5::instance(),
1929 GPIO2: gpio::GPIO2::instance(),
1930 GPT1: gpt::GPT1::instance(),
1931 GPT2: gpt::GPT2::instance(),
1932 IOMUXC: iomuxc::IOMUXC::instance(),
1933 IOMUXC_GPR: iomuxc_gpr::IOMUXC_GPR::instance(),
1934 IOMUXC_SNVS: iomuxc_snvs::IOMUXC_SNVS::instance(),
1935 IOMUXC_SNVS_GPR: iomuxc_snvs_gpr::IOMUXC_SNVS_GPR::instance(),
1936 KPP: kpp::KPP::instance(),
1937 LPI2C1: lpi2c::LPI2C1::instance(),
1938 LPI2C2: lpi2c::LPI2C2::instance(),
1939 LPSPI1: lpspi::LPSPI1::instance(),
1940 LPSPI2: lpspi::LPSPI2::instance(),
1941 LPUART1: lpuart::LPUART1::instance(),
1942 LPUART2: lpuart::LPUART2::instance(),
1943 LPUART3: lpuart::LPUART3::instance(),
1944 LPUART4: lpuart::LPUART4::instance(),
1945 OCOTP: ocotp::OCOTP::instance(),
1946 OTFAD: otfad::OTFAD::instance(),
1947 PGC: pgc::PGC::instance(),
1948 PIT: pit::PIT::instance(),
1949 PMU: pmu::PMU::instance(),
1950 PWM: pwm::PWM::instance(),
1951 ROMC: romc::ROMC::instance(),
1952 RTWDOG: rtwdog::RTWDOG::instance(),
1953 SAI1: sai::SAI1::instance(),
1954 SAI3: sai::SAI3::instance(),
1955 SNVS: snvs::SNVS::instance(),
1956 SPDIF: spdif::SPDIF::instance(),
1957 SRC: src::SRC::instance(),
1958 TEMPMON: tempmon::TEMPMON::instance(),
1959 TRNG: trng::TRNG::instance(),
1960 USB: usb::USB::instance(),
1961 USB_ANALOG: usb_analog::USB_ANALOG::instance(),
1962 USBNC: usbnc::USBNC::instance(),
1963 USBPHY: usbphy::USBPHY::instance(),
1964 WDOG1: wdog::WDOG1::instance(),
1965 WDOG2: wdog::WDOG2::instance(),
1966 XBARA: xbara::XBARA::instance(),
1967 XTALOSC24M: xtalosc24m::XTALOSC24M::instance(),
1968 }
1969 }
1970}