imxrt_ral/
imxrt1062.rs

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}