1#[derive(Copy, Clone, Debug, PartialEq, Eq)]
2pub enum Interrupt {
3 #[doc = "0 - DMA0_DMA16"]
4 DMA0_DMA16 = 0,
5 #[doc = "1 - DMA1_DMA17"]
6 DMA1_DMA17 = 1,
7 #[doc = "2 - DMA2_DMA18"]
8 DMA2_DMA18 = 2,
9 #[doc = "3 - DMA3_DMA19"]
10 DMA3_DMA19 = 3,
11 #[doc = "4 - DMA4_DMA20"]
12 DMA4_DMA20 = 4,
13 #[doc = "5 - DMA5_DMA21"]
14 DMA5_DMA21 = 5,
15 #[doc = "6 - DMA6_DMA22"]
16 DMA6_DMA22 = 6,
17 #[doc = "7 - DMA7_DMA23"]
18 DMA7_DMA23 = 7,
19 #[doc = "8 - DMA8_DMA24"]
20 DMA8_DMA24 = 8,
21 #[doc = "9 - DMA9_DMA25"]
22 DMA9_DMA25 = 9,
23 #[doc = "10 - DMA10_DMA26"]
24 DMA10_DMA26 = 10,
25 #[doc = "11 - DMA11_DMA27"]
26 DMA11_DMA27 = 11,
27 #[doc = "12 - DMA12_DMA28"]
28 DMA12_DMA28 = 12,
29 #[doc = "13 - DMA13_DMA29"]
30 DMA13_DMA29 = 13,
31 #[doc = "14 - DMA14_DMA30"]
32 DMA14_DMA30 = 14,
33 #[doc = "15 - DMA15_DMA31"]
34 DMA15_DMA31 = 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 - LPUART5"]
46 LPUART5 = 24,
47 #[doc = "25 - LPUART6"]
48 LPUART6 = 25,
49 #[doc = "26 - LPUART7"]
50 LPUART7 = 26,
51 #[doc = "27 - LPUART8"]
52 LPUART8 = 27,
53 #[doc = "28 - LPI2C1"]
54 LPI2C1 = 28,
55 #[doc = "29 - LPI2C2"]
56 LPI2C2 = 29,
57 #[doc = "30 - LPI2C3"]
58 LPI2C3 = 30,
59 #[doc = "31 - LPI2C4"]
60 LPI2C4 = 31,
61 #[doc = "32 - LPSPI1"]
62 LPSPI1 = 32,
63 #[doc = "33 - LPSPI2"]
64 LPSPI2 = 33,
65 #[doc = "34 - LPSPI3"]
66 LPSPI3 = 34,
67 #[doc = "35 - LPSPI4"]
68 LPSPI4 = 35,
69 #[doc = "36 - CAN1"]
70 CAN1 = 36,
71 #[doc = "37 - CAN2"]
72 CAN2 = 37,
73 #[doc = "38 - FLEXRAM"]
74 FLEXRAM = 38,
75 #[doc = "39 - KPP"]
76 KPP = 39,
77 #[doc = "40 - TSC_DIG"]
78 TSC_DIG = 40,
79 #[doc = "41 - GPR (aka \"GPC\") interrupt request"]
80 GPR_IRQ = 41,
81 #[doc = "42 - LCDIF"]
82 LCDIF = 42,
83 #[doc = "43 - CSI"]
84 CSI = 43,
85 #[doc = "44 - PXP"]
86 PXP = 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 = "55 - BEE"]
104 BEE = 55,
105 #[doc = "56 - SAI1"]
106 SAI1 = 56,
107 #[doc = "57 - SAI2"]
108 SAI2 = 57,
109 #[doc = "58 - SAI3_RX"]
110 SAI3_RX = 58,
111 #[doc = "59 - SAI3_TX"]
112 SAI3_TX = 59,
113 #[doc = "60 - SPDIF"]
114 SPDIF = 60,
115 #[doc = "61 - PMU_EVENT"]
116 PMU_EVENT = 61,
117 #[doc = "63 - TEMP_LOW_HIGH"]
118 TEMP_LOW_HIGH = 63,
119 #[doc = "64 - TEMP_PANIC"]
120 TEMP_PANIC = 64,
121 #[doc = "65 - USB_PHY1"]
122 USB_PHY1 = 65,
123 #[doc = "66 - USB_PHY2"]
124 USB_PHY2 = 66,
125 #[doc = "67 - ADC1"]
126 ADC1 = 67,
127 #[doc = "68 - ADC2"]
128 ADC2 = 68,
129 #[doc = "69 - DCDC"]
130 DCDC = 69,
131 #[doc = "72 - GPIO1_INT0"]
132 GPIO1_INT0 = 72,
133 #[doc = "73 - GPIO1_INT1"]
134 GPIO1_INT1 = 73,
135 #[doc = "74 - GPIO1_INT2"]
136 GPIO1_INT2 = 74,
137 #[doc = "75 - GPIO1_INT3"]
138 GPIO1_INT3 = 75,
139 #[doc = "76 - GPIO1_INT4"]
140 GPIO1_INT4 = 76,
141 #[doc = "77 - GPIO1_INT5"]
142 GPIO1_INT5 = 77,
143 #[doc = "78 - GPIO1_INT6"]
144 GPIO1_INT6 = 78,
145 #[doc = "79 - GPIO1_INT7"]
146 GPIO1_INT7 = 79,
147 #[doc = "80 - GPIO1_COMBINED_0_15"]
148 GPIO1_COMBINED_0_15 = 80,
149 #[doc = "81 - GPIO1_COMBINED_16_31"]
150 GPIO1_COMBINED_16_31 = 81,
151 #[doc = "82 - GPIO2_COMBINED_0_15"]
152 GPIO2_COMBINED_0_15 = 82,
153 #[doc = "83 - GPIO2_COMBINED_16_31"]
154 GPIO2_COMBINED_16_31 = 83,
155 #[doc = "84 - GPIO3_COMBINED_0_15"]
156 GPIO3_COMBINED_0_15 = 84,
157 #[doc = "85 - GPIO3_COMBINED_16_31"]
158 GPIO3_COMBINED_16_31 = 85,
159 #[doc = "86 - GPIO4_COMBINED_0_15"]
160 GPIO4_COMBINED_0_15 = 86,
161 #[doc = "87 - GPIO4_COMBINED_16_31"]
162 GPIO4_COMBINED_16_31 = 87,
163 #[doc = "88 - GPIO5_COMBINED_0_15"]
164 GPIO5_COMBINED_0_15 = 88,
165 #[doc = "89 - GPIO5_COMBINED_16_31"]
166 GPIO5_COMBINED_16_31 = 89,
167 #[doc = "90 - FLEXIO1"]
168 FLEXIO1 = 90,
169 #[doc = "91 - FLEXIO2"]
170 FLEXIO2 = 91,
171 #[doc = "92 - WDOG1"]
172 WDOG1 = 92,
173 #[doc = "93 - RTWDOG"]
174 RTWDOG = 93,
175 #[doc = "94 - EWM"]
176 EWM = 94,
177 #[doc = "95 - CCM_1"]
178 CCM_1 = 95,
179 #[doc = "96 - CCM_2"]
180 CCM_2 = 96,
181 #[doc = "97 - GPC"]
182 GPC = 97,
183 #[doc = "98 - SRC"]
184 SRC = 98,
185 #[doc = "100 - GPT1"]
186 GPT1 = 100,
187 #[doc = "101 - GPT2"]
188 GPT2 = 101,
189 #[doc = "102 - PWM1_0"]
190 PWM1_0 = 102,
191 #[doc = "103 - PWM1_1"]
192 PWM1_1 = 103,
193 #[doc = "104 - PWM1_2"]
194 PWM1_2 = 104,
195 #[doc = "105 - PWM1_3"]
196 PWM1_3 = 105,
197 #[doc = "106 - PWM1_FAULT"]
198 PWM1_FAULT = 106,
199 #[doc = "107 - FLEXSPI2"]
200 FLEXSPI2 = 107,
201 #[doc = "108 - FLEXSPI"]
202 FLEXSPI = 108,
203 #[doc = "109 - SEMC"]
204 SEMC = 109,
205 #[doc = "110 - USDHC1"]
206 USDHC1 = 110,
207 #[doc = "111 - USDHC2"]
208 USDHC2 = 111,
209 #[doc = "112 - USB_OTG2"]
210 USB_OTG2 = 112,
211 #[doc = "113 - USB_OTG1"]
212 USB_OTG1 = 113,
213 #[doc = "114 - ENET"]
214 ENET = 114,
215 #[doc = "115 - ENET_1588_TIMER"]
216 ENET_1588_TIMER = 115,
217 #[doc = "116 - XBAR1_IRQ_0_1"]
218 XBAR1_IRQ_0_1 = 116,
219 #[doc = "117 - XBAR1_IRQ_2_3"]
220 XBAR1_IRQ_2_3 = 117,
221 #[doc = "118 - ADC_ETC_IRQ0"]
222 ADC_ETC_IRQ0 = 118,
223 #[doc = "119 - ADC_ETC_IRQ1"]
224 ADC_ETC_IRQ1 = 119,
225 #[doc = "120 - ADC_ETC_IRQ2"]
226 ADC_ETC_IRQ2 = 120,
227 #[doc = "121 - ADC_ETC_ERROR_IRQ"]
228 ADC_ETC_ERROR_IRQ = 121,
229 #[doc = "122 - PIT"]
230 PIT = 122,
231 #[doc = "123 - ACMP1"]
232 ACMP1 = 123,
233 #[doc = "124 - ACMP2"]
234 ACMP2 = 124,
235 #[doc = "125 - ACMP3"]
236 ACMP3 = 125,
237 #[doc = "126 - ACMP4"]
238 ACMP4 = 126,
239 #[doc = "129 - ENC1"]
240 ENC1 = 129,
241 #[doc = "130 - ENC2"]
242 ENC2 = 130,
243 #[doc = "131 - ENC3"]
244 ENC3 = 131,
245 #[doc = "132 - ENC4"]
246 ENC4 = 132,
247 #[doc = "133 - TMR1"]
248 TMR1 = 133,
249 #[doc = "134 - TMR2"]
250 TMR2 = 134,
251 #[doc = "135 - TMR3"]
252 TMR3 = 135,
253 #[doc = "136 - TMR4"]
254 TMR4 = 136,
255 #[doc = "137 - PWM2_0"]
256 PWM2_0 = 137,
257 #[doc = "138 - PWM2_1"]
258 PWM2_1 = 138,
259 #[doc = "139 - PWM2_2"]
260 PWM2_2 = 139,
261 #[doc = "140 - PWM2_3"]
262 PWM2_3 = 140,
263 #[doc = "141 - PWM2_FAULT"]
264 PWM2_FAULT = 141,
265 #[doc = "142 - PWM3_0"]
266 PWM3_0 = 142,
267 #[doc = "143 - PWM3_1"]
268 PWM3_1 = 143,
269 #[doc = "144 - PWM3_2"]
270 PWM3_2 = 144,
271 #[doc = "145 - PWM3_3"]
272 PWM3_3 = 145,
273 #[doc = "146 - PWM3_FAULT"]
274 PWM3_FAULT = 146,
275 #[doc = "147 - PWM4_0"]
276 PWM4_0 = 147,
277 #[doc = "148 - PWM4_1"]
278 PWM4_1 = 148,
279 #[doc = "149 - PWM4_2"]
280 PWM4_2 = 149,
281 #[doc = "150 - PWM4_3"]
282 PWM4_3 = 150,
283 #[doc = "151 - PWM4_FAULT"]
284 PWM4_FAULT = 151,
285 #[doc = "152 - ENET2"]
286 ENET2 = 152,
287 #[doc = "153 - ENET2_1588_TIMER"]
288 ENET2_1588_TIMER = 153,
289 #[doc = "154 - CAN3"]
290 CAN3 = 154,
291 #[doc = "156 - FLEXIO3"]
292 FLEXIO3 = 156,
293 #[doc = "157 - GPIO6_7_8_9"]
294 GPIO6_7_8_9 = 157,
295}
296pub type interrupt = Interrupt;
297unsafe impl cortex_m::interrupt::InterruptNumber for Interrupt {
298 #[inline(always)]
299 fn number(self) -> u16 {
300 self as u16
301 }
302}
303#[cfg(all(feature = "rt", target_os = "none"))]
304mod _vectors {
305 extern "C" {
306 fn DMA0_DMA16();
307 fn DMA1_DMA17();
308 fn DMA2_DMA18();
309 fn DMA3_DMA19();
310 fn DMA4_DMA20();
311 fn DMA5_DMA21();
312 fn DMA6_DMA22();
313 fn DMA7_DMA23();
314 fn DMA8_DMA24();
315 fn DMA9_DMA25();
316 fn DMA10_DMA26();
317 fn DMA11_DMA27();
318 fn DMA12_DMA28();
319 fn DMA13_DMA29();
320 fn DMA14_DMA30();
321 fn DMA15_DMA31();
322 fn DMA_ERROR();
323 fn LPUART1();
324 fn LPUART2();
325 fn LPUART3();
326 fn LPUART4();
327 fn LPUART5();
328 fn LPUART6();
329 fn LPUART7();
330 fn LPUART8();
331 fn LPI2C1();
332 fn LPI2C2();
333 fn LPI2C3();
334 fn LPI2C4();
335 fn LPSPI1();
336 fn LPSPI2();
337 fn LPSPI3();
338 fn LPSPI4();
339 fn CAN1();
340 fn CAN2();
341 fn FLEXRAM();
342 fn KPP();
343 fn TSC_DIG();
344 fn GPR_IRQ();
345 fn LCDIF();
346 fn CSI();
347 fn PXP();
348 fn WDOG2();
349 fn SNVS_HP_WRAPPER();
350 fn SNVS_HP_WRAPPER_TZ();
351 fn SNVS_LP_WRAPPER();
352 fn CSU();
353 fn DCP();
354 fn DCP_VMI();
355 fn TRNG();
356 fn BEE();
357 fn SAI1();
358 fn SAI2();
359 fn SAI3_RX();
360 fn SAI3_TX();
361 fn SPDIF();
362 fn PMU_EVENT();
363 fn TEMP_LOW_HIGH();
364 fn TEMP_PANIC();
365 fn USB_PHY1();
366 fn USB_PHY2();
367 fn ADC1();
368 fn ADC2();
369 fn DCDC();
370 fn GPIO1_INT0();
371 fn GPIO1_INT1();
372 fn GPIO1_INT2();
373 fn GPIO1_INT3();
374 fn GPIO1_INT4();
375 fn GPIO1_INT5();
376 fn GPIO1_INT6();
377 fn GPIO1_INT7();
378 fn GPIO1_COMBINED_0_15();
379 fn GPIO1_COMBINED_16_31();
380 fn GPIO2_COMBINED_0_15();
381 fn GPIO2_COMBINED_16_31();
382 fn GPIO3_COMBINED_0_15();
383 fn GPIO3_COMBINED_16_31();
384 fn GPIO4_COMBINED_0_15();
385 fn GPIO4_COMBINED_16_31();
386 fn GPIO5_COMBINED_0_15();
387 fn GPIO5_COMBINED_16_31();
388 fn FLEXIO1();
389 fn FLEXIO2();
390 fn WDOG1();
391 fn RTWDOG();
392 fn EWM();
393 fn CCM_1();
394 fn CCM_2();
395 fn GPC();
396 fn SRC();
397 fn GPT1();
398 fn GPT2();
399 fn PWM1_0();
400 fn PWM1_1();
401 fn PWM1_2();
402 fn PWM1_3();
403 fn PWM1_FAULT();
404 fn FLEXSPI2();
405 fn FLEXSPI();
406 fn SEMC();
407 fn USDHC1();
408 fn USDHC2();
409 fn USB_OTG2();
410 fn USB_OTG1();
411 fn ENET();
412 fn ENET_1588_TIMER();
413 fn XBAR1_IRQ_0_1();
414 fn XBAR1_IRQ_2_3();
415 fn ADC_ETC_IRQ0();
416 fn ADC_ETC_IRQ1();
417 fn ADC_ETC_IRQ2();
418 fn ADC_ETC_ERROR_IRQ();
419 fn PIT();
420 fn ACMP1();
421 fn ACMP2();
422 fn ACMP3();
423 fn ACMP4();
424 fn ENC1();
425 fn ENC2();
426 fn ENC3();
427 fn ENC4();
428 fn TMR1();
429 fn TMR2();
430 fn TMR3();
431 fn TMR4();
432 fn PWM2_0();
433 fn PWM2_1();
434 fn PWM2_2();
435 fn PWM2_3();
436 fn PWM2_FAULT();
437 fn PWM3_0();
438 fn PWM3_1();
439 fn PWM3_2();
440 fn PWM3_3();
441 fn PWM3_FAULT();
442 fn PWM4_0();
443 fn PWM4_1();
444 fn PWM4_2();
445 fn PWM4_3();
446 fn PWM4_FAULT();
447 fn ENET2();
448 fn ENET2_1588_TIMER();
449 fn CAN3();
450 fn FLEXIO3();
451 fn GPIO6_7_8_9();
452 }
453 pub union Vector {
454 _handler: unsafe extern "C" fn(),
455 _reserved: u32,
456 }
457 #[cfg_attr(target_os = "none", link_section = ".vector_table.interrupts")]
458 #[no_mangle]
459 pub static __INTERRUPTS: [Vector; 158] = [
460 Vector {
461 _handler: DMA0_DMA16,
462 },
463 Vector {
464 _handler: DMA1_DMA17,
465 },
466 Vector {
467 _handler: DMA2_DMA18,
468 },
469 Vector {
470 _handler: DMA3_DMA19,
471 },
472 Vector {
473 _handler: DMA4_DMA20,
474 },
475 Vector {
476 _handler: DMA5_DMA21,
477 },
478 Vector {
479 _handler: DMA6_DMA22,
480 },
481 Vector {
482 _handler: DMA7_DMA23,
483 },
484 Vector {
485 _handler: DMA8_DMA24,
486 },
487 Vector {
488 _handler: DMA9_DMA25,
489 },
490 Vector {
491 _handler: DMA10_DMA26,
492 },
493 Vector {
494 _handler: DMA11_DMA27,
495 },
496 Vector {
497 _handler: DMA12_DMA28,
498 },
499 Vector {
500 _handler: DMA13_DMA29,
501 },
502 Vector {
503 _handler: DMA14_DMA30,
504 },
505 Vector {
506 _handler: DMA15_DMA31,
507 },
508 Vector {
509 _handler: DMA_ERROR,
510 },
511 Vector { _reserved: 0 },
512 Vector { _reserved: 0 },
513 Vector { _reserved: 0 },
514 Vector { _handler: LPUART1 },
515 Vector { _handler: LPUART2 },
516 Vector { _handler: LPUART3 },
517 Vector { _handler: LPUART4 },
518 Vector { _handler: LPUART5 },
519 Vector { _handler: LPUART6 },
520 Vector { _handler: LPUART7 },
521 Vector { _handler: LPUART8 },
522 Vector { _handler: LPI2C1 },
523 Vector { _handler: LPI2C2 },
524 Vector { _handler: LPI2C3 },
525 Vector { _handler: LPI2C4 },
526 Vector { _handler: LPSPI1 },
527 Vector { _handler: LPSPI2 },
528 Vector { _handler: LPSPI3 },
529 Vector { _handler: LPSPI4 },
530 Vector { _handler: CAN1 },
531 Vector { _handler: CAN2 },
532 Vector { _handler: FLEXRAM },
533 Vector { _handler: KPP },
534 Vector { _handler: TSC_DIG },
535 Vector { _handler: GPR_IRQ },
536 Vector { _handler: LCDIF },
537 Vector { _handler: CSI },
538 Vector { _handler: PXP },
539 Vector { _handler: WDOG2 },
540 Vector {
541 _handler: SNVS_HP_WRAPPER,
542 },
543 Vector {
544 _handler: SNVS_HP_WRAPPER_TZ,
545 },
546 Vector {
547 _handler: SNVS_LP_WRAPPER,
548 },
549 Vector { _handler: CSU },
550 Vector { _handler: DCP },
551 Vector { _handler: DCP_VMI },
552 Vector { _reserved: 0 },
553 Vector { _handler: TRNG },
554 Vector { _reserved: 0 },
555 Vector { _handler: BEE },
556 Vector { _handler: SAI1 },
557 Vector { _handler: SAI2 },
558 Vector { _handler: SAI3_RX },
559 Vector { _handler: SAI3_TX },
560 Vector { _handler: SPDIF },
561 Vector {
562 _handler: PMU_EVENT,
563 },
564 Vector { _reserved: 0 },
565 Vector {
566 _handler: TEMP_LOW_HIGH,
567 },
568 Vector {
569 _handler: TEMP_PANIC,
570 },
571 Vector { _handler: USB_PHY1 },
572 Vector { _handler: USB_PHY2 },
573 Vector { _handler: ADC1 },
574 Vector { _handler: ADC2 },
575 Vector { _handler: DCDC },
576 Vector { _reserved: 0 },
577 Vector { _reserved: 0 },
578 Vector {
579 _handler: GPIO1_INT0,
580 },
581 Vector {
582 _handler: GPIO1_INT1,
583 },
584 Vector {
585 _handler: GPIO1_INT2,
586 },
587 Vector {
588 _handler: GPIO1_INT3,
589 },
590 Vector {
591 _handler: GPIO1_INT4,
592 },
593 Vector {
594 _handler: GPIO1_INT5,
595 },
596 Vector {
597 _handler: GPIO1_INT6,
598 },
599 Vector {
600 _handler: GPIO1_INT7,
601 },
602 Vector {
603 _handler: GPIO1_COMBINED_0_15,
604 },
605 Vector {
606 _handler: GPIO1_COMBINED_16_31,
607 },
608 Vector {
609 _handler: GPIO2_COMBINED_0_15,
610 },
611 Vector {
612 _handler: GPIO2_COMBINED_16_31,
613 },
614 Vector {
615 _handler: GPIO3_COMBINED_0_15,
616 },
617 Vector {
618 _handler: GPIO3_COMBINED_16_31,
619 },
620 Vector {
621 _handler: GPIO4_COMBINED_0_15,
622 },
623 Vector {
624 _handler: GPIO4_COMBINED_16_31,
625 },
626 Vector {
627 _handler: GPIO5_COMBINED_0_15,
628 },
629 Vector {
630 _handler: GPIO5_COMBINED_16_31,
631 },
632 Vector { _handler: FLEXIO1 },
633 Vector { _handler: FLEXIO2 },
634 Vector { _handler: WDOG1 },
635 Vector { _handler: RTWDOG },
636 Vector { _handler: EWM },
637 Vector { _handler: CCM_1 },
638 Vector { _handler: CCM_2 },
639 Vector { _handler: GPC },
640 Vector { _handler: SRC },
641 Vector { _reserved: 0 },
642 Vector { _handler: GPT1 },
643 Vector { _handler: GPT2 },
644 Vector { _handler: PWM1_0 },
645 Vector { _handler: PWM1_1 },
646 Vector { _handler: PWM1_2 },
647 Vector { _handler: PWM1_3 },
648 Vector {
649 _handler: PWM1_FAULT,
650 },
651 Vector { _handler: FLEXSPI2 },
652 Vector { _handler: FLEXSPI },
653 Vector { _handler: SEMC },
654 Vector { _handler: USDHC1 },
655 Vector { _handler: USDHC2 },
656 Vector { _handler: USB_OTG2 },
657 Vector { _handler: USB_OTG1 },
658 Vector { _handler: ENET },
659 Vector {
660 _handler: ENET_1588_TIMER,
661 },
662 Vector {
663 _handler: XBAR1_IRQ_0_1,
664 },
665 Vector {
666 _handler: XBAR1_IRQ_2_3,
667 },
668 Vector {
669 _handler: ADC_ETC_IRQ0,
670 },
671 Vector {
672 _handler: ADC_ETC_IRQ1,
673 },
674 Vector {
675 _handler: ADC_ETC_IRQ2,
676 },
677 Vector {
678 _handler: ADC_ETC_ERROR_IRQ,
679 },
680 Vector { _handler: PIT },
681 Vector { _handler: ACMP1 },
682 Vector { _handler: ACMP2 },
683 Vector { _handler: ACMP3 },
684 Vector { _handler: ACMP4 },
685 Vector { _reserved: 0 },
686 Vector { _reserved: 0 },
687 Vector { _handler: ENC1 },
688 Vector { _handler: ENC2 },
689 Vector { _handler: ENC3 },
690 Vector { _handler: ENC4 },
691 Vector { _handler: TMR1 },
692 Vector { _handler: TMR2 },
693 Vector { _handler: TMR3 },
694 Vector { _handler: TMR4 },
695 Vector { _handler: PWM2_0 },
696 Vector { _handler: PWM2_1 },
697 Vector { _handler: PWM2_2 },
698 Vector { _handler: PWM2_3 },
699 Vector {
700 _handler: PWM2_FAULT,
701 },
702 Vector { _handler: PWM3_0 },
703 Vector { _handler: PWM3_1 },
704 Vector { _handler: PWM3_2 },
705 Vector { _handler: PWM3_3 },
706 Vector {
707 _handler: PWM3_FAULT,
708 },
709 Vector { _handler: PWM4_0 },
710 Vector { _handler: PWM4_1 },
711 Vector { _handler: PWM4_2 },
712 Vector { _handler: PWM4_3 },
713 Vector {
714 _handler: PWM4_FAULT,
715 },
716 Vector { _handler: ENET2 },
717 Vector {
718 _handler: ENET2_1588_TIMER,
719 },
720 Vector { _handler: CAN3 },
721 Vector { _reserved: 0 },
722 Vector { _handler: FLEXIO3 },
723 Vector {
724 _handler: GPIO6_7_8_9,
725 },
726 ];
727}
728#[path = "."]
729pub mod adc {
730 #[doc = "Analog-to-Digital Converter"]
731 pub const ADC1: *const RegisterBlock = 0x400c_4000 as *const RegisterBlock;
732 #[doc = "Analog-to-Digital Converter"]
733 pub const ADC2: *const RegisterBlock = 0x400c_8000 as *const RegisterBlock;
734 #[path = "blocks/imxrt1021/adc.rs"]
735 mod blocks;
736 pub use blocks::*;
737 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
738 pub type ADC1 = Instance<1>;
739 impl crate::private::Sealed for ADC1 {}
740 impl crate::Valid for ADC1 {}
741 impl ADC1 {
742 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
743 #[doc = r""]
744 #[doc = r" # Safety"]
745 #[doc = r""]
746 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
747 #[inline]
748 pub const unsafe fn instance() -> Self {
749 Instance::new(ADC1)
750 }
751 }
752 pub type ADC2 = Instance<2>;
753 impl crate::private::Sealed for ADC2 {}
754 impl crate::Valid for ADC2 {}
755 impl ADC2 {
756 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
757 #[doc = r""]
758 #[doc = r" # Safety"]
759 #[doc = r""]
760 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
761 #[inline]
762 pub const unsafe fn instance() -> Self {
763 Instance::new(ADC2)
764 }
765 }
766 #[doc = r" Returns the instance number `N` for a peripheral instance."]
767 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
768 [(ADC1, 1), (ADC2, 2)]
769 .into_iter()
770 .find(|(ptr, _)| core::ptr::eq(rb, *ptr))
771 .map(|(_, inst)| inst)
772 }
773}
774#[path = "."]
775pub mod adc_etc {
776 #[doc = "ADC_ETC"]
777 pub const ADC_ETC: *const RegisterBlock = 0x403b_0000 as *const RegisterBlock;
778 #[path = "blocks/imxrt1051/adc_etc.rs"]
779 mod blocks;
780 pub use blocks::*;
781 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
782 pub type ADC_ETC = Instance<{ crate::SOLE_INSTANCE }>;
783 impl crate::private::Sealed for ADC_ETC {}
784 impl crate::Valid for ADC_ETC {}
785 impl ADC_ETC {
786 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
787 #[doc = r""]
788 #[doc = r" # Safety"]
789 #[doc = r""]
790 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
791 #[inline]
792 pub const unsafe fn instance() -> Self {
793 Instance::new(ADC_ETC)
794 }
795 }
796 #[doc = r" Returns the instance number `N` for a peripheral instance."]
797 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
798 core::ptr::eq(rb, ADC_ETC).then_some(0)
799 }
800}
801#[path = "."]
802pub mod aipstz {
803 #[doc = "AIPSTZ Control Registers"]
804 pub const AIPSTZ1: *const RegisterBlock = 0x4007_c000 as *const RegisterBlock;
805 #[doc = "AIPSTZ Control Registers"]
806 pub const AIPSTZ2: *const RegisterBlock = 0x4017_c000 as *const RegisterBlock;
807 #[doc = "AIPSTZ Control Registers"]
808 pub const AIPSTZ3: *const RegisterBlock = 0x4027_c000 as *const RegisterBlock;
809 #[doc = "AIPSTZ Control Registers"]
810 pub const AIPSTZ4: *const RegisterBlock = 0x4037_c000 as *const RegisterBlock;
811 #[path = "blocks/imxrt1011/aipstz.rs"]
812 mod blocks;
813 pub use blocks::*;
814 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
815 pub type AIPSTZ1 = Instance<1>;
816 impl crate::private::Sealed for AIPSTZ1 {}
817 impl crate::Valid for AIPSTZ1 {}
818 impl AIPSTZ1 {
819 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
820 #[doc = r""]
821 #[doc = r" # Safety"]
822 #[doc = r""]
823 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
824 #[inline]
825 pub const unsafe fn instance() -> Self {
826 Instance::new(AIPSTZ1)
827 }
828 }
829 pub type AIPSTZ2 = Instance<2>;
830 impl crate::private::Sealed for AIPSTZ2 {}
831 impl crate::Valid for AIPSTZ2 {}
832 impl AIPSTZ2 {
833 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
834 #[doc = r""]
835 #[doc = r" # Safety"]
836 #[doc = r""]
837 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
838 #[inline]
839 pub const unsafe fn instance() -> Self {
840 Instance::new(AIPSTZ2)
841 }
842 }
843 pub type AIPSTZ3 = Instance<3>;
844 impl crate::private::Sealed for AIPSTZ3 {}
845 impl crate::Valid for AIPSTZ3 {}
846 impl AIPSTZ3 {
847 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
848 #[doc = r""]
849 #[doc = r" # Safety"]
850 #[doc = r""]
851 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
852 #[inline]
853 pub const unsafe fn instance() -> Self {
854 Instance::new(AIPSTZ3)
855 }
856 }
857 pub type AIPSTZ4 = Instance<4>;
858 impl crate::private::Sealed for AIPSTZ4 {}
859 impl crate::Valid for AIPSTZ4 {}
860 impl AIPSTZ4 {
861 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
862 #[doc = r""]
863 #[doc = r" # Safety"]
864 #[doc = r""]
865 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
866 #[inline]
867 pub const unsafe fn instance() -> Self {
868 Instance::new(AIPSTZ4)
869 }
870 }
871 #[doc = r" Returns the instance number `N` for a peripheral instance."]
872 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
873 [(AIPSTZ1, 1), (AIPSTZ2, 2), (AIPSTZ3, 3), (AIPSTZ4, 4)]
874 .into_iter()
875 .find(|(ptr, _)| core::ptr::eq(rb, *ptr))
876 .map(|(_, inst)| inst)
877 }
878}
879#[path = "."]
880pub mod aoi {
881 #[doc = "AND/OR/INVERT module"]
882 pub const AOI1: *const RegisterBlock = 0x403b_4000 as *const RegisterBlock;
883 #[doc = "AND/OR/INVERT module"]
884 pub const AOI2: *const RegisterBlock = 0x403b_8000 as *const RegisterBlock;
885 #[path = "blocks/imxrt1051/aoi.rs"]
886 mod blocks;
887 pub use blocks::*;
888 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
889 pub type AOI1 = Instance<1>;
890 impl crate::private::Sealed for AOI1 {}
891 impl crate::Valid for AOI1 {}
892 impl AOI1 {
893 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
894 #[doc = r""]
895 #[doc = r" # Safety"]
896 #[doc = r""]
897 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
898 #[inline]
899 pub const unsafe fn instance() -> Self {
900 Instance::new(AOI1)
901 }
902 }
903 pub type AOI2 = Instance<2>;
904 impl crate::private::Sealed for AOI2 {}
905 impl crate::Valid for AOI2 {}
906 impl AOI2 {
907 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
908 #[doc = r""]
909 #[doc = r" # Safety"]
910 #[doc = r""]
911 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
912 #[inline]
913 pub const unsafe fn instance() -> Self {
914 Instance::new(AOI2)
915 }
916 }
917 #[doc = r" Returns the instance number `N` for a peripheral instance."]
918 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
919 [(AOI1, 1), (AOI2, 2)]
920 .into_iter()
921 .find(|(ptr, _)| core::ptr::eq(rb, *ptr))
922 .map(|(_, inst)| inst)
923 }
924}
925#[path = "."]
926pub mod bee {
927 #[doc = "Bus Encryption Engine"]
928 pub const BEE: *const RegisterBlock = 0x403e_c000 as *const RegisterBlock;
929 #[path = "blocks/imxrt1015/bee.rs"]
930 mod blocks;
931 pub use blocks::*;
932 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
933 pub type BEE = Instance<{ crate::SOLE_INSTANCE }>;
934 impl crate::private::Sealed for BEE {}
935 impl crate::Valid for BEE {}
936 impl BEE {
937 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
938 #[doc = r""]
939 #[doc = r" # Safety"]
940 #[doc = r""]
941 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
942 #[inline]
943 pub const unsafe fn instance() -> Self {
944 Instance::new(BEE)
945 }
946 }
947 #[doc = r" Returns the instance number `N` for a peripheral instance."]
948 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
949 core::ptr::eq(rb, BEE).then_some(0)
950 }
951}
952#[path = "."]
953pub mod can {
954 #[doc = "FLEXCAN"]
955 pub const CAN1: *const RegisterBlock = 0x401d_0000 as *const RegisterBlock;
956 #[doc = "FLEXCAN"]
957 pub const CAN2: *const RegisterBlock = 0x401d_4000 as *const RegisterBlock;
958 #[path = "blocks/imxrt1061/can.rs"]
959 mod blocks;
960 pub use blocks::*;
961 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
962 pub type CAN1 = Instance<1>;
963 impl crate::private::Sealed for CAN1 {}
964 impl crate::Valid for CAN1 {}
965 impl CAN1 {
966 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
967 #[doc = r""]
968 #[doc = r" # Safety"]
969 #[doc = r""]
970 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
971 #[inline]
972 pub const unsafe fn instance() -> Self {
973 Instance::new(CAN1)
974 }
975 }
976 pub type CAN2 = Instance<2>;
977 impl crate::private::Sealed for CAN2 {}
978 impl crate::Valid for CAN2 {}
979 impl CAN2 {
980 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
981 #[doc = r""]
982 #[doc = r" # Safety"]
983 #[doc = r""]
984 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
985 #[inline]
986 pub const unsafe fn instance() -> Self {
987 Instance::new(CAN2)
988 }
989 }
990 #[doc = r" Returns the instance number `N` for a peripheral instance."]
991 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
992 [(CAN1, 1), (CAN2, 2)]
993 .into_iter()
994 .find(|(ptr, _)| core::ptr::eq(rb, *ptr))
995 .map(|(_, inst)| inst)
996 }
997}
998#[path = "."]
999pub mod can3 {
1000 #[doc = "CAN"]
1001 pub const CAN3: *const RegisterBlock = 0x401d_8000 as *const RegisterBlock;
1002 #[path = "blocks/imxrt1061/can3.rs"]
1003 mod blocks;
1004 pub use blocks::*;
1005 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
1006 pub type CAN3 = Instance<{ crate::SOLE_INSTANCE }>;
1007 impl crate::private::Sealed for CAN3 {}
1008 impl crate::Valid for CAN3 {}
1009 impl CAN3 {
1010 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1011 #[doc = r""]
1012 #[doc = r" # Safety"]
1013 #[doc = r""]
1014 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1015 #[inline]
1016 pub const unsafe fn instance() -> Self {
1017 Instance::new(CAN3)
1018 }
1019 }
1020 #[doc = r" Returns the instance number `N` for a peripheral instance."]
1021 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
1022 core::ptr::eq(rb, CAN3).then_some(0)
1023 }
1024}
1025#[path = "."]
1026pub mod ccm {
1027 #[doc = "CCM"]
1028 pub const CCM: *const RegisterBlock = 0x400f_c000 as *const RegisterBlock;
1029 #[path = "blocks/imxrt1061/ccm.rs"]
1030 mod blocks;
1031 pub use blocks::*;
1032 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
1033 pub type CCM = Instance<{ crate::SOLE_INSTANCE }>;
1034 impl crate::private::Sealed for CCM {}
1035 impl crate::Valid for CCM {}
1036 impl CCM {
1037 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1038 #[doc = r""]
1039 #[doc = r" # Safety"]
1040 #[doc = r""]
1041 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1042 #[inline]
1043 pub const unsafe fn instance() -> Self {
1044 Instance::new(CCM)
1045 }
1046 }
1047 #[doc = r" Returns the instance number `N` for a peripheral instance."]
1048 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
1049 core::ptr::eq(rb, CCM).then_some(0)
1050 }
1051}
1052#[path = "."]
1053pub mod ccm_analog {
1054 #[doc = "CCM_ANALOG"]
1055 pub const CCM_ANALOG: *const RegisterBlock = 0x400d_8000 as *const RegisterBlock;
1056 #[path = "blocks/imxrt1061/ccm_analog.rs"]
1057 mod blocks;
1058 pub use blocks::*;
1059 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
1060 pub type CCM_ANALOG = Instance<{ crate::SOLE_INSTANCE }>;
1061 impl crate::private::Sealed for CCM_ANALOG {}
1062 impl crate::Valid for CCM_ANALOG {}
1063 impl CCM_ANALOG {
1064 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1065 #[doc = r""]
1066 #[doc = r" # Safety"]
1067 #[doc = r""]
1068 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1069 #[inline]
1070 pub const unsafe fn instance() -> Self {
1071 Instance::new(CCM_ANALOG)
1072 }
1073 }
1074 #[doc = r" Returns the instance number `N` for a peripheral instance."]
1075 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
1076 core::ptr::eq(rb, CCM_ANALOG).then_some(0)
1077 }
1078}
1079#[path = "."]
1080pub mod cmp {
1081 #[doc = "High-Speed Comparator (CMP), Voltage Reference (VREF) Digital-to-Analog Converter (DAC), and Analog Mux (ANMUX)"]
1082 pub const CMP1: *const RegisterBlock = 0x4009_4000 as *const RegisterBlock;
1083 #[doc = "High-Speed Comparator (CMP), Voltage Reference (VREF) Digital-to-Analog Converter (DAC), and Analog Mux (ANMUX)"]
1084 pub const CMP2: *const RegisterBlock = 0x4009_4008 as *const RegisterBlock;
1085 #[doc = "High-Speed Comparator (CMP), Voltage Reference (VREF) Digital-to-Analog Converter (DAC), and Analog Mux (ANMUX)"]
1086 pub const CMP3: *const RegisterBlock = 0x4009_4010 as *const RegisterBlock;
1087 #[doc = "High-Speed Comparator (CMP), Voltage Reference (VREF) Digital-to-Analog Converter (DAC), and Analog Mux (ANMUX)"]
1088 pub const CMP4: *const RegisterBlock = 0x4009_4018 as *const RegisterBlock;
1089 #[path = "blocks/imxrt1021/cmp.rs"]
1090 mod blocks;
1091 pub use blocks::*;
1092 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
1093 pub type CMP1 = Instance<1>;
1094 impl crate::private::Sealed for CMP1 {}
1095 impl crate::Valid for CMP1 {}
1096 impl CMP1 {
1097 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1098 #[doc = r""]
1099 #[doc = r" # Safety"]
1100 #[doc = r""]
1101 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1102 #[inline]
1103 pub const unsafe fn instance() -> Self {
1104 Instance::new(CMP1)
1105 }
1106 }
1107 pub type CMP2 = Instance<2>;
1108 impl crate::private::Sealed for CMP2 {}
1109 impl crate::Valid for CMP2 {}
1110 impl CMP2 {
1111 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1112 #[doc = r""]
1113 #[doc = r" # Safety"]
1114 #[doc = r""]
1115 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1116 #[inline]
1117 pub const unsafe fn instance() -> Self {
1118 Instance::new(CMP2)
1119 }
1120 }
1121 pub type CMP3 = Instance<3>;
1122 impl crate::private::Sealed for CMP3 {}
1123 impl crate::Valid for CMP3 {}
1124 impl CMP3 {
1125 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1126 #[doc = r""]
1127 #[doc = r" # Safety"]
1128 #[doc = r""]
1129 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1130 #[inline]
1131 pub const unsafe fn instance() -> Self {
1132 Instance::new(CMP3)
1133 }
1134 }
1135 pub type CMP4 = Instance<4>;
1136 impl crate::private::Sealed for CMP4 {}
1137 impl crate::Valid for CMP4 {}
1138 impl CMP4 {
1139 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1140 #[doc = r""]
1141 #[doc = r" # Safety"]
1142 #[doc = r""]
1143 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1144 #[inline]
1145 pub const unsafe fn instance() -> Self {
1146 Instance::new(CMP4)
1147 }
1148 }
1149 #[doc = r" Returns the instance number `N` for a peripheral instance."]
1150 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
1151 [(CMP1, 1), (CMP2, 2), (CMP3, 3), (CMP4, 4)]
1152 .into_iter()
1153 .find(|(ptr, _)| core::ptr::eq(rb, *ptr))
1154 .map(|(_, inst)| inst)
1155 }
1156}
1157#[path = "."]
1158pub mod csi {
1159 #[doc = "CSI"]
1160 pub const CSI: *const RegisterBlock = 0x402b_c000 as *const RegisterBlock;
1161 #[path = "blocks/imxrt1052/csi.rs"]
1162 mod blocks;
1163 pub use blocks::*;
1164 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
1165 pub type CSI = Instance<{ crate::SOLE_INSTANCE }>;
1166 impl crate::private::Sealed for CSI {}
1167 impl crate::Valid for CSI {}
1168 impl CSI {
1169 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1170 #[doc = r""]
1171 #[doc = r" # Safety"]
1172 #[doc = r""]
1173 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1174 #[inline]
1175 pub const unsafe fn instance() -> Self {
1176 Instance::new(CSI)
1177 }
1178 }
1179 #[doc = r" Returns the instance number `N` for a peripheral instance."]
1180 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
1181 core::ptr::eq(rb, CSI).then_some(0)
1182 }
1183}
1184#[path = "."]
1185pub mod csu {
1186 #[doc = "CSU registers"]
1187 pub const CSU: *const RegisterBlock = 0x400d_c000 as *const RegisterBlock;
1188 #[path = "blocks/imxrt1011/csu.rs"]
1189 mod blocks;
1190 pub use blocks::*;
1191 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
1192 pub type CSU = Instance<{ crate::SOLE_INSTANCE }>;
1193 impl crate::private::Sealed for CSU {}
1194 impl crate::Valid for CSU {}
1195 impl CSU {
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(CSU)
1204 }
1205 }
1206 #[doc = r" Returns the instance number `N` for a peripheral instance."]
1207 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
1208 core::ptr::eq(rb, CSU).then_some(0)
1209 }
1210}
1211#[path = "."]
1212pub mod dcdc {
1213 #[doc = "DCDC"]
1214 pub const DCDC: *const RegisterBlock = 0x4008_0000 as *const RegisterBlock;
1215 #[path = "blocks/imxrt1051/dcdc.rs"]
1216 mod blocks;
1217 pub use blocks::*;
1218 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
1219 pub type DCDC = Instance<{ crate::SOLE_INSTANCE }>;
1220 impl crate::private::Sealed for DCDC {}
1221 impl crate::Valid for DCDC {}
1222 impl DCDC {
1223 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1224 #[doc = r""]
1225 #[doc = r" # Safety"]
1226 #[doc = r""]
1227 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1228 #[inline]
1229 pub const unsafe fn instance() -> Self {
1230 Instance::new(DCDC)
1231 }
1232 }
1233 #[doc = r" Returns the instance number `N` for a peripheral instance."]
1234 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
1235 core::ptr::eq(rb, DCDC).then_some(0)
1236 }
1237}
1238#[path = "."]
1239pub mod dcp {
1240 #[doc = "DCP register reference index"]
1241 pub const DCP: *const RegisterBlock = 0x402f_c000 as *const RegisterBlock;
1242 #[path = "blocks/imxrt1011/dcp.rs"]
1243 mod blocks;
1244 pub use blocks::*;
1245 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
1246 pub type DCP = Instance<{ crate::SOLE_INSTANCE }>;
1247 impl crate::private::Sealed for DCP {}
1248 impl crate::Valid for DCP {}
1249 impl DCP {
1250 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1251 #[doc = r""]
1252 #[doc = r" # Safety"]
1253 #[doc = r""]
1254 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1255 #[inline]
1256 pub const unsafe fn instance() -> Self {
1257 Instance::new(DCP)
1258 }
1259 }
1260 #[doc = r" Returns the instance number `N` for a peripheral instance."]
1261 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
1262 core::ptr::eq(rb, DCP).then_some(0)
1263 }
1264}
1265#[path = "."]
1266pub mod dma {
1267 #[doc = "DMA"]
1268 pub const DMA: *const RegisterBlock = 0x400e_8000 as *const RegisterBlock;
1269 #[path = "blocks/imxrt1051/dma.rs"]
1270 mod blocks;
1271 pub use blocks::*;
1272 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
1273 pub type DMA = Instance<{ crate::SOLE_INSTANCE }>;
1274 impl crate::private::Sealed for DMA {}
1275 impl crate::Valid for DMA {}
1276 impl DMA {
1277 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1278 #[doc = r""]
1279 #[doc = r" # Safety"]
1280 #[doc = r""]
1281 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1282 #[inline]
1283 pub const unsafe fn instance() -> Self {
1284 Instance::new(DMA)
1285 }
1286 }
1287 #[doc = r" Returns the instance number `N` for a peripheral instance."]
1288 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
1289 core::ptr::eq(rb, DMA).then_some(0)
1290 }
1291}
1292#[path = "."]
1293pub mod dmamux {
1294 #[doc = "DMA_CH_MUX"]
1295 pub const DMAMUX: *const RegisterBlock = 0x400e_c000 as *const RegisterBlock;
1296 #[path = "blocks/imxrt1015/dmamux.rs"]
1297 mod blocks;
1298 pub use blocks::*;
1299 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
1300 pub type DMAMUX = Instance<{ crate::SOLE_INSTANCE }>;
1301 impl crate::private::Sealed for DMAMUX {}
1302 impl crate::Valid for DMAMUX {}
1303 impl DMAMUX {
1304 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1305 #[doc = r""]
1306 #[doc = r" # Safety"]
1307 #[doc = r""]
1308 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1309 #[inline]
1310 pub const unsafe fn instance() -> Self {
1311 Instance::new(DMAMUX)
1312 }
1313 }
1314 #[doc = r" Returns the instance number `N` for a peripheral instance."]
1315 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
1316 core::ptr::eq(rb, DMAMUX).then_some(0)
1317 }
1318}
1319#[path = "."]
1320pub mod enc {
1321 #[doc = "Quadrature Decoder"]
1322 pub const ENC1: *const RegisterBlock = 0x403c_8000 as *const RegisterBlock;
1323 #[doc = "Quadrature Decoder"]
1324 pub const ENC2: *const RegisterBlock = 0x403c_c000 as *const RegisterBlock;
1325 #[doc = "Quadrature Decoder"]
1326 pub const ENC3: *const RegisterBlock = 0x403d_0000 as *const RegisterBlock;
1327 #[doc = "Quadrature Decoder"]
1328 pub const ENC4: *const RegisterBlock = 0x403d_4000 as *const RegisterBlock;
1329 #[path = "blocks/imxrt1021/enc.rs"]
1330 mod blocks;
1331 pub use blocks::*;
1332 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
1333 pub type ENC1 = Instance<1>;
1334 impl crate::private::Sealed for ENC1 {}
1335 impl crate::Valid for ENC1 {}
1336 impl ENC1 {
1337 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1338 #[doc = r""]
1339 #[doc = r" # Safety"]
1340 #[doc = r""]
1341 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1342 #[inline]
1343 pub const unsafe fn instance() -> Self {
1344 Instance::new(ENC1)
1345 }
1346 }
1347 pub type ENC2 = Instance<2>;
1348 impl crate::private::Sealed for ENC2 {}
1349 impl crate::Valid for ENC2 {}
1350 impl ENC2 {
1351 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1352 #[doc = r""]
1353 #[doc = r" # Safety"]
1354 #[doc = r""]
1355 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1356 #[inline]
1357 pub const unsafe fn instance() -> Self {
1358 Instance::new(ENC2)
1359 }
1360 }
1361 pub type ENC3 = Instance<3>;
1362 impl crate::private::Sealed for ENC3 {}
1363 impl crate::Valid for ENC3 {}
1364 impl ENC3 {
1365 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1366 #[doc = r""]
1367 #[doc = r" # Safety"]
1368 #[doc = r""]
1369 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1370 #[inline]
1371 pub const unsafe fn instance() -> Self {
1372 Instance::new(ENC3)
1373 }
1374 }
1375 pub type ENC4 = Instance<4>;
1376 impl crate::private::Sealed for ENC4 {}
1377 impl crate::Valid for ENC4 {}
1378 impl ENC4 {
1379 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1380 #[doc = r""]
1381 #[doc = r" # Safety"]
1382 #[doc = r""]
1383 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1384 #[inline]
1385 pub const unsafe fn instance() -> Self {
1386 Instance::new(ENC4)
1387 }
1388 }
1389 #[doc = r" Returns the instance number `N` for a peripheral instance."]
1390 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
1391 [(ENC1, 1), (ENC2, 2), (ENC3, 3), (ENC4, 4)]
1392 .into_iter()
1393 .find(|(ptr, _)| core::ptr::eq(rb, *ptr))
1394 .map(|(_, inst)| inst)
1395 }
1396}
1397#[path = "."]
1398pub mod enet {
1399 #[doc = "Ethernet MAC-NET Core"]
1400 pub const ENET1: *const RegisterBlock = 0x402d_8000 as *const RegisterBlock;
1401 #[doc = "Ethernet MAC-NET Core"]
1402 pub const ENET2: *const RegisterBlock = 0x402d_4000 as *const RegisterBlock;
1403 #[path = "blocks/imxrt1061/enet.rs"]
1404 mod blocks;
1405 pub use blocks::*;
1406 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
1407 pub type ENET1 = Instance<1>;
1408 impl crate::private::Sealed for ENET1 {}
1409 impl crate::Valid for ENET1 {}
1410 impl ENET1 {
1411 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1412 #[doc = r""]
1413 #[doc = r" # Safety"]
1414 #[doc = r""]
1415 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1416 #[inline]
1417 pub const unsafe fn instance() -> Self {
1418 Instance::new(ENET1)
1419 }
1420 }
1421 pub type ENET2 = Instance<2>;
1422 impl crate::private::Sealed for ENET2 {}
1423 impl crate::Valid for ENET2 {}
1424 impl ENET2 {
1425 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1426 #[doc = r""]
1427 #[doc = r" # Safety"]
1428 #[doc = r""]
1429 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1430 #[inline]
1431 pub const unsafe fn instance() -> Self {
1432 Instance::new(ENET2)
1433 }
1434 }
1435 #[doc = r" Returns the instance number `N` for a peripheral instance."]
1436 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
1437 [(ENET1, 1), (ENET2, 2)]
1438 .into_iter()
1439 .find(|(ptr, _)| core::ptr::eq(rb, *ptr))
1440 .map(|(_, inst)| inst)
1441 }
1442}
1443#[path = "."]
1444pub mod ewm {
1445 #[doc = "EWM"]
1446 pub const EWM: *const RegisterBlock = 0x400b_4000 as *const RegisterBlock;
1447 #[path = "blocks/imxrt1011/ewm.rs"]
1448 mod blocks;
1449 pub use blocks::*;
1450 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
1451 pub type EWM = Instance<{ crate::SOLE_INSTANCE }>;
1452 impl crate::private::Sealed for EWM {}
1453 impl crate::Valid for EWM {}
1454 impl EWM {
1455 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1456 #[doc = r""]
1457 #[doc = r" # Safety"]
1458 #[doc = r""]
1459 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1460 #[inline]
1461 pub const unsafe fn instance() -> Self {
1462 Instance::new(EWM)
1463 }
1464 }
1465 #[doc = r" Returns the instance number `N` for a peripheral instance."]
1466 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
1467 core::ptr::eq(rb, EWM).then_some(0)
1468 }
1469}
1470#[path = "."]
1471pub mod flexio {
1472 #[doc = "FLEXIO"]
1473 pub const FLEXIO1: *const RegisterBlock = 0x401a_c000 as *const RegisterBlock;
1474 #[doc = "FLEXIO"]
1475 pub const FLEXIO2: *const RegisterBlock = 0x401b_0000 as *const RegisterBlock;
1476 #[doc = "FLEXIO"]
1477 pub const FLEXIO3: *const RegisterBlock = 0x4202_0000 as *const RegisterBlock;
1478 #[path = "blocks/imxrt1061/flexio.rs"]
1479 mod blocks;
1480 pub use blocks::*;
1481 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
1482 pub type FLEXIO1 = Instance<1>;
1483 impl crate::private::Sealed for FLEXIO1 {}
1484 impl crate::Valid for FLEXIO1 {}
1485 impl FLEXIO1 {
1486 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1487 #[doc = r""]
1488 #[doc = r" # Safety"]
1489 #[doc = r""]
1490 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1491 #[inline]
1492 pub const unsafe fn instance() -> Self {
1493 Instance::new(FLEXIO1)
1494 }
1495 }
1496 pub type FLEXIO2 = Instance<2>;
1497 impl crate::private::Sealed for FLEXIO2 {}
1498 impl crate::Valid for FLEXIO2 {}
1499 impl FLEXIO2 {
1500 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1501 #[doc = r""]
1502 #[doc = r" # Safety"]
1503 #[doc = r""]
1504 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1505 #[inline]
1506 pub const unsafe fn instance() -> Self {
1507 Instance::new(FLEXIO2)
1508 }
1509 }
1510 pub type FLEXIO3 = Instance<3>;
1511 impl crate::private::Sealed for FLEXIO3 {}
1512 impl crate::Valid for FLEXIO3 {}
1513 impl FLEXIO3 {
1514 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1515 #[doc = r""]
1516 #[doc = r" # Safety"]
1517 #[doc = r""]
1518 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1519 #[inline]
1520 pub const unsafe fn instance() -> Self {
1521 Instance::new(FLEXIO3)
1522 }
1523 }
1524 #[doc = r" Returns the instance number `N` for a peripheral instance."]
1525 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
1526 [(FLEXIO1, 1), (FLEXIO2, 2), (FLEXIO3, 3)]
1527 .into_iter()
1528 .find(|(ptr, _)| core::ptr::eq(rb, *ptr))
1529 .map(|(_, inst)| inst)
1530 }
1531}
1532#[path = "."]
1533pub mod flexram {
1534 #[doc = "FLEXRAM"]
1535 pub const FLEXRAM: *const RegisterBlock = 0x400b_0000 as *const RegisterBlock;
1536 #[path = "blocks/imxrt1015/flexram.rs"]
1537 mod blocks;
1538 pub use blocks::*;
1539 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
1540 pub type FLEXRAM = Instance<{ crate::SOLE_INSTANCE }>;
1541 impl crate::private::Sealed for FLEXRAM {}
1542 impl crate::Valid for FLEXRAM {}
1543 impl FLEXRAM {
1544 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1545 #[doc = r""]
1546 #[doc = r" # Safety"]
1547 #[doc = r""]
1548 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1549 #[inline]
1550 pub const unsafe fn instance() -> Self {
1551 Instance::new(FLEXRAM)
1552 }
1553 }
1554 #[doc = r" Returns the instance number `N` for a peripheral instance."]
1555 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
1556 core::ptr::eq(rb, FLEXRAM).then_some(0)
1557 }
1558}
1559#[path = "."]
1560pub mod flexspi {
1561 #[doc = "FlexSPI"]
1562 pub const FLEXSPI1: *const RegisterBlock = 0x402a_8000 as *const RegisterBlock;
1563 #[doc = "FlexSPI"]
1564 pub const FLEXSPI2: *const RegisterBlock = 0x402a_4000 as *const RegisterBlock;
1565 #[path = "blocks/imxrt1061/flexspi.rs"]
1566 mod blocks;
1567 pub use blocks::*;
1568 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
1569 pub type FLEXSPI1 = Instance<1>;
1570 impl crate::private::Sealed for FLEXSPI1 {}
1571 impl crate::Valid for FLEXSPI1 {}
1572 impl FLEXSPI1 {
1573 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1574 #[doc = r""]
1575 #[doc = r" # Safety"]
1576 #[doc = r""]
1577 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1578 #[inline]
1579 pub const unsafe fn instance() -> Self {
1580 Instance::new(FLEXSPI1)
1581 }
1582 }
1583 pub type FLEXSPI2 = Instance<2>;
1584 impl crate::private::Sealed for FLEXSPI2 {}
1585 impl crate::Valid for FLEXSPI2 {}
1586 impl FLEXSPI2 {
1587 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1588 #[doc = r""]
1589 #[doc = r" # Safety"]
1590 #[doc = r""]
1591 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1592 #[inline]
1593 pub const unsafe fn instance() -> Self {
1594 Instance::new(FLEXSPI2)
1595 }
1596 }
1597 #[doc = r" Returns the instance number `N` for a peripheral instance."]
1598 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
1599 [(FLEXSPI1, 1), (FLEXSPI2, 2)]
1600 .into_iter()
1601 .find(|(ptr, _)| core::ptr::eq(rb, *ptr))
1602 .map(|(_, inst)| inst)
1603 }
1604}
1605#[path = "."]
1606pub mod gpc {
1607 #[doc = "GPC"]
1608 pub const GPC: *const RegisterBlock = 0x400f_4000 as *const RegisterBlock;
1609 #[path = "blocks/imxrt1011/gpc.rs"]
1610 mod blocks;
1611 pub use blocks::*;
1612 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
1613 pub type GPC = Instance<{ crate::SOLE_INSTANCE }>;
1614 impl crate::private::Sealed for GPC {}
1615 impl crate::Valid for GPC {}
1616 impl GPC {
1617 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1618 #[doc = r""]
1619 #[doc = r" # Safety"]
1620 #[doc = r""]
1621 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1622 #[inline]
1623 pub const unsafe fn instance() -> Self {
1624 Instance::new(GPC)
1625 }
1626 }
1627 #[doc = r" Returns the instance number `N` for a peripheral instance."]
1628 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
1629 core::ptr::eq(rb, GPC).then_some(0)
1630 }
1631}
1632#[path = "."]
1633pub mod gpio {
1634 #[doc = "GPIO"]
1635 pub const GPIO1: *const RegisterBlock = 0x401b_8000 as *const RegisterBlock;
1636 #[doc = "GPIO"]
1637 pub const GPIO5: *const RegisterBlock = 0x400c_0000 as *const RegisterBlock;
1638 #[doc = "GPIO"]
1639 pub const GPIO2: *const RegisterBlock = 0x401b_c000 as *const RegisterBlock;
1640 #[doc = "GPIO"]
1641 pub const GPIO3: *const RegisterBlock = 0x401c_0000 as *const RegisterBlock;
1642 #[doc = "GPIO"]
1643 pub const GPIO4: *const RegisterBlock = 0x401c_4000 as *const RegisterBlock;
1644 #[doc = "GPIO"]
1645 pub const GPIO6: *const RegisterBlock = 0x4200_0000 as *const RegisterBlock;
1646 #[doc = "GPIO"]
1647 pub const GPIO7: *const RegisterBlock = 0x4200_4000 as *const RegisterBlock;
1648 #[doc = "GPIO"]
1649 pub const GPIO8: *const RegisterBlock = 0x4200_8000 as *const RegisterBlock;
1650 #[doc = "GPIO"]
1651 pub const GPIO9: *const RegisterBlock = 0x4200_c000 as *const RegisterBlock;
1652 #[path = "blocks/imxrt1011/gpio.rs"]
1653 mod blocks;
1654 pub use blocks::*;
1655 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
1656 pub type GPIO1 = Instance<1>;
1657 impl crate::private::Sealed for GPIO1 {}
1658 impl crate::Valid for GPIO1 {}
1659 impl GPIO1 {
1660 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1661 #[doc = r""]
1662 #[doc = r" # Safety"]
1663 #[doc = r""]
1664 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1665 #[inline]
1666 pub const unsafe fn instance() -> Self {
1667 Instance::new(GPIO1)
1668 }
1669 }
1670 pub type GPIO5 = Instance<5>;
1671 impl crate::private::Sealed for GPIO5 {}
1672 impl crate::Valid for GPIO5 {}
1673 impl GPIO5 {
1674 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1675 #[doc = r""]
1676 #[doc = r" # Safety"]
1677 #[doc = r""]
1678 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1679 #[inline]
1680 pub const unsafe fn instance() -> Self {
1681 Instance::new(GPIO5)
1682 }
1683 }
1684 pub type GPIO2 = Instance<2>;
1685 impl crate::private::Sealed for GPIO2 {}
1686 impl crate::Valid for GPIO2 {}
1687 impl GPIO2 {
1688 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1689 #[doc = r""]
1690 #[doc = r" # Safety"]
1691 #[doc = r""]
1692 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1693 #[inline]
1694 pub const unsafe fn instance() -> Self {
1695 Instance::new(GPIO2)
1696 }
1697 }
1698 pub type GPIO3 = Instance<3>;
1699 impl crate::private::Sealed for GPIO3 {}
1700 impl crate::Valid for GPIO3 {}
1701 impl GPIO3 {
1702 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1703 #[doc = r""]
1704 #[doc = r" # Safety"]
1705 #[doc = r""]
1706 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1707 #[inline]
1708 pub const unsafe fn instance() -> Self {
1709 Instance::new(GPIO3)
1710 }
1711 }
1712 pub type GPIO4 = Instance<4>;
1713 impl crate::private::Sealed for GPIO4 {}
1714 impl crate::Valid for GPIO4 {}
1715 impl GPIO4 {
1716 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1717 #[doc = r""]
1718 #[doc = r" # Safety"]
1719 #[doc = r""]
1720 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1721 #[inline]
1722 pub const unsafe fn instance() -> Self {
1723 Instance::new(GPIO4)
1724 }
1725 }
1726 pub type GPIO6 = Instance<6>;
1727 impl crate::private::Sealed for GPIO6 {}
1728 impl crate::Valid for GPIO6 {}
1729 impl GPIO6 {
1730 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1731 #[doc = r""]
1732 #[doc = r" # Safety"]
1733 #[doc = r""]
1734 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1735 #[inline]
1736 pub const unsafe fn instance() -> Self {
1737 Instance::new(GPIO6)
1738 }
1739 }
1740 pub type GPIO7 = Instance<7>;
1741 impl crate::private::Sealed for GPIO7 {}
1742 impl crate::Valid for GPIO7 {}
1743 impl GPIO7 {
1744 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1745 #[doc = r""]
1746 #[doc = r" # Safety"]
1747 #[doc = r""]
1748 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1749 #[inline]
1750 pub const unsafe fn instance() -> Self {
1751 Instance::new(GPIO7)
1752 }
1753 }
1754 pub type GPIO8 = Instance<8>;
1755 impl crate::private::Sealed for GPIO8 {}
1756 impl crate::Valid for GPIO8 {}
1757 impl GPIO8 {
1758 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1759 #[doc = r""]
1760 #[doc = r" # Safety"]
1761 #[doc = r""]
1762 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1763 #[inline]
1764 pub const unsafe fn instance() -> Self {
1765 Instance::new(GPIO8)
1766 }
1767 }
1768 pub type GPIO9 = Instance<9>;
1769 impl crate::private::Sealed for GPIO9 {}
1770 impl crate::Valid for GPIO9 {}
1771 impl GPIO9 {
1772 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1773 #[doc = r""]
1774 #[doc = r" # Safety"]
1775 #[doc = r""]
1776 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1777 #[inline]
1778 pub const unsafe fn instance() -> Self {
1779 Instance::new(GPIO9)
1780 }
1781 }
1782 #[doc = r" Returns the instance number `N` for a peripheral instance."]
1783 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
1784 [
1785 (GPIO1, 1),
1786 (GPIO5, 5),
1787 (GPIO2, 2),
1788 (GPIO3, 3),
1789 (GPIO4, 4),
1790 (GPIO6, 6),
1791 (GPIO7, 7),
1792 (GPIO8, 8),
1793 (GPIO9, 9),
1794 ]
1795 .into_iter()
1796 .find(|(ptr, _)| core::ptr::eq(rb, *ptr))
1797 .map(|(_, inst)| inst)
1798 }
1799}
1800#[path = "."]
1801pub mod gpt {
1802 #[doc = "GPT"]
1803 pub const GPT1: *const RegisterBlock = 0x401e_c000 as *const RegisterBlock;
1804 #[doc = "GPT"]
1805 pub const GPT2: *const RegisterBlock = 0x401f_0000 as *const RegisterBlock;
1806 #[path = "blocks/imxrt1011/gpt.rs"]
1807 mod blocks;
1808 pub use blocks::*;
1809 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
1810 pub type GPT1 = Instance<1>;
1811 impl crate::private::Sealed for GPT1 {}
1812 impl crate::Valid for GPT1 {}
1813 impl GPT1 {
1814 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1815 #[doc = r""]
1816 #[doc = r" # Safety"]
1817 #[doc = r""]
1818 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1819 #[inline]
1820 pub const unsafe fn instance() -> Self {
1821 Instance::new(GPT1)
1822 }
1823 }
1824 pub type GPT2 = Instance<2>;
1825 impl crate::private::Sealed for GPT2 {}
1826 impl crate::Valid for GPT2 {}
1827 impl GPT2 {
1828 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1829 #[doc = r""]
1830 #[doc = r" # Safety"]
1831 #[doc = r""]
1832 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1833 #[inline]
1834 pub const unsafe fn instance() -> Self {
1835 Instance::new(GPT2)
1836 }
1837 }
1838 #[doc = r" Returns the instance number `N` for a peripheral instance."]
1839 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
1840 [(GPT1, 1), (GPT2, 2)]
1841 .into_iter()
1842 .find(|(ptr, _)| core::ptr::eq(rb, *ptr))
1843 .map(|(_, inst)| inst)
1844 }
1845}
1846#[path = "."]
1847pub mod iomuxc {
1848 #[doc = "IOMUXC"]
1849 pub const IOMUXC: *const RegisterBlock = 0x401f_8000 as *const RegisterBlock;
1850 #[path = "blocks/imxrt1061/iomuxc.rs"]
1851 mod blocks;
1852 pub use blocks::*;
1853 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
1854 pub type IOMUXC = Instance<{ crate::SOLE_INSTANCE }>;
1855 impl crate::private::Sealed for IOMUXC {}
1856 impl crate::Valid for IOMUXC {}
1857 impl IOMUXC {
1858 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1859 #[doc = r""]
1860 #[doc = r" # Safety"]
1861 #[doc = r""]
1862 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1863 #[inline]
1864 pub const unsafe fn instance() -> Self {
1865 Instance::new(IOMUXC)
1866 }
1867 }
1868 #[doc = r" Returns the instance number `N` for a peripheral instance."]
1869 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
1870 core::ptr::eq(rb, IOMUXC).then_some(0)
1871 }
1872}
1873#[path = "."]
1874pub mod iomuxc_gpr {
1875 #[doc = "IOMUXC_GPR"]
1876 pub const IOMUXC_GPR: *const RegisterBlock = 0x400a_c000 as *const RegisterBlock;
1877 #[path = "blocks/imxrt1061/iomuxc_gpr.rs"]
1878 mod blocks;
1879 pub use blocks::*;
1880 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
1881 pub type IOMUXC_GPR = Instance<{ crate::SOLE_INSTANCE }>;
1882 impl crate::private::Sealed for IOMUXC_GPR {}
1883 impl crate::Valid for IOMUXC_GPR {}
1884 impl IOMUXC_GPR {
1885 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1886 #[doc = r""]
1887 #[doc = r" # Safety"]
1888 #[doc = r""]
1889 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1890 #[inline]
1891 pub const unsafe fn instance() -> Self {
1892 Instance::new(IOMUXC_GPR)
1893 }
1894 }
1895 #[doc = r" Returns the instance number `N` for a peripheral instance."]
1896 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
1897 core::ptr::eq(rb, IOMUXC_GPR).then_some(0)
1898 }
1899}
1900#[path = "."]
1901pub mod iomuxc_snvs {
1902 #[doc = "IOMUXC_SNVS"]
1903 pub const IOMUXC_SNVS: *const RegisterBlock = 0x400a_8000 as *const RegisterBlock;
1904 #[path = "blocks/imxrt1021/iomuxc_snvs.rs"]
1905 mod blocks;
1906 pub use blocks::*;
1907 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
1908 pub type IOMUXC_SNVS = Instance<{ crate::SOLE_INSTANCE }>;
1909 impl crate::private::Sealed for IOMUXC_SNVS {}
1910 impl crate::Valid for IOMUXC_SNVS {}
1911 impl IOMUXC_SNVS {
1912 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1913 #[doc = r""]
1914 #[doc = r" # Safety"]
1915 #[doc = r""]
1916 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1917 #[inline]
1918 pub const unsafe fn instance() -> Self {
1919 Instance::new(IOMUXC_SNVS)
1920 }
1921 }
1922 #[doc = r" Returns the instance number `N` for a peripheral instance."]
1923 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
1924 core::ptr::eq(rb, IOMUXC_SNVS).then_some(0)
1925 }
1926}
1927#[path = "."]
1928pub mod iomuxc_snvs_gpr {
1929 #[doc = "IOMUXC"]
1930 pub const IOMUXC_SNVS_GPR: *const RegisterBlock = 0x400a_4000 as *const RegisterBlock;
1931 #[path = "blocks/imxrt1011/iomuxc_snvs_gpr.rs"]
1932 mod blocks;
1933 pub use blocks::*;
1934 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
1935 pub type IOMUXC_SNVS_GPR = Instance<{ crate::SOLE_INSTANCE }>;
1936 impl crate::private::Sealed for IOMUXC_SNVS_GPR {}
1937 impl crate::Valid for IOMUXC_SNVS_GPR {}
1938 impl IOMUXC_SNVS_GPR {
1939 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1940 #[doc = r""]
1941 #[doc = r" # Safety"]
1942 #[doc = r""]
1943 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1944 #[inline]
1945 pub const unsafe fn instance() -> Self {
1946 Instance::new(IOMUXC_SNVS_GPR)
1947 }
1948 }
1949 #[doc = r" Returns the instance number `N` for a peripheral instance."]
1950 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
1951 core::ptr::eq(rb, IOMUXC_SNVS_GPR).then_some(0)
1952 }
1953}
1954#[path = "."]
1955pub mod kpp {
1956 #[doc = "KPP Registers"]
1957 pub const KPP: *const RegisterBlock = 0x401f_c000 as *const RegisterBlock;
1958 #[path = "blocks/imxrt1011/kpp.rs"]
1959 mod blocks;
1960 pub use blocks::*;
1961 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
1962 pub type KPP = Instance<{ crate::SOLE_INSTANCE }>;
1963 impl crate::private::Sealed for KPP {}
1964 impl crate::Valid for KPP {}
1965 impl KPP {
1966 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1967 #[doc = r""]
1968 #[doc = r" # Safety"]
1969 #[doc = r""]
1970 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1971 #[inline]
1972 pub const unsafe fn instance() -> Self {
1973 Instance::new(KPP)
1974 }
1975 }
1976 #[doc = r" Returns the instance number `N` for a peripheral instance."]
1977 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
1978 core::ptr::eq(rb, KPP).then_some(0)
1979 }
1980}
1981#[path = "."]
1982pub mod lcdif {
1983 #[doc = "LCDIF Register Reference Index"]
1984 pub const LCDIF: *const RegisterBlock = 0x402b_8000 as *const RegisterBlock;
1985 #[path = "blocks/imxrt1062/lcdif.rs"]
1986 mod blocks;
1987 pub use blocks::*;
1988 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
1989 pub type LCDIF = Instance<{ crate::SOLE_INSTANCE }>;
1990 impl crate::private::Sealed for LCDIF {}
1991 impl crate::Valid for LCDIF {}
1992 impl LCDIF {
1993 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
1994 #[doc = r""]
1995 #[doc = r" # Safety"]
1996 #[doc = r""]
1997 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
1998 #[inline]
1999 pub const unsafe fn instance() -> Self {
2000 Instance::new(LCDIF)
2001 }
2002 }
2003 #[doc = r" Returns the instance number `N` for a peripheral instance."]
2004 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
2005 core::ptr::eq(rb, LCDIF).then_some(0)
2006 }
2007}
2008#[path = "."]
2009pub mod lpi2c {
2010 #[doc = "LPI2C"]
2011 pub const LPI2C1: *const RegisterBlock = 0x403f_0000 as *const RegisterBlock;
2012 #[doc = "LPI2C"]
2013 pub const LPI2C2: *const RegisterBlock = 0x403f_4000 as *const RegisterBlock;
2014 #[doc = "LPI2C"]
2015 pub const LPI2C3: *const RegisterBlock = 0x403f_8000 as *const RegisterBlock;
2016 #[doc = "LPI2C"]
2017 pub const LPI2C4: *const RegisterBlock = 0x403f_c000 as *const RegisterBlock;
2018 #[path = "blocks/imxrt1011/lpi2c.rs"]
2019 mod blocks;
2020 pub use blocks::*;
2021 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
2022 pub type LPI2C1 = Instance<1>;
2023 impl crate::private::Sealed for LPI2C1 {}
2024 impl crate::Valid for LPI2C1 {}
2025 impl LPI2C1 {
2026 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
2027 #[doc = r""]
2028 #[doc = r" # Safety"]
2029 #[doc = r""]
2030 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
2031 #[inline]
2032 pub const unsafe fn instance() -> Self {
2033 Instance::new(LPI2C1)
2034 }
2035 }
2036 pub type LPI2C2 = Instance<2>;
2037 impl crate::private::Sealed for LPI2C2 {}
2038 impl crate::Valid for LPI2C2 {}
2039 impl LPI2C2 {
2040 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
2041 #[doc = r""]
2042 #[doc = r" # Safety"]
2043 #[doc = r""]
2044 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
2045 #[inline]
2046 pub const unsafe fn instance() -> Self {
2047 Instance::new(LPI2C2)
2048 }
2049 }
2050 pub type LPI2C3 = Instance<3>;
2051 impl crate::private::Sealed for LPI2C3 {}
2052 impl crate::Valid for LPI2C3 {}
2053 impl LPI2C3 {
2054 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
2055 #[doc = r""]
2056 #[doc = r" # Safety"]
2057 #[doc = r""]
2058 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
2059 #[inline]
2060 pub const unsafe fn instance() -> Self {
2061 Instance::new(LPI2C3)
2062 }
2063 }
2064 pub type LPI2C4 = Instance<4>;
2065 impl crate::private::Sealed for LPI2C4 {}
2066 impl crate::Valid for LPI2C4 {}
2067 impl LPI2C4 {
2068 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
2069 #[doc = r""]
2070 #[doc = r" # Safety"]
2071 #[doc = r""]
2072 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
2073 #[inline]
2074 pub const unsafe fn instance() -> Self {
2075 Instance::new(LPI2C4)
2076 }
2077 }
2078 #[doc = r" Returns the instance number `N` for a peripheral instance."]
2079 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
2080 [(LPI2C1, 1), (LPI2C2, 2), (LPI2C3, 3), (LPI2C4, 4)]
2081 .into_iter()
2082 .find(|(ptr, _)| core::ptr::eq(rb, *ptr))
2083 .map(|(_, inst)| inst)
2084 }
2085}
2086#[path = "."]
2087pub mod lpspi {
2088 #[doc = "LPSPI"]
2089 pub const LPSPI1: *const RegisterBlock = 0x4039_4000 as *const RegisterBlock;
2090 #[doc = "LPSPI"]
2091 pub const LPSPI2: *const RegisterBlock = 0x4039_8000 as *const RegisterBlock;
2092 #[doc = "LPSPI"]
2093 pub const LPSPI3: *const RegisterBlock = 0x4039_c000 as *const RegisterBlock;
2094 #[doc = "LPSPI"]
2095 pub const LPSPI4: *const RegisterBlock = 0x403a_0000 as *const RegisterBlock;
2096 #[path = "blocks/imxrt1011/lpspi.rs"]
2097 mod blocks;
2098 pub use blocks::*;
2099 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
2100 pub type LPSPI1 = Instance<1>;
2101 impl crate::private::Sealed for LPSPI1 {}
2102 impl crate::Valid for LPSPI1 {}
2103 impl LPSPI1 {
2104 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
2105 #[doc = r""]
2106 #[doc = r" # Safety"]
2107 #[doc = r""]
2108 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
2109 #[inline]
2110 pub const unsafe fn instance() -> Self {
2111 Instance::new(LPSPI1)
2112 }
2113 }
2114 pub type LPSPI2 = Instance<2>;
2115 impl crate::private::Sealed for LPSPI2 {}
2116 impl crate::Valid for LPSPI2 {}
2117 impl LPSPI2 {
2118 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
2119 #[doc = r""]
2120 #[doc = r" # Safety"]
2121 #[doc = r""]
2122 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
2123 #[inline]
2124 pub const unsafe fn instance() -> Self {
2125 Instance::new(LPSPI2)
2126 }
2127 }
2128 pub type LPSPI3 = Instance<3>;
2129 impl crate::private::Sealed for LPSPI3 {}
2130 impl crate::Valid for LPSPI3 {}
2131 impl LPSPI3 {
2132 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
2133 #[doc = r""]
2134 #[doc = r" # Safety"]
2135 #[doc = r""]
2136 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
2137 #[inline]
2138 pub const unsafe fn instance() -> Self {
2139 Instance::new(LPSPI3)
2140 }
2141 }
2142 pub type LPSPI4 = Instance<4>;
2143 impl crate::private::Sealed for LPSPI4 {}
2144 impl crate::Valid for LPSPI4 {}
2145 impl LPSPI4 {
2146 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
2147 #[doc = r""]
2148 #[doc = r" # Safety"]
2149 #[doc = r""]
2150 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
2151 #[inline]
2152 pub const unsafe fn instance() -> Self {
2153 Instance::new(LPSPI4)
2154 }
2155 }
2156 #[doc = r" Returns the instance number `N` for a peripheral instance."]
2157 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
2158 [(LPSPI1, 1), (LPSPI2, 2), (LPSPI3, 3), (LPSPI4, 4)]
2159 .into_iter()
2160 .find(|(ptr, _)| core::ptr::eq(rb, *ptr))
2161 .map(|(_, inst)| inst)
2162 }
2163}
2164#[path = "."]
2165pub mod lpuart {
2166 #[doc = "LPUART"]
2167 pub const LPUART1: *const RegisterBlock = 0x4018_4000 as *const RegisterBlock;
2168 #[doc = "LPUART"]
2169 pub const LPUART2: *const RegisterBlock = 0x4018_8000 as *const RegisterBlock;
2170 #[doc = "LPUART"]
2171 pub const LPUART3: *const RegisterBlock = 0x4018_c000 as *const RegisterBlock;
2172 #[doc = "LPUART"]
2173 pub const LPUART4: *const RegisterBlock = 0x4019_0000 as *const RegisterBlock;
2174 #[doc = "LPUART"]
2175 pub const LPUART5: *const RegisterBlock = 0x4019_4000 as *const RegisterBlock;
2176 #[doc = "LPUART"]
2177 pub const LPUART6: *const RegisterBlock = 0x4019_8000 as *const RegisterBlock;
2178 #[doc = "LPUART"]
2179 pub const LPUART7: *const RegisterBlock = 0x4019_c000 as *const RegisterBlock;
2180 #[doc = "LPUART"]
2181 pub const LPUART8: *const RegisterBlock = 0x401a_0000 as *const RegisterBlock;
2182 #[path = "blocks/imxrt1011/lpuart.rs"]
2183 mod blocks;
2184 pub use blocks::*;
2185 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
2186 pub type LPUART1 = Instance<1>;
2187 impl crate::private::Sealed for LPUART1 {}
2188 impl crate::Valid for LPUART1 {}
2189 impl LPUART1 {
2190 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
2191 #[doc = r""]
2192 #[doc = r" # Safety"]
2193 #[doc = r""]
2194 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
2195 #[inline]
2196 pub const unsafe fn instance() -> Self {
2197 Instance::new(LPUART1)
2198 }
2199 }
2200 pub type LPUART2 = Instance<2>;
2201 impl crate::private::Sealed for LPUART2 {}
2202 impl crate::Valid for LPUART2 {}
2203 impl LPUART2 {
2204 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
2205 #[doc = r""]
2206 #[doc = r" # Safety"]
2207 #[doc = r""]
2208 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
2209 #[inline]
2210 pub const unsafe fn instance() -> Self {
2211 Instance::new(LPUART2)
2212 }
2213 }
2214 pub type LPUART3 = Instance<3>;
2215 impl crate::private::Sealed for LPUART3 {}
2216 impl crate::Valid for LPUART3 {}
2217 impl LPUART3 {
2218 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
2219 #[doc = r""]
2220 #[doc = r" # Safety"]
2221 #[doc = r""]
2222 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
2223 #[inline]
2224 pub const unsafe fn instance() -> Self {
2225 Instance::new(LPUART3)
2226 }
2227 }
2228 pub type LPUART4 = Instance<4>;
2229 impl crate::private::Sealed for LPUART4 {}
2230 impl crate::Valid for LPUART4 {}
2231 impl LPUART4 {
2232 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
2233 #[doc = r""]
2234 #[doc = r" # Safety"]
2235 #[doc = r""]
2236 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
2237 #[inline]
2238 pub const unsafe fn instance() -> Self {
2239 Instance::new(LPUART4)
2240 }
2241 }
2242 pub type LPUART5 = Instance<5>;
2243 impl crate::private::Sealed for LPUART5 {}
2244 impl crate::Valid for LPUART5 {}
2245 impl LPUART5 {
2246 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
2247 #[doc = r""]
2248 #[doc = r" # Safety"]
2249 #[doc = r""]
2250 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
2251 #[inline]
2252 pub const unsafe fn instance() -> Self {
2253 Instance::new(LPUART5)
2254 }
2255 }
2256 pub type LPUART6 = Instance<6>;
2257 impl crate::private::Sealed for LPUART6 {}
2258 impl crate::Valid for LPUART6 {}
2259 impl LPUART6 {
2260 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
2261 #[doc = r""]
2262 #[doc = r" # Safety"]
2263 #[doc = r""]
2264 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
2265 #[inline]
2266 pub const unsafe fn instance() -> Self {
2267 Instance::new(LPUART6)
2268 }
2269 }
2270 pub type LPUART7 = Instance<7>;
2271 impl crate::private::Sealed for LPUART7 {}
2272 impl crate::Valid for LPUART7 {}
2273 impl LPUART7 {
2274 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
2275 #[doc = r""]
2276 #[doc = r" # Safety"]
2277 #[doc = r""]
2278 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
2279 #[inline]
2280 pub const unsafe fn instance() -> Self {
2281 Instance::new(LPUART7)
2282 }
2283 }
2284 pub type LPUART8 = Instance<8>;
2285 impl crate::private::Sealed for LPUART8 {}
2286 impl crate::Valid for LPUART8 {}
2287 impl LPUART8 {
2288 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
2289 #[doc = r""]
2290 #[doc = r" # Safety"]
2291 #[doc = r""]
2292 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
2293 #[inline]
2294 pub const unsafe fn instance() -> Self {
2295 Instance::new(LPUART8)
2296 }
2297 }
2298 #[doc = r" Returns the instance number `N` for a peripheral instance."]
2299 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
2300 [
2301 (LPUART1, 1),
2302 (LPUART2, 2),
2303 (LPUART3, 3),
2304 (LPUART4, 4),
2305 (LPUART5, 5),
2306 (LPUART6, 6),
2307 (LPUART7, 7),
2308 (LPUART8, 8),
2309 ]
2310 .into_iter()
2311 .find(|(ptr, _)| core::ptr::eq(rb, *ptr))
2312 .map(|(_, inst)| inst)
2313 }
2314}
2315#[path = "."]
2316pub mod ocotp {
2317 #[doc = "OCOTP"]
2318 pub const OCOTP: *const RegisterBlock = 0x401f_4000 as *const RegisterBlock;
2319 #[path = "blocks/imxrt1061/ocotp.rs"]
2320 mod blocks;
2321 pub use blocks::*;
2322 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
2323 pub type OCOTP = Instance<{ crate::SOLE_INSTANCE }>;
2324 impl crate::private::Sealed for OCOTP {}
2325 impl crate::Valid for OCOTP {}
2326 impl OCOTP {
2327 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
2328 #[doc = r""]
2329 #[doc = r" # Safety"]
2330 #[doc = r""]
2331 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
2332 #[inline]
2333 pub const unsafe fn instance() -> Self {
2334 Instance::new(OCOTP)
2335 }
2336 }
2337 #[doc = r" Returns the instance number `N` for a peripheral instance."]
2338 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
2339 core::ptr::eq(rb, OCOTP).then_some(0)
2340 }
2341}
2342#[path = "."]
2343pub mod pgc {
2344 #[doc = "PGC"]
2345 pub const PGC: *const RegisterBlock = 0x400f_4000 as *const RegisterBlock;
2346 #[path = "blocks/imxrt1011/pgc.rs"]
2347 mod blocks;
2348 pub use blocks::*;
2349 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
2350 pub type PGC = Instance<{ crate::SOLE_INSTANCE }>;
2351 impl crate::private::Sealed for PGC {}
2352 impl crate::Valid for PGC {}
2353 impl PGC {
2354 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
2355 #[doc = r""]
2356 #[doc = r" # Safety"]
2357 #[doc = r""]
2358 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
2359 #[inline]
2360 pub const unsafe fn instance() -> Self {
2361 Instance::new(PGC)
2362 }
2363 }
2364 #[doc = r" Returns the instance number `N` for a peripheral instance."]
2365 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
2366 core::ptr::eq(rb, PGC).then_some(0)
2367 }
2368}
2369#[path = "."]
2370pub mod pit {
2371 #[doc = "PIT"]
2372 pub const PIT: *const RegisterBlock = 0x4008_4000 as *const RegisterBlock;
2373 #[path = "blocks/imxrt1011/pit.rs"]
2374 mod blocks;
2375 pub use blocks::*;
2376 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
2377 pub type PIT = Instance<{ crate::SOLE_INSTANCE }>;
2378 impl crate::private::Sealed for PIT {}
2379 impl crate::Valid for PIT {}
2380 impl PIT {
2381 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
2382 #[doc = r""]
2383 #[doc = r" # Safety"]
2384 #[doc = r""]
2385 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
2386 #[inline]
2387 pub const unsafe fn instance() -> Self {
2388 Instance::new(PIT)
2389 }
2390 }
2391 #[doc = r" Returns the instance number `N` for a peripheral instance."]
2392 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
2393 core::ptr::eq(rb, PIT).then_some(0)
2394 }
2395}
2396#[path = "."]
2397pub mod pmu {
2398 #[doc = "PMU"]
2399 pub const PMU: *const RegisterBlock = 0x400d_8000 as *const RegisterBlock;
2400 #[path = "blocks/imxrt1051/pmu.rs"]
2401 mod blocks;
2402 pub use blocks::*;
2403 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
2404 pub type PMU = Instance<{ crate::SOLE_INSTANCE }>;
2405 impl crate::private::Sealed for PMU {}
2406 impl crate::Valid for PMU {}
2407 impl PMU {
2408 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
2409 #[doc = r""]
2410 #[doc = r" # Safety"]
2411 #[doc = r""]
2412 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
2413 #[inline]
2414 pub const unsafe fn instance() -> Self {
2415 Instance::new(PMU)
2416 }
2417 }
2418 #[doc = r" Returns the instance number `N` for a peripheral instance."]
2419 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
2420 core::ptr::eq(rb, PMU).then_some(0)
2421 }
2422}
2423#[path = "."]
2424pub mod pwm {
2425 #[doc = "PWM"]
2426 pub const PWM1: *const RegisterBlock = 0x403d_c000 as *const RegisterBlock;
2427 #[doc = "PWM"]
2428 pub const PWM2: *const RegisterBlock = 0x403e_0000 as *const RegisterBlock;
2429 #[doc = "PWM"]
2430 pub const PWM3: *const RegisterBlock = 0x403e_4000 as *const RegisterBlock;
2431 #[doc = "PWM"]
2432 pub const PWM4: *const RegisterBlock = 0x403e_8000 as *const RegisterBlock;
2433 #[path = "blocks/imxrt1021/pwm.rs"]
2434 mod blocks;
2435 pub use blocks::*;
2436 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
2437 pub type PWM1 = Instance<1>;
2438 impl crate::private::Sealed for PWM1 {}
2439 impl crate::Valid for PWM1 {}
2440 impl PWM1 {
2441 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
2442 #[doc = r""]
2443 #[doc = r" # Safety"]
2444 #[doc = r""]
2445 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
2446 #[inline]
2447 pub const unsafe fn instance() -> Self {
2448 Instance::new(PWM1)
2449 }
2450 }
2451 pub type PWM2 = Instance<2>;
2452 impl crate::private::Sealed for PWM2 {}
2453 impl crate::Valid for PWM2 {}
2454 impl PWM2 {
2455 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
2456 #[doc = r""]
2457 #[doc = r" # Safety"]
2458 #[doc = r""]
2459 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
2460 #[inline]
2461 pub const unsafe fn instance() -> Self {
2462 Instance::new(PWM2)
2463 }
2464 }
2465 pub type PWM3 = Instance<3>;
2466 impl crate::private::Sealed for PWM3 {}
2467 impl crate::Valid for PWM3 {}
2468 impl PWM3 {
2469 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
2470 #[doc = r""]
2471 #[doc = r" # Safety"]
2472 #[doc = r""]
2473 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
2474 #[inline]
2475 pub const unsafe fn instance() -> Self {
2476 Instance::new(PWM3)
2477 }
2478 }
2479 pub type PWM4 = Instance<4>;
2480 impl crate::private::Sealed for PWM4 {}
2481 impl crate::Valid for PWM4 {}
2482 impl PWM4 {
2483 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
2484 #[doc = r""]
2485 #[doc = r" # Safety"]
2486 #[doc = r""]
2487 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
2488 #[inline]
2489 pub const unsafe fn instance() -> Self {
2490 Instance::new(PWM4)
2491 }
2492 }
2493 #[doc = r" Returns the instance number `N` for a peripheral instance."]
2494 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
2495 [(PWM1, 1), (PWM2, 2), (PWM3, 3), (PWM4, 4)]
2496 .into_iter()
2497 .find(|(ptr, _)| core::ptr::eq(rb, *ptr))
2498 .map(|(_, inst)| inst)
2499 }
2500}
2501#[path = "."]
2502pub mod pxp {
2503 #[doc = "PXP v2.0 Register Reference Index"]
2504 pub const PXP: *const RegisterBlock = 0x402b_4000 as *const RegisterBlock;
2505 #[path = "blocks/imxrt1052/pxp.rs"]
2506 mod blocks;
2507 pub use blocks::*;
2508 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
2509 pub type PXP = Instance<{ crate::SOLE_INSTANCE }>;
2510 impl crate::private::Sealed for PXP {}
2511 impl crate::Valid for PXP {}
2512 impl PXP {
2513 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
2514 #[doc = r""]
2515 #[doc = r" # Safety"]
2516 #[doc = r""]
2517 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
2518 #[inline]
2519 pub const unsafe fn instance() -> Self {
2520 Instance::new(PXP)
2521 }
2522 }
2523 #[doc = r" Returns the instance number `N` for a peripheral instance."]
2524 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
2525 core::ptr::eq(rb, PXP).then_some(0)
2526 }
2527}
2528#[path = "."]
2529pub mod romc {
2530 #[doc = "ROMC"]
2531 pub const ROMC: *const RegisterBlock = 0x4018_0000 as *const RegisterBlock;
2532 #[path = "blocks/imxrt1011/romc.rs"]
2533 mod blocks;
2534 pub use blocks::*;
2535 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
2536 pub type ROMC = Instance<{ crate::SOLE_INSTANCE }>;
2537 impl crate::private::Sealed for ROMC {}
2538 impl crate::Valid for ROMC {}
2539 impl ROMC {
2540 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
2541 #[doc = r""]
2542 #[doc = r" # Safety"]
2543 #[doc = r""]
2544 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
2545 #[inline]
2546 pub const unsafe fn instance() -> Self {
2547 Instance::new(ROMC)
2548 }
2549 }
2550 #[doc = r" Returns the instance number `N` for a peripheral instance."]
2551 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
2552 core::ptr::eq(rb, ROMC).then_some(0)
2553 }
2554}
2555#[path = "."]
2556pub mod rtwdog {
2557 #[doc = "WDOG"]
2558 pub const RTWDOG: *const RegisterBlock = 0x400b_c000 as *const RegisterBlock;
2559 #[path = "blocks/imxrt1011/rtwdog.rs"]
2560 mod blocks;
2561 pub use blocks::*;
2562 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
2563 pub type RTWDOG = Instance<{ crate::SOLE_INSTANCE }>;
2564 impl crate::private::Sealed for RTWDOG {}
2565 impl crate::Valid for RTWDOG {}
2566 impl RTWDOG {
2567 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
2568 #[doc = r""]
2569 #[doc = r" # Safety"]
2570 #[doc = r""]
2571 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
2572 #[inline]
2573 pub const unsafe fn instance() -> Self {
2574 Instance::new(RTWDOG)
2575 }
2576 }
2577 #[doc = r" Returns the instance number `N` for a peripheral instance."]
2578 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
2579 core::ptr::eq(rb, RTWDOG).then_some(0)
2580 }
2581}
2582#[path = "."]
2583pub mod sai {
2584 #[doc = "I2S"]
2585 pub const SAI1: *const RegisterBlock = 0x4038_4000 as *const RegisterBlock;
2586 #[doc = "I2S"]
2587 pub const SAI2: *const RegisterBlock = 0x4038_8000 as *const RegisterBlock;
2588 #[doc = "I2S"]
2589 pub const SAI3: *const RegisterBlock = 0x4038_c000 as *const RegisterBlock;
2590 #[path = "blocks/imxrt1015/sai.rs"]
2591 mod blocks;
2592 pub use blocks::*;
2593 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
2594 pub type SAI1 = Instance<1>;
2595 impl crate::private::Sealed for SAI1 {}
2596 impl crate::Valid for SAI1 {}
2597 impl SAI1 {
2598 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
2599 #[doc = r""]
2600 #[doc = r" # Safety"]
2601 #[doc = r""]
2602 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
2603 #[inline]
2604 pub const unsafe fn instance() -> Self {
2605 Instance::new(SAI1)
2606 }
2607 }
2608 pub type SAI2 = Instance<2>;
2609 impl crate::private::Sealed for SAI2 {}
2610 impl crate::Valid for SAI2 {}
2611 impl SAI2 {
2612 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
2613 #[doc = r""]
2614 #[doc = r" # Safety"]
2615 #[doc = r""]
2616 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
2617 #[inline]
2618 pub const unsafe fn instance() -> Self {
2619 Instance::new(SAI2)
2620 }
2621 }
2622 pub type SAI3 = Instance<3>;
2623 impl crate::private::Sealed for SAI3 {}
2624 impl crate::Valid for SAI3 {}
2625 impl SAI3 {
2626 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
2627 #[doc = r""]
2628 #[doc = r" # Safety"]
2629 #[doc = r""]
2630 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
2631 #[inline]
2632 pub const unsafe fn instance() -> Self {
2633 Instance::new(SAI3)
2634 }
2635 }
2636 #[doc = r" Returns the instance number `N` for a peripheral instance."]
2637 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
2638 [(SAI1, 1), (SAI2, 2), (SAI3, 3)]
2639 .into_iter()
2640 .find(|(ptr, _)| core::ptr::eq(rb, *ptr))
2641 .map(|(_, inst)| inst)
2642 }
2643}
2644#[path = "."]
2645pub mod semc {
2646 #[doc = "SEMC"]
2647 pub const SEMC: *const RegisterBlock = 0x402f_0000 as *const RegisterBlock;
2648 #[path = "blocks/imxrt1061/semc.rs"]
2649 mod blocks;
2650 pub use blocks::*;
2651 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
2652 pub type SEMC = Instance<{ crate::SOLE_INSTANCE }>;
2653 impl crate::private::Sealed for SEMC {}
2654 impl crate::Valid for SEMC {}
2655 impl SEMC {
2656 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
2657 #[doc = r""]
2658 #[doc = r" # Safety"]
2659 #[doc = r""]
2660 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
2661 #[inline]
2662 pub const unsafe fn instance() -> Self {
2663 Instance::new(SEMC)
2664 }
2665 }
2666 #[doc = r" Returns the instance number `N` for a peripheral instance."]
2667 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
2668 core::ptr::eq(rb, SEMC).then_some(0)
2669 }
2670}
2671#[path = "."]
2672pub mod snvs {
2673 #[doc = "SNVS"]
2674 pub const SNVS: *const RegisterBlock = 0x400d_4000 as *const RegisterBlock;
2675 #[path = "blocks/imxrt1051/snvs.rs"]
2676 mod blocks;
2677 pub use blocks::*;
2678 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
2679 pub type SNVS = Instance<{ crate::SOLE_INSTANCE }>;
2680 impl crate::private::Sealed for SNVS {}
2681 impl crate::Valid for SNVS {}
2682 impl SNVS {
2683 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
2684 #[doc = r""]
2685 #[doc = r" # Safety"]
2686 #[doc = r""]
2687 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
2688 #[inline]
2689 pub const unsafe fn instance() -> Self {
2690 Instance::new(SNVS)
2691 }
2692 }
2693 #[doc = r" Returns the instance number `N` for a peripheral instance."]
2694 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
2695 core::ptr::eq(rb, SNVS).then_some(0)
2696 }
2697}
2698#[path = "."]
2699pub mod spdif {
2700 #[doc = "SPDIF"]
2701 pub const SPDIF: *const RegisterBlock = 0x4038_0000 as *const RegisterBlock;
2702 #[path = "blocks/imxrt1011/spdif.rs"]
2703 mod blocks;
2704 pub use blocks::*;
2705 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
2706 pub type SPDIF = Instance<{ crate::SOLE_INSTANCE }>;
2707 impl crate::private::Sealed for SPDIF {}
2708 impl crate::Valid for SPDIF {}
2709 impl SPDIF {
2710 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
2711 #[doc = r""]
2712 #[doc = r" # Safety"]
2713 #[doc = r""]
2714 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
2715 #[inline]
2716 pub const unsafe fn instance() -> Self {
2717 Instance::new(SPDIF)
2718 }
2719 }
2720 #[doc = r" Returns the instance number `N` for a peripheral instance."]
2721 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
2722 core::ptr::eq(rb, SPDIF).then_some(0)
2723 }
2724}
2725#[path = "."]
2726pub mod src {
2727 #[doc = "SRC"]
2728 pub const SRC: *const RegisterBlock = 0x400f_8000 as *const RegisterBlock;
2729 #[path = "blocks/imxrt1051/src.rs"]
2730 mod blocks;
2731 pub use blocks::*;
2732 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
2733 pub type SRC = Instance<{ crate::SOLE_INSTANCE }>;
2734 impl crate::private::Sealed for SRC {}
2735 impl crate::Valid for SRC {}
2736 impl SRC {
2737 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
2738 #[doc = r""]
2739 #[doc = r" # Safety"]
2740 #[doc = r""]
2741 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
2742 #[inline]
2743 pub const unsafe fn instance() -> Self {
2744 Instance::new(SRC)
2745 }
2746 }
2747 #[doc = r" Returns the instance number `N` for a peripheral instance."]
2748 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
2749 core::ptr::eq(rb, SRC).then_some(0)
2750 }
2751}
2752#[path = "."]
2753pub mod tempmon {
2754 #[doc = "Temperature Monitor"]
2755 pub const TEMPMON: *const RegisterBlock = 0x400d_8000 as *const RegisterBlock;
2756 #[path = "blocks/imxrt1011/tempmon.rs"]
2757 mod blocks;
2758 pub use blocks::*;
2759 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
2760 pub type TEMPMON = Instance<{ crate::SOLE_INSTANCE }>;
2761 impl crate::private::Sealed for TEMPMON {}
2762 impl crate::Valid for TEMPMON {}
2763 impl TEMPMON {
2764 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
2765 #[doc = r""]
2766 #[doc = r" # Safety"]
2767 #[doc = r""]
2768 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
2769 #[inline]
2770 pub const unsafe fn instance() -> Self {
2771 Instance::new(TEMPMON)
2772 }
2773 }
2774 #[doc = r" Returns the instance number `N` for a peripheral instance."]
2775 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
2776 core::ptr::eq(rb, TEMPMON).then_some(0)
2777 }
2778}
2779#[path = "."]
2780pub mod tmr {
2781 #[doc = "Quad Timer"]
2782 pub const TMR1: *const RegisterBlock = 0x401d_c000 as *const RegisterBlock;
2783 #[doc = "Quad Timer"]
2784 pub const TMR2: *const RegisterBlock = 0x401e_0000 as *const RegisterBlock;
2785 #[doc = "Quad Timer"]
2786 pub const TMR3: *const RegisterBlock = 0x401e_4000 as *const RegisterBlock;
2787 #[doc = "Quad Timer"]
2788 pub const TMR4: *const RegisterBlock = 0x401e_8000 as *const RegisterBlock;
2789 #[path = "blocks/imxrt1021/tmr.rs"]
2790 mod blocks;
2791 pub use blocks::*;
2792 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
2793 pub type TMR1 = Instance<1>;
2794 impl crate::private::Sealed for TMR1 {}
2795 impl crate::Valid for TMR1 {}
2796 impl TMR1 {
2797 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
2798 #[doc = r""]
2799 #[doc = r" # Safety"]
2800 #[doc = r""]
2801 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
2802 #[inline]
2803 pub const unsafe fn instance() -> Self {
2804 Instance::new(TMR1)
2805 }
2806 }
2807 pub type TMR2 = Instance<2>;
2808 impl crate::private::Sealed for TMR2 {}
2809 impl crate::Valid for TMR2 {}
2810 impl TMR2 {
2811 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
2812 #[doc = r""]
2813 #[doc = r" # Safety"]
2814 #[doc = r""]
2815 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
2816 #[inline]
2817 pub const unsafe fn instance() -> Self {
2818 Instance::new(TMR2)
2819 }
2820 }
2821 pub type TMR3 = Instance<3>;
2822 impl crate::private::Sealed for TMR3 {}
2823 impl crate::Valid for TMR3 {}
2824 impl TMR3 {
2825 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
2826 #[doc = r""]
2827 #[doc = r" # Safety"]
2828 #[doc = r""]
2829 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
2830 #[inline]
2831 pub const unsafe fn instance() -> Self {
2832 Instance::new(TMR3)
2833 }
2834 }
2835 pub type TMR4 = Instance<4>;
2836 impl crate::private::Sealed for TMR4 {}
2837 impl crate::Valid for TMR4 {}
2838 impl TMR4 {
2839 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
2840 #[doc = r""]
2841 #[doc = r" # Safety"]
2842 #[doc = r""]
2843 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
2844 #[inline]
2845 pub const unsafe fn instance() -> Self {
2846 Instance::new(TMR4)
2847 }
2848 }
2849 #[doc = r" Returns the instance number `N` for a peripheral instance."]
2850 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
2851 [(TMR1, 1), (TMR2, 2), (TMR3, 3), (TMR4, 4)]
2852 .into_iter()
2853 .find(|(ptr, _)| core::ptr::eq(rb, *ptr))
2854 .map(|(_, inst)| inst)
2855 }
2856}
2857#[path = "."]
2858pub mod trng {
2859 #[doc = "TRNG"]
2860 pub const TRNG: *const RegisterBlock = 0x400c_c000 as *const RegisterBlock;
2861 #[path = "blocks/imxrt1011/trng.rs"]
2862 mod blocks;
2863 pub use blocks::*;
2864 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
2865 pub type TRNG = Instance<{ crate::SOLE_INSTANCE }>;
2866 impl crate::private::Sealed for TRNG {}
2867 impl crate::Valid for TRNG {}
2868 impl TRNG {
2869 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
2870 #[doc = r""]
2871 #[doc = r" # Safety"]
2872 #[doc = r""]
2873 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
2874 #[inline]
2875 pub const unsafe fn instance() -> Self {
2876 Instance::new(TRNG)
2877 }
2878 }
2879 #[doc = r" Returns the instance number `N` for a peripheral instance."]
2880 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
2881 core::ptr::eq(rb, TRNG).then_some(0)
2882 }
2883}
2884#[path = "."]
2885pub mod tsc {
2886 #[doc = "Touch Screen Controller"]
2887 pub const TSC: *const RegisterBlock = 0x400e_0000 as *const RegisterBlock;
2888 #[path = "blocks/imxrt1051/tsc.rs"]
2889 mod blocks;
2890 pub use blocks::*;
2891 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
2892 pub type TSC = Instance<{ crate::SOLE_INSTANCE }>;
2893 impl crate::private::Sealed for TSC {}
2894 impl crate::Valid for TSC {}
2895 impl TSC {
2896 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
2897 #[doc = r""]
2898 #[doc = r" # Safety"]
2899 #[doc = r""]
2900 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
2901 #[inline]
2902 pub const unsafe fn instance() -> Self {
2903 Instance::new(TSC)
2904 }
2905 }
2906 #[doc = r" Returns the instance number `N` for a peripheral instance."]
2907 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
2908 core::ptr::eq(rb, TSC).then_some(0)
2909 }
2910}
2911#[path = "."]
2912pub mod usb {
2913 #[doc = "USB"]
2914 pub const USB1: *const RegisterBlock = 0x402e_0000 as *const RegisterBlock;
2915 #[doc = "USB"]
2916 pub const USB2: *const RegisterBlock = 0x402e_0200 as *const RegisterBlock;
2917 #[path = "blocks/imxrt1011/usb.rs"]
2918 mod blocks;
2919 pub use blocks::*;
2920 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
2921 pub type USB1 = Instance<1>;
2922 impl crate::private::Sealed for USB1 {}
2923 impl crate::Valid for USB1 {}
2924 impl USB1 {
2925 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
2926 #[doc = r""]
2927 #[doc = r" # Safety"]
2928 #[doc = r""]
2929 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
2930 #[inline]
2931 pub const unsafe fn instance() -> Self {
2932 Instance::new(USB1)
2933 }
2934 }
2935 pub type USB2 = Instance<2>;
2936 impl crate::private::Sealed for USB2 {}
2937 impl crate::Valid for USB2 {}
2938 impl USB2 {
2939 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
2940 #[doc = r""]
2941 #[doc = r" # Safety"]
2942 #[doc = r""]
2943 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
2944 #[inline]
2945 pub const unsafe fn instance() -> Self {
2946 Instance::new(USB2)
2947 }
2948 }
2949 #[doc = r" Returns the instance number `N` for a peripheral instance."]
2950 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
2951 [(USB1, 1), (USB2, 2)]
2952 .into_iter()
2953 .find(|(ptr, _)| core::ptr::eq(rb, *ptr))
2954 .map(|(_, inst)| inst)
2955 }
2956}
2957#[path = "."]
2958pub mod usb_analog {
2959 #[doc = "USB Analog"]
2960 pub const USB_ANALOG: *const RegisterBlock = 0x400d_8000 as *const RegisterBlock;
2961 #[path = "blocks/imxrt1061/usb_analog.rs"]
2962 mod blocks;
2963 pub use blocks::*;
2964 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
2965 pub type USB_ANALOG = Instance<{ crate::SOLE_INSTANCE }>;
2966 impl crate::private::Sealed for USB_ANALOG {}
2967 impl crate::Valid for USB_ANALOG {}
2968 impl USB_ANALOG {
2969 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
2970 #[doc = r""]
2971 #[doc = r" # Safety"]
2972 #[doc = r""]
2973 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
2974 #[inline]
2975 pub const unsafe fn instance() -> Self {
2976 Instance::new(USB_ANALOG)
2977 }
2978 }
2979 #[doc = r" Returns the instance number `N` for a peripheral instance."]
2980 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
2981 core::ptr::eq(rb, USB_ANALOG).then_some(0)
2982 }
2983}
2984#[path = "."]
2985pub mod usbnc {
2986 #[doc = "USB"]
2987 pub const USBNC1: *const RegisterBlock = 0x402e_0000 as *const RegisterBlock;
2988 #[doc = "USB"]
2989 pub const USBNC2: *const RegisterBlock = 0x402e_0004 as *const RegisterBlock;
2990 #[path = "blocks/imxrt1051/usbnc.rs"]
2991 mod blocks;
2992 pub use blocks::*;
2993 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
2994 pub type USBNC1 = Instance<1>;
2995 impl crate::private::Sealed for USBNC1 {}
2996 impl crate::Valid for USBNC1 {}
2997 impl USBNC1 {
2998 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
2999 #[doc = r""]
3000 #[doc = r" # Safety"]
3001 #[doc = r""]
3002 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
3003 #[inline]
3004 pub const unsafe fn instance() -> Self {
3005 Instance::new(USBNC1)
3006 }
3007 }
3008 pub type USBNC2 = Instance<2>;
3009 impl crate::private::Sealed for USBNC2 {}
3010 impl crate::Valid for USBNC2 {}
3011 impl USBNC2 {
3012 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
3013 #[doc = r""]
3014 #[doc = r" # Safety"]
3015 #[doc = r""]
3016 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
3017 #[inline]
3018 pub const unsafe fn instance() -> Self {
3019 Instance::new(USBNC2)
3020 }
3021 }
3022 #[doc = r" Returns the instance number `N` for a peripheral instance."]
3023 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
3024 [(USBNC1, 1), (USBNC2, 2)]
3025 .into_iter()
3026 .find(|(ptr, _)| core::ptr::eq(rb, *ptr))
3027 .map(|(_, inst)| inst)
3028 }
3029}
3030#[path = "."]
3031pub mod usbphy {
3032 #[doc = "USBPHY Register Reference Index"]
3033 pub const USBPHY1: *const RegisterBlock = 0x400d_9000 as *const RegisterBlock;
3034 #[doc = "USBPHY Register Reference Index"]
3035 pub const USBPHY2: *const RegisterBlock = 0x400d_a000 as *const RegisterBlock;
3036 #[path = "blocks/imxrt1051/usbphy.rs"]
3037 mod blocks;
3038 pub use blocks::*;
3039 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
3040 pub type USBPHY1 = Instance<1>;
3041 impl crate::private::Sealed for USBPHY1 {}
3042 impl crate::Valid for USBPHY1 {}
3043 impl USBPHY1 {
3044 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
3045 #[doc = r""]
3046 #[doc = r" # Safety"]
3047 #[doc = r""]
3048 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
3049 #[inline]
3050 pub const unsafe fn instance() -> Self {
3051 Instance::new(USBPHY1)
3052 }
3053 }
3054 pub type USBPHY2 = Instance<2>;
3055 impl crate::private::Sealed for USBPHY2 {}
3056 impl crate::Valid for USBPHY2 {}
3057 impl USBPHY2 {
3058 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
3059 #[doc = r""]
3060 #[doc = r" # Safety"]
3061 #[doc = r""]
3062 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
3063 #[inline]
3064 pub const unsafe fn instance() -> Self {
3065 Instance::new(USBPHY2)
3066 }
3067 }
3068 #[doc = r" Returns the instance number `N` for a peripheral instance."]
3069 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
3070 [(USBPHY1, 1), (USBPHY2, 2)]
3071 .into_iter()
3072 .find(|(ptr, _)| core::ptr::eq(rb, *ptr))
3073 .map(|(_, inst)| inst)
3074 }
3075}
3076#[path = "."]
3077pub mod usdhc {
3078 #[doc = "uSDHC"]
3079 pub const USDHC1: *const RegisterBlock = 0x402c_0000 as *const RegisterBlock;
3080 #[doc = "uSDHC"]
3081 pub const USDHC2: *const RegisterBlock = 0x402c_4000 as *const RegisterBlock;
3082 #[path = "blocks/imxrt1021/usdhc.rs"]
3083 mod blocks;
3084 pub use blocks::*;
3085 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
3086 pub type USDHC1 = Instance<1>;
3087 impl crate::private::Sealed for USDHC1 {}
3088 impl crate::Valid for USDHC1 {}
3089 impl USDHC1 {
3090 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
3091 #[doc = r""]
3092 #[doc = r" # Safety"]
3093 #[doc = r""]
3094 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
3095 #[inline]
3096 pub const unsafe fn instance() -> Self {
3097 Instance::new(USDHC1)
3098 }
3099 }
3100 pub type USDHC2 = Instance<2>;
3101 impl crate::private::Sealed for USDHC2 {}
3102 impl crate::Valid for USDHC2 {}
3103 impl USDHC2 {
3104 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
3105 #[doc = r""]
3106 #[doc = r" # Safety"]
3107 #[doc = r""]
3108 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
3109 #[inline]
3110 pub const unsafe fn instance() -> Self {
3111 Instance::new(USDHC2)
3112 }
3113 }
3114 #[doc = r" Returns the instance number `N` for a peripheral instance."]
3115 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
3116 [(USDHC1, 1), (USDHC2, 2)]
3117 .into_iter()
3118 .find(|(ptr, _)| core::ptr::eq(rb, *ptr))
3119 .map(|(_, inst)| inst)
3120 }
3121}
3122#[path = "."]
3123pub mod wdog {
3124 #[doc = "WDOG"]
3125 pub const WDOG1: *const RegisterBlock = 0x400b_8000 as *const RegisterBlock;
3126 #[doc = "WDOG"]
3127 pub const WDOG2: *const RegisterBlock = 0x400d_0000 as *const RegisterBlock;
3128 #[path = "blocks/imxrt1011/wdog.rs"]
3129 mod blocks;
3130 pub use blocks::*;
3131 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
3132 pub type WDOG1 = Instance<1>;
3133 impl crate::private::Sealed for WDOG1 {}
3134 impl crate::Valid for WDOG1 {}
3135 impl WDOG1 {
3136 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
3137 #[doc = r""]
3138 #[doc = r" # Safety"]
3139 #[doc = r""]
3140 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
3141 #[inline]
3142 pub const unsafe fn instance() -> Self {
3143 Instance::new(WDOG1)
3144 }
3145 }
3146 pub type WDOG2 = Instance<2>;
3147 impl crate::private::Sealed for WDOG2 {}
3148 impl crate::Valid for WDOG2 {}
3149 impl WDOG2 {
3150 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
3151 #[doc = r""]
3152 #[doc = r" # Safety"]
3153 #[doc = r""]
3154 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
3155 #[inline]
3156 pub const unsafe fn instance() -> Self {
3157 Instance::new(WDOG2)
3158 }
3159 }
3160 #[doc = r" Returns the instance number `N` for a peripheral instance."]
3161 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
3162 [(WDOG1, 1), (WDOG2, 2)]
3163 .into_iter()
3164 .find(|(ptr, _)| core::ptr::eq(rb, *ptr))
3165 .map(|(_, inst)| inst)
3166 }
3167}
3168#[path = "."]
3169pub mod xbara1 {
3170 #[doc = "Crossbar Switch"]
3171 pub const XBARA1: *const RegisterBlock = 0x403b_c000 as *const RegisterBlock;
3172 #[path = "blocks/imxrt1051/xbara1.rs"]
3173 mod blocks;
3174 pub use blocks::*;
3175 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
3176 pub type XBARA1 = Instance<{ crate::SOLE_INSTANCE }>;
3177 impl crate::private::Sealed for XBARA1 {}
3178 impl crate::Valid for XBARA1 {}
3179 impl XBARA1 {
3180 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
3181 #[doc = r""]
3182 #[doc = r" # Safety"]
3183 #[doc = r""]
3184 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
3185 #[inline]
3186 pub const unsafe fn instance() -> Self {
3187 Instance::new(XBARA1)
3188 }
3189 }
3190 #[doc = r" Returns the instance number `N` for a peripheral instance."]
3191 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
3192 core::ptr::eq(rb, XBARA1).then_some(0)
3193 }
3194}
3195#[path = "."]
3196pub mod xbarb {
3197 #[doc = "Crossbar Switch"]
3198 pub const XBARB2: *const RegisterBlock = 0x403c_0000 as *const RegisterBlock;
3199 #[doc = "Crossbar Switch"]
3200 pub const XBARB3: *const RegisterBlock = 0x403c_4000 as *const RegisterBlock;
3201 #[path = "blocks/imxrt1051/xbarb.rs"]
3202 mod blocks;
3203 pub use blocks::*;
3204 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
3205 pub type XBARB2 = Instance<2>;
3206 impl crate::private::Sealed for XBARB2 {}
3207 impl crate::Valid for XBARB2 {}
3208 impl XBARB2 {
3209 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
3210 #[doc = r""]
3211 #[doc = r" # Safety"]
3212 #[doc = r""]
3213 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
3214 #[inline]
3215 pub const unsafe fn instance() -> Self {
3216 Instance::new(XBARB2)
3217 }
3218 }
3219 pub type XBARB3 = Instance<3>;
3220 impl crate::private::Sealed for XBARB3 {}
3221 impl crate::Valid for XBARB3 {}
3222 impl XBARB3 {
3223 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
3224 #[doc = r""]
3225 #[doc = r" # Safety"]
3226 #[doc = r""]
3227 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
3228 #[inline]
3229 pub const unsafe fn instance() -> Self {
3230 Instance::new(XBARB3)
3231 }
3232 }
3233 #[doc = r" Returns the instance number `N` for a peripheral instance."]
3234 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
3235 [(XBARB2, 2), (XBARB3, 3)]
3236 .into_iter()
3237 .find(|(ptr, _)| core::ptr::eq(rb, *ptr))
3238 .map(|(_, inst)| inst)
3239 }
3240}
3241#[path = "."]
3242pub mod xtalosc24m {
3243 #[doc = "XTALOSC24M"]
3244 pub const XTALOSC24M: *const RegisterBlock = 0x400d_8000 as *const RegisterBlock;
3245 #[path = "blocks/imxrt1011/xtalosc24m.rs"]
3246 mod blocks;
3247 pub use blocks::*;
3248 pub type Instance<const N: u8> = crate::Instance<RegisterBlock, N>;
3249 pub type XTALOSC24M = Instance<{ crate::SOLE_INSTANCE }>;
3250 impl crate::private::Sealed for XTALOSC24M {}
3251 impl crate::Valid for XTALOSC24M {}
3252 impl XTALOSC24M {
3253 #[doc = r" Acquire a vaild, but possibly aliased, instance."]
3254 #[doc = r""]
3255 #[doc = r" # Safety"]
3256 #[doc = r""]
3257 #[doc = r" See [the struct-level safety documentation](crate::Instance)."]
3258 #[inline]
3259 pub const unsafe fn instance() -> Self {
3260 Instance::new(XTALOSC24M)
3261 }
3262 }
3263 #[doc = r" Returns the instance number `N` for a peripheral instance."]
3264 pub fn number(rb: *const RegisterBlock) -> Option<u8> {
3265 core::ptr::eq(rb, XTALOSC24M).then_some(0)
3266 }
3267}
3268#[doc = r"Number available in the NVIC for configuring priority"]
3269pub const NVIC_PRIO_BITS: u8 = 4;
3270#[doc = r" Instances for all of this device's peripherals."]
3271#[doc = r""]
3272#[doc = r" Use this if you want a single way to acquire *all* instances"]
3273#[doc = r" for your device."]
3274pub struct Instances {
3275 pub ADC1: adc::ADC1,
3276 pub ADC2: adc::ADC2,
3277 pub ADC_ETC: adc_etc::ADC_ETC,
3278 pub AIPSTZ1: aipstz::AIPSTZ1,
3279 pub AIPSTZ2: aipstz::AIPSTZ2,
3280 pub AIPSTZ3: aipstz::AIPSTZ3,
3281 pub AIPSTZ4: aipstz::AIPSTZ4,
3282 pub AOI1: aoi::AOI1,
3283 pub AOI2: aoi::AOI2,
3284 pub BEE: bee::BEE,
3285 pub CAN1: can::CAN1,
3286 pub CAN2: can::CAN2,
3287 pub CAN3: can3::CAN3,
3288 pub CCM: ccm::CCM,
3289 pub CCM_ANALOG: ccm_analog::CCM_ANALOG,
3290 pub CMP1: cmp::CMP1,
3291 pub CMP2: cmp::CMP2,
3292 pub CMP3: cmp::CMP3,
3293 pub CMP4: cmp::CMP4,
3294 pub CSI: csi::CSI,
3295 pub CSU: csu::CSU,
3296 pub DCDC: dcdc::DCDC,
3297 pub DCP: dcp::DCP,
3298 pub DMA: dma::DMA,
3299 pub DMAMUX: dmamux::DMAMUX,
3300 pub ENC1: enc::ENC1,
3301 pub ENC2: enc::ENC2,
3302 pub ENC3: enc::ENC3,
3303 pub ENC4: enc::ENC4,
3304 pub ENET1: enet::ENET1,
3305 pub ENET2: enet::ENET2,
3306 pub EWM: ewm::EWM,
3307 pub FLEXIO1: flexio::FLEXIO1,
3308 pub FLEXIO2: flexio::FLEXIO2,
3309 pub FLEXIO3: flexio::FLEXIO3,
3310 pub FLEXRAM: flexram::FLEXRAM,
3311 pub FLEXSPI1: flexspi::FLEXSPI1,
3312 pub FLEXSPI2: flexspi::FLEXSPI2,
3313 pub GPC: gpc::GPC,
3314 pub GPIO1: gpio::GPIO1,
3315 pub GPIO5: gpio::GPIO5,
3316 pub GPIO2: gpio::GPIO2,
3317 pub GPIO3: gpio::GPIO3,
3318 pub GPIO4: gpio::GPIO4,
3319 pub GPIO6: gpio::GPIO6,
3320 pub GPIO7: gpio::GPIO7,
3321 pub GPIO8: gpio::GPIO8,
3322 pub GPIO9: gpio::GPIO9,
3323 pub GPT1: gpt::GPT1,
3324 pub GPT2: gpt::GPT2,
3325 pub IOMUXC: iomuxc::IOMUXC,
3326 pub IOMUXC_GPR: iomuxc_gpr::IOMUXC_GPR,
3327 pub IOMUXC_SNVS: iomuxc_snvs::IOMUXC_SNVS,
3328 pub IOMUXC_SNVS_GPR: iomuxc_snvs_gpr::IOMUXC_SNVS_GPR,
3329 pub KPP: kpp::KPP,
3330 pub LCDIF: lcdif::LCDIF,
3331 pub LPI2C1: lpi2c::LPI2C1,
3332 pub LPI2C2: lpi2c::LPI2C2,
3333 pub LPI2C3: lpi2c::LPI2C3,
3334 pub LPI2C4: lpi2c::LPI2C4,
3335 pub LPSPI1: lpspi::LPSPI1,
3336 pub LPSPI2: lpspi::LPSPI2,
3337 pub LPSPI3: lpspi::LPSPI3,
3338 pub LPSPI4: lpspi::LPSPI4,
3339 pub LPUART1: lpuart::LPUART1,
3340 pub LPUART2: lpuart::LPUART2,
3341 pub LPUART3: lpuart::LPUART3,
3342 pub LPUART4: lpuart::LPUART4,
3343 pub LPUART5: lpuart::LPUART5,
3344 pub LPUART6: lpuart::LPUART6,
3345 pub LPUART7: lpuart::LPUART7,
3346 pub LPUART8: lpuart::LPUART8,
3347 pub OCOTP: ocotp::OCOTP,
3348 pub PGC: pgc::PGC,
3349 pub PIT: pit::PIT,
3350 pub PMU: pmu::PMU,
3351 pub PWM1: pwm::PWM1,
3352 pub PWM2: pwm::PWM2,
3353 pub PWM3: pwm::PWM3,
3354 pub PWM4: pwm::PWM4,
3355 pub PXP: pxp::PXP,
3356 pub ROMC: romc::ROMC,
3357 pub RTWDOG: rtwdog::RTWDOG,
3358 pub SAI1: sai::SAI1,
3359 pub SAI2: sai::SAI2,
3360 pub SAI3: sai::SAI3,
3361 pub SEMC: semc::SEMC,
3362 pub SNVS: snvs::SNVS,
3363 pub SPDIF: spdif::SPDIF,
3364 pub SRC: src::SRC,
3365 pub TEMPMON: tempmon::TEMPMON,
3366 pub TMR1: tmr::TMR1,
3367 pub TMR2: tmr::TMR2,
3368 pub TMR3: tmr::TMR3,
3369 pub TMR4: tmr::TMR4,
3370 pub TRNG: trng::TRNG,
3371 pub TSC: tsc::TSC,
3372 pub USB1: usb::USB1,
3373 pub USB2: usb::USB2,
3374 pub USB_ANALOG: usb_analog::USB_ANALOG,
3375 pub USBNC1: usbnc::USBNC1,
3376 pub USBNC2: usbnc::USBNC2,
3377 pub USBPHY1: usbphy::USBPHY1,
3378 pub USBPHY2: usbphy::USBPHY2,
3379 pub USDHC1: usdhc::USDHC1,
3380 pub USDHC2: usdhc::USDHC2,
3381 pub WDOG1: wdog::WDOG1,
3382 pub WDOG2: wdog::WDOG2,
3383 pub XBARA1: xbara1::XBARA1,
3384 pub XBARB2: xbarb::XBARB2,
3385 pub XBARB3: xbarb::XBARB3,
3386 pub XTALOSC24M: xtalosc24m::XTALOSC24M,
3387}
3388impl Instances {
3389 #[doc = r" Acquire all peripheral instances."]
3390 #[doc = r""]
3391 #[doc = r" # Safety"]
3392 #[doc = r""]
3393 #[doc = r" Since this calls `instance()` to initialize each of its members,"]
3394 #[doc = r" the `instance()` safety contract applies. See [the `Instance` safety"]
3395 #[doc = r" documentation](crate::Instance) for more information."]
3396 #[inline]
3397 pub const unsafe fn instances() -> Self {
3398 Self {
3399 ADC1: adc::ADC1::instance(),
3400 ADC2: adc::ADC2::instance(),
3401 ADC_ETC: adc_etc::ADC_ETC::instance(),
3402 AIPSTZ1: aipstz::AIPSTZ1::instance(),
3403 AIPSTZ2: aipstz::AIPSTZ2::instance(),
3404 AIPSTZ3: aipstz::AIPSTZ3::instance(),
3405 AIPSTZ4: aipstz::AIPSTZ4::instance(),
3406 AOI1: aoi::AOI1::instance(),
3407 AOI2: aoi::AOI2::instance(),
3408 BEE: bee::BEE::instance(),
3409 CAN1: can::CAN1::instance(),
3410 CAN2: can::CAN2::instance(),
3411 CAN3: can3::CAN3::instance(),
3412 CCM: ccm::CCM::instance(),
3413 CCM_ANALOG: ccm_analog::CCM_ANALOG::instance(),
3414 CMP1: cmp::CMP1::instance(),
3415 CMP2: cmp::CMP2::instance(),
3416 CMP3: cmp::CMP3::instance(),
3417 CMP4: cmp::CMP4::instance(),
3418 CSI: csi::CSI::instance(),
3419 CSU: csu::CSU::instance(),
3420 DCDC: dcdc::DCDC::instance(),
3421 DCP: dcp::DCP::instance(),
3422 DMA: dma::DMA::instance(),
3423 DMAMUX: dmamux::DMAMUX::instance(),
3424 ENC1: enc::ENC1::instance(),
3425 ENC2: enc::ENC2::instance(),
3426 ENC3: enc::ENC3::instance(),
3427 ENC4: enc::ENC4::instance(),
3428 ENET1: enet::ENET1::instance(),
3429 ENET2: enet::ENET2::instance(),
3430 EWM: ewm::EWM::instance(),
3431 FLEXIO1: flexio::FLEXIO1::instance(),
3432 FLEXIO2: flexio::FLEXIO2::instance(),
3433 FLEXIO3: flexio::FLEXIO3::instance(),
3434 FLEXRAM: flexram::FLEXRAM::instance(),
3435 FLEXSPI1: flexspi::FLEXSPI1::instance(),
3436 FLEXSPI2: flexspi::FLEXSPI2::instance(),
3437 GPC: gpc::GPC::instance(),
3438 GPIO1: gpio::GPIO1::instance(),
3439 GPIO5: gpio::GPIO5::instance(),
3440 GPIO2: gpio::GPIO2::instance(),
3441 GPIO3: gpio::GPIO3::instance(),
3442 GPIO4: gpio::GPIO4::instance(),
3443 GPIO6: gpio::GPIO6::instance(),
3444 GPIO7: gpio::GPIO7::instance(),
3445 GPIO8: gpio::GPIO8::instance(),
3446 GPIO9: gpio::GPIO9::instance(),
3447 GPT1: gpt::GPT1::instance(),
3448 GPT2: gpt::GPT2::instance(),
3449 IOMUXC: iomuxc::IOMUXC::instance(),
3450 IOMUXC_GPR: iomuxc_gpr::IOMUXC_GPR::instance(),
3451 IOMUXC_SNVS: iomuxc_snvs::IOMUXC_SNVS::instance(),
3452 IOMUXC_SNVS_GPR: iomuxc_snvs_gpr::IOMUXC_SNVS_GPR::instance(),
3453 KPP: kpp::KPP::instance(),
3454 LCDIF: lcdif::LCDIF::instance(),
3455 LPI2C1: lpi2c::LPI2C1::instance(),
3456 LPI2C2: lpi2c::LPI2C2::instance(),
3457 LPI2C3: lpi2c::LPI2C3::instance(),
3458 LPI2C4: lpi2c::LPI2C4::instance(),
3459 LPSPI1: lpspi::LPSPI1::instance(),
3460 LPSPI2: lpspi::LPSPI2::instance(),
3461 LPSPI3: lpspi::LPSPI3::instance(),
3462 LPSPI4: lpspi::LPSPI4::instance(),
3463 LPUART1: lpuart::LPUART1::instance(),
3464 LPUART2: lpuart::LPUART2::instance(),
3465 LPUART3: lpuart::LPUART3::instance(),
3466 LPUART4: lpuart::LPUART4::instance(),
3467 LPUART5: lpuart::LPUART5::instance(),
3468 LPUART6: lpuart::LPUART6::instance(),
3469 LPUART7: lpuart::LPUART7::instance(),
3470 LPUART8: lpuart::LPUART8::instance(),
3471 OCOTP: ocotp::OCOTP::instance(),
3472 PGC: pgc::PGC::instance(),
3473 PIT: pit::PIT::instance(),
3474 PMU: pmu::PMU::instance(),
3475 PWM1: pwm::PWM1::instance(),
3476 PWM2: pwm::PWM2::instance(),
3477 PWM3: pwm::PWM3::instance(),
3478 PWM4: pwm::PWM4::instance(),
3479 PXP: pxp::PXP::instance(),
3480 ROMC: romc::ROMC::instance(),
3481 RTWDOG: rtwdog::RTWDOG::instance(),
3482 SAI1: sai::SAI1::instance(),
3483 SAI2: sai::SAI2::instance(),
3484 SAI3: sai::SAI3::instance(),
3485 SEMC: semc::SEMC::instance(),
3486 SNVS: snvs::SNVS::instance(),
3487 SPDIF: spdif::SPDIF::instance(),
3488 SRC: src::SRC::instance(),
3489 TEMPMON: tempmon::TEMPMON::instance(),
3490 TMR1: tmr::TMR1::instance(),
3491 TMR2: tmr::TMR2::instance(),
3492 TMR3: tmr::TMR3::instance(),
3493 TMR4: tmr::TMR4::instance(),
3494 TRNG: trng::TRNG::instance(),
3495 TSC: tsc::TSC::instance(),
3496 USB1: usb::USB1::instance(),
3497 USB2: usb::USB2::instance(),
3498 USB_ANALOG: usb_analog::USB_ANALOG::instance(),
3499 USBNC1: usbnc::USBNC1::instance(),
3500 USBNC2: usbnc::USBNC2::instance(),
3501 USBPHY1: usbphy::USBPHY1::instance(),
3502 USBPHY2: usbphy::USBPHY2::instance(),
3503 USDHC1: usdhc::USDHC1::instance(),
3504 USDHC2: usdhc::USDHC2::instance(),
3505 WDOG1: wdog::WDOG1::instance(),
3506 WDOG2: wdog::WDOG2::instance(),
3507 XBARA1: xbara1::XBARA1::instance(),
3508 XBARB2: xbarb::XBARB2::instance(),
3509 XBARB3: xbarb::XBARB3::instance(),
3510 XTALOSC24M: xtalosc24m::XTALOSC24M::instance(),
3511 }
3512 }
3513}