1#![doc = "Peripheral access API for MCXN947_CM33_CORE0 microcontrollers (generated using svd2rust v0.31.5 ( ))\n\nYou can find an overview of the generated API [here].\n\nAPI features to be included in the [next]
2svd2rust release can be generated by cloning the svd2rust [repository], checking out the above commit, and running `cargo doc --open`.\n\n[here]: https://docs.rs/svd2rust/0.31.5/svd2rust/#peripheral-api\n[next]: https://github.com/rust-embedded/svd2rust/blob/master/CHANGELOG.md#unreleased\n[repository]: https://github.com/rust-embedded/svd2rust"]
3#![allow(non_camel_case_types)]
4#![allow(non_snake_case)]
5#![no_std]
6use core::marker::PhantomData;
7use core::ops::Deref;
8#[doc = r"Number available in the NVIC for configuring priority"]
9pub const NVIC_PRIO_BITS: u8 = 3;
10#[cfg(feature = "rt")]
11pub use self::Interrupt as interrupt;
12pub use cortex_m::peripheral::Peripherals as CorePeripherals;
13pub use cortex_m::peripheral::{CBP, CPUID, DCB, DWT, FPB, FPU, ITM, MPU, NVIC, SCB, SYST, TPIU};
14#[cfg(feature = "rt")]
15pub use cortex_m_rt::interrupt;
16#[allow(unused_imports)]
17use generic::*;
18#[doc = r"Common register and bit access and modify traits"]
19pub mod generic;
20#[cfg(feature = "rt")]
21extern "C" {
22 fn EDMA_0_CH0();
23 fn EDMA_0_CH1();
24 fn EDMA_0_CH2();
25 fn EDMA_0_CH3();
26 fn EDMA_0_CH4();
27 fn EDMA_0_CH5();
28 fn EDMA_0_CH6();
29 fn EDMA_0_CH7();
30 fn EDMA_0_CH8();
31 fn EDMA_0_CH9();
32 fn EDMA_0_CH10();
33 fn EDMA_0_CH11();
34 fn EDMA_0_CH12();
35 fn EDMA_0_CH13();
36 fn EDMA_0_CH14();
37 fn EDMA_0_CH15();
38 fn GPIO00();
39 fn GPIO01();
40 fn GPIO10();
41 fn GPIO11();
42 fn GPIO20();
43 fn GPIO21();
44 fn GPIO30();
45 fn GPIO31();
46 fn GPIO40();
47 fn GPIO41();
48 fn GPIO50();
49 fn GPIO51();
50 fn UTICK0();
51 fn MRT0();
52 fn CTIMER0();
53 fn CTIMER1();
54 fn SCT0();
55 fn CTIMER2();
56 fn LP_FLEXCOMM0();
57 fn LP_FLEXCOMM1();
58 fn LP_FLEXCOMM2();
59 fn LP_FLEXCOMM3();
60 fn LP_FLEXCOMM4();
61 fn LP_FLEXCOMM5();
62 fn LP_FLEXCOMM6();
63 fn LP_FLEXCOMM7();
64 fn LP_FLEXCOMM8();
65 fn LP_FLEXCOMM9();
66 fn ADC0();
67 fn ADC1();
68 fn PINT0();
69 fn PDM_EVENT();
70 fn USB0_FS();
71 fn USB0_DCD();
72 fn RTC();
73 fn SMARTDMA();
74 fn MAILBOX();
75 fn CTIMER3();
76 fn CTIMER4();
77 fn OS_EVENT();
78 fn FLEXSPI0();
79 fn SAI0();
80 fn SAI1();
81 fn USDHC0();
82 fn CAN0();
83 fn CAN1();
84 fn USB1_HS_PHY();
85 fn USB1_HS();
86 fn SEC_HYPERVISOR_CALL();
87 fn PLU();
88 fn FREQME();
89 fn SEC_VIO();
90 fn ELS();
91 fn PKC();
92 fn PUF();
93 fn PQ();
94 fn EDMA_1_CH0();
95 fn EDMA_1_CH1();
96 fn EDMA_1_CH2();
97 fn EDMA_1_CH3();
98 fn EDMA_1_CH4();
99 fn EDMA_1_CH5();
100 fn EDMA_1_CH6();
101 fn EDMA_1_CH7();
102 fn EDMA_1_CH8();
103 fn EDMA_1_CH9();
104 fn EDMA_1_CH10();
105 fn EDMA_1_CH11();
106 fn EDMA_1_CH12();
107 fn EDMA_1_CH13();
108 fn EDMA_1_CH14();
109 fn EDMA_1_CH15();
110 fn CDOG0();
111 fn CDOG1();
112 fn I3C0();
113 fn I3C1();
114 fn GDET();
115 fn VBAT0();
116 fn EWM0();
117 fn TSI_END_OF_SCAN();
118 fn TSI_OUT_OF_SCAN();
119 fn EMVSIM0();
120 fn EMVSIM1();
121 fn FLEXIO();
122 fn DAC0();
123 fn DAC1();
124 fn DAC2();
125 fn HSCMP0();
126 fn HSCMP1();
127 fn HSCMP2();
128 fn FLEXPWM0_RELOAD_ERROR();
129 fn FLEXPWM0_FAULT();
130 fn FLEXPWM0_SUBMODULE0();
131 fn FLEXPWM0_SUBMODULE1();
132 fn FLEXPWM0_SUBMODULE2();
133 fn FLEXPWM0_SUBMODULE3();
134 fn FLEXPWM1_RELOAD_ERROR();
135 fn FLEXPWM1_FAULT();
136 fn FLEXPWM1_SUBMODULE0();
137 fn FLEXPWM1_SUBMODULE1();
138 fn FLEXPWM1_SUBMODULE2();
139 fn FLEXPWM1_SUBMODULE3();
140 fn ENC0_COMPARE();
141 fn ENC0_HOME();
142 fn ENC0_WDG_SAB();
143 fn ENC0_IDX();
144 fn ENC1_COMPARE();
145 fn ENC1_HOME();
146 fn ENC1_WDG_SAB();
147 fn ENC1_IDX();
148 fn ITRC0();
149 fn BSP32();
150 fn ELS_ERR();
151 fn PKC_ERR();
152 fn ERM_SINGLE_BIT_ERROR();
153 fn ERM_MULTI_BIT_ERROR();
154 fn FMU0();
155 fn ETHERNET();
156 fn ETHERNET_PMT();
157 fn ETHERNET_MACLP();
158 fn SINC_FILTER();
159 fn LPTMR0();
160 fn LPTMR1();
161 fn SCG();
162 fn SPC();
163 fn WUU();
164 fn PORT_EFT();
165 fn ETB0();
166 fn SM3();
167 fn TRNG0();
168 fn WWDT0();
169 fn WWDT1();
170 fn CMC0();
171 fn CTI0();
172}
173#[doc(hidden)]
174#[repr(C)]
175pub union Vector {
176 _handler: unsafe extern "C" fn(),
177 _reserved: u32,
178}
179#[cfg(feature = "rt")]
180#[doc(hidden)]
181#[link_section = ".vector_table.interrupts"]
182#[no_mangle]
183pub static __INTERRUPTS: [Vector; 156] = [
184 Vector { _reserved: 0 },
185 Vector {
186 _handler: EDMA_0_CH0,
187 },
188 Vector {
189 _handler: EDMA_0_CH1,
190 },
191 Vector {
192 _handler: EDMA_0_CH2,
193 },
194 Vector {
195 _handler: EDMA_0_CH3,
196 },
197 Vector {
198 _handler: EDMA_0_CH4,
199 },
200 Vector {
201 _handler: EDMA_0_CH5,
202 },
203 Vector {
204 _handler: EDMA_0_CH6,
205 },
206 Vector {
207 _handler: EDMA_0_CH7,
208 },
209 Vector {
210 _handler: EDMA_0_CH8,
211 },
212 Vector {
213 _handler: EDMA_0_CH9,
214 },
215 Vector {
216 _handler: EDMA_0_CH10,
217 },
218 Vector {
219 _handler: EDMA_0_CH11,
220 },
221 Vector {
222 _handler: EDMA_0_CH12,
223 },
224 Vector {
225 _handler: EDMA_0_CH13,
226 },
227 Vector {
228 _handler: EDMA_0_CH14,
229 },
230 Vector {
231 _handler: EDMA_0_CH15,
232 },
233 Vector { _handler: GPIO00 },
234 Vector { _handler: GPIO01 },
235 Vector { _handler: GPIO10 },
236 Vector { _handler: GPIO11 },
237 Vector { _handler: GPIO20 },
238 Vector { _handler: GPIO21 },
239 Vector { _handler: GPIO30 },
240 Vector { _handler: GPIO31 },
241 Vector { _handler: GPIO40 },
242 Vector { _handler: GPIO41 },
243 Vector { _handler: GPIO50 },
244 Vector { _handler: GPIO51 },
245 Vector { _handler: UTICK0 },
246 Vector { _handler: MRT0 },
247 Vector { _handler: CTIMER0 },
248 Vector { _handler: CTIMER1 },
249 Vector { _handler: SCT0 },
250 Vector { _handler: CTIMER2 },
251 Vector {
252 _handler: LP_FLEXCOMM0,
253 },
254 Vector {
255 _handler: LP_FLEXCOMM1,
256 },
257 Vector {
258 _handler: LP_FLEXCOMM2,
259 },
260 Vector {
261 _handler: LP_FLEXCOMM3,
262 },
263 Vector {
264 _handler: LP_FLEXCOMM4,
265 },
266 Vector {
267 _handler: LP_FLEXCOMM5,
268 },
269 Vector {
270 _handler: LP_FLEXCOMM6,
271 },
272 Vector {
273 _handler: LP_FLEXCOMM7,
274 },
275 Vector {
276 _handler: LP_FLEXCOMM8,
277 },
278 Vector {
279 _handler: LP_FLEXCOMM9,
280 },
281 Vector { _handler: ADC0 },
282 Vector { _handler: ADC1 },
283 Vector { _handler: PINT0 },
284 Vector {
285 _handler: PDM_EVENT,
286 },
287 Vector { _reserved: 0 },
288 Vector { _handler: USB0_FS },
289 Vector { _handler: USB0_DCD },
290 Vector { _handler: RTC },
291 Vector { _handler: SMARTDMA },
292 Vector { _handler: MAILBOX },
293 Vector { _handler: CTIMER3 },
294 Vector { _handler: CTIMER4 },
295 Vector { _handler: OS_EVENT },
296 Vector { _handler: FLEXSPI0 },
297 Vector { _handler: SAI0 },
298 Vector { _handler: SAI1 },
299 Vector { _handler: USDHC0 },
300 Vector { _handler: CAN0 },
301 Vector { _handler: CAN1 },
302 Vector { _reserved: 0 },
303 Vector { _reserved: 0 },
304 Vector {
305 _handler: USB1_HS_PHY,
306 },
307 Vector { _handler: USB1_HS },
308 Vector {
309 _handler: SEC_HYPERVISOR_CALL,
310 },
311 Vector { _reserved: 0 },
312 Vector { _handler: PLU },
313 Vector { _handler: FREQME },
314 Vector { _handler: SEC_VIO },
315 Vector { _handler: ELS },
316 Vector { _handler: PKC },
317 Vector { _handler: PUF },
318 Vector { _handler: PQ },
319 Vector {
320 _handler: EDMA_1_CH0,
321 },
322 Vector {
323 _handler: EDMA_1_CH1,
324 },
325 Vector {
326 _handler: EDMA_1_CH2,
327 },
328 Vector {
329 _handler: EDMA_1_CH3,
330 },
331 Vector {
332 _handler: EDMA_1_CH4,
333 },
334 Vector {
335 _handler: EDMA_1_CH5,
336 },
337 Vector {
338 _handler: EDMA_1_CH6,
339 },
340 Vector {
341 _handler: EDMA_1_CH7,
342 },
343 Vector {
344 _handler: EDMA_1_CH8,
345 },
346 Vector {
347 _handler: EDMA_1_CH9,
348 },
349 Vector {
350 _handler: EDMA_1_CH10,
351 },
352 Vector {
353 _handler: EDMA_1_CH11,
354 },
355 Vector {
356 _handler: EDMA_1_CH12,
357 },
358 Vector {
359 _handler: EDMA_1_CH13,
360 },
361 Vector {
362 _handler: EDMA_1_CH14,
363 },
364 Vector {
365 _handler: EDMA_1_CH15,
366 },
367 Vector { _handler: CDOG0 },
368 Vector { _handler: CDOG1 },
369 Vector { _handler: I3C0 },
370 Vector { _handler: I3C1 },
371 Vector { _reserved: 0 },
372 Vector { _handler: GDET },
373 Vector { _handler: VBAT0 },
374 Vector { _handler: EWM0 },
375 Vector {
376 _handler: TSI_END_OF_SCAN,
377 },
378 Vector {
379 _handler: TSI_OUT_OF_SCAN,
380 },
381 Vector { _handler: EMVSIM0 },
382 Vector { _handler: EMVSIM1 },
383 Vector { _handler: FLEXIO },
384 Vector { _handler: DAC0 },
385 Vector { _handler: DAC1 },
386 Vector { _handler: DAC2 },
387 Vector { _handler: HSCMP0 },
388 Vector { _handler: HSCMP1 },
389 Vector { _handler: HSCMP2 },
390 Vector {
391 _handler: FLEXPWM0_RELOAD_ERROR,
392 },
393 Vector {
394 _handler: FLEXPWM0_FAULT,
395 },
396 Vector {
397 _handler: FLEXPWM0_SUBMODULE0,
398 },
399 Vector {
400 _handler: FLEXPWM0_SUBMODULE1,
401 },
402 Vector {
403 _handler: FLEXPWM0_SUBMODULE2,
404 },
405 Vector {
406 _handler: FLEXPWM0_SUBMODULE3,
407 },
408 Vector {
409 _handler: FLEXPWM1_RELOAD_ERROR,
410 },
411 Vector {
412 _handler: FLEXPWM1_FAULT,
413 },
414 Vector {
415 _handler: FLEXPWM1_SUBMODULE0,
416 },
417 Vector {
418 _handler: FLEXPWM1_SUBMODULE1,
419 },
420 Vector {
421 _handler: FLEXPWM1_SUBMODULE2,
422 },
423 Vector {
424 _handler: FLEXPWM1_SUBMODULE3,
425 },
426 Vector {
427 _handler: ENC0_COMPARE,
428 },
429 Vector {
430 _handler: ENC0_HOME,
431 },
432 Vector {
433 _handler: ENC0_WDG_SAB,
434 },
435 Vector { _handler: ENC0_IDX },
436 Vector {
437 _handler: ENC1_COMPARE,
438 },
439 Vector {
440 _handler: ENC1_HOME,
441 },
442 Vector {
443 _handler: ENC1_WDG_SAB,
444 },
445 Vector { _handler: ENC1_IDX },
446 Vector { _handler: ITRC0 },
447 Vector { _handler: BSP32 },
448 Vector { _handler: ELS_ERR },
449 Vector { _handler: PKC_ERR },
450 Vector {
451 _handler: ERM_SINGLE_BIT_ERROR,
452 },
453 Vector {
454 _handler: ERM_MULTI_BIT_ERROR,
455 },
456 Vector { _handler: FMU0 },
457 Vector { _handler: ETHERNET },
458 Vector {
459 _handler: ETHERNET_PMT,
460 },
461 Vector {
462 _handler: ETHERNET_MACLP,
463 },
464 Vector {
465 _handler: SINC_FILTER,
466 },
467 Vector { _handler: LPTMR0 },
468 Vector { _handler: LPTMR1 },
469 Vector { _handler: SCG },
470 Vector { _handler: SPC },
471 Vector { _handler: WUU },
472 Vector { _handler: PORT_EFT },
473 Vector { _handler: ETB0 },
474 Vector { _handler: SM3 },
475 Vector { _handler: TRNG0 },
476 Vector { _handler: WWDT0 },
477 Vector { _handler: WWDT1 },
478 Vector { _handler: CMC0 },
479 Vector { _handler: CTI0 },
480];
481#[doc = r"Enumeration of all the interrupts."]
482#[derive(Copy, Clone, Debug, PartialEq, Eq)]
483#[repr(u16)]
484pub enum Interrupt {
485 #[doc = "1 - EDMA_0_CH0"]
486 EDMA_0_CH0 = 1,
487 #[doc = "2 - EDMA_0_CH1"]
488 EDMA_0_CH1 = 2,
489 #[doc = "3 - EDMA_0_CH2"]
490 EDMA_0_CH2 = 3,
491 #[doc = "4 - EDMA_0_CH3"]
492 EDMA_0_CH3 = 4,
493 #[doc = "5 - EDMA_0_CH4"]
494 EDMA_0_CH4 = 5,
495 #[doc = "6 - EDMA_0_CH5"]
496 EDMA_0_CH5 = 6,
497 #[doc = "7 - EDMA_0_CH6"]
498 EDMA_0_CH6 = 7,
499 #[doc = "8 - EDMA_0_CH7"]
500 EDMA_0_CH7 = 8,
501 #[doc = "9 - EDMA_0_CH8"]
502 EDMA_0_CH8 = 9,
503 #[doc = "10 - EDMA_0_CH9"]
504 EDMA_0_CH9 = 10,
505 #[doc = "11 - EDMA_0_CH10"]
506 EDMA_0_CH10 = 11,
507 #[doc = "12 - EDMA_0_CH11"]
508 EDMA_0_CH11 = 12,
509 #[doc = "13 - EDMA_0_CH12"]
510 EDMA_0_CH12 = 13,
511 #[doc = "14 - EDMA_0_CH13"]
512 EDMA_0_CH13 = 14,
513 #[doc = "15 - EDMA_0_CH14"]
514 EDMA_0_CH14 = 15,
515 #[doc = "16 - EDMA_0_CH15"]
516 EDMA_0_CH15 = 16,
517 #[doc = "17 - GPIO00"]
518 GPIO00 = 17,
519 #[doc = "18 - GPIO01"]
520 GPIO01 = 18,
521 #[doc = "19 - GPIO10"]
522 GPIO10 = 19,
523 #[doc = "20 - GPIO11"]
524 GPIO11 = 20,
525 #[doc = "21 - GPIO20"]
526 GPIO20 = 21,
527 #[doc = "22 - GPIO21"]
528 GPIO21 = 22,
529 #[doc = "23 - GPIO30"]
530 GPIO30 = 23,
531 #[doc = "24 - GPIO31"]
532 GPIO31 = 24,
533 #[doc = "25 - GPIO40"]
534 GPIO40 = 25,
535 #[doc = "26 - GPIO41"]
536 GPIO41 = 26,
537 #[doc = "27 - GPIO50"]
538 GPIO50 = 27,
539 #[doc = "28 - GPIO51"]
540 GPIO51 = 28,
541 #[doc = "29 - UTICK0"]
542 UTICK0 = 29,
543 #[doc = "30 - MRT0"]
544 MRT0 = 30,
545 #[doc = "31 - CTIMER0"]
546 CTIMER0 = 31,
547 #[doc = "32 - CTIMER1"]
548 CTIMER1 = 32,
549 #[doc = "33 - SCT0"]
550 SCT0 = 33,
551 #[doc = "34 - CTIMER2"]
552 CTIMER2 = 34,
553 #[doc = "35 - LP_FLEXCOMM0"]
554 LP_FLEXCOMM0 = 35,
555 #[doc = "36 - LP_FLEXCOMM1"]
556 LP_FLEXCOMM1 = 36,
557 #[doc = "37 - LP_FLEXCOMM2"]
558 LP_FLEXCOMM2 = 37,
559 #[doc = "38 - LP_FLEXCOMM3"]
560 LP_FLEXCOMM3 = 38,
561 #[doc = "39 - LP_FLEXCOMM4"]
562 LP_FLEXCOMM4 = 39,
563 #[doc = "40 - LP_FLEXCOMM5"]
564 LP_FLEXCOMM5 = 40,
565 #[doc = "41 - LP_FLEXCOMM6"]
566 LP_FLEXCOMM6 = 41,
567 #[doc = "42 - LP_FLEXCOMM7"]
568 LP_FLEXCOMM7 = 42,
569 #[doc = "43 - LP_FLEXCOMM8"]
570 LP_FLEXCOMM8 = 43,
571 #[doc = "44 - LP_FLEXCOMM9"]
572 LP_FLEXCOMM9 = 44,
573 #[doc = "45 - ADC0"]
574 ADC0 = 45,
575 #[doc = "46 - ADC1"]
576 ADC1 = 46,
577 #[doc = "47 - PINT0"]
578 PINT0 = 47,
579 #[doc = "48 - PDM_EVENT"]
580 PDM_EVENT = 48,
581 #[doc = "50 - USB0_FS"]
582 USB0_FS = 50,
583 #[doc = "51 - USB0_DCD"]
584 USB0_DCD = 51,
585 #[doc = "52 - RTC"]
586 RTC = 52,
587 #[doc = "53 - SMARTDMA"]
588 SMARTDMA = 53,
589 #[doc = "54 - MAILBOX"]
590 MAILBOX = 54,
591 #[doc = "55 - CTIMER3"]
592 CTIMER3 = 55,
593 #[doc = "56 - CTIMER4"]
594 CTIMER4 = 56,
595 #[doc = "57 - OS_EVENT"]
596 OS_EVENT = 57,
597 #[doc = "58 - FLEXSPI0"]
598 FLEXSPI0 = 58,
599 #[doc = "59 - SAI0"]
600 SAI0 = 59,
601 #[doc = "60 - SAI1"]
602 SAI1 = 60,
603 #[doc = "61 - USDHC0"]
604 USDHC0 = 61,
605 #[doc = "62 - CAN0"]
606 CAN0 = 62,
607 #[doc = "63 - CAN1"]
608 CAN1 = 63,
609 #[doc = "66 - USB1_HS_PHY"]
610 USB1_HS_PHY = 66,
611 #[doc = "67 - USB1_HS"]
612 USB1_HS = 67,
613 #[doc = "68 - SEC_HYPERVISOR_CALL"]
614 SEC_HYPERVISOR_CALL = 68,
615 #[doc = "70 - PLU"]
616 PLU = 70,
617 #[doc = "71 - Freqme"]
618 FREQME = 71,
619 #[doc = "72 - SEC_VIO"]
620 SEC_VIO = 72,
621 #[doc = "73 - ELS"]
622 ELS = 73,
623 #[doc = "74 - PKC"]
624 PKC = 74,
625 #[doc = "75 - PUF"]
626 PUF = 75,
627 #[doc = "76 - PQ"]
628 PQ = 76,
629 #[doc = "77 - EDMA_1_CH0"]
630 EDMA_1_CH0 = 77,
631 #[doc = "78 - EDMA_1_CH1"]
632 EDMA_1_CH1 = 78,
633 #[doc = "79 - EDMA_1_CH2"]
634 EDMA_1_CH2 = 79,
635 #[doc = "80 - EDMA_1_CH3"]
636 EDMA_1_CH3 = 80,
637 #[doc = "81 - EDMA_1_CH4"]
638 EDMA_1_CH4 = 81,
639 #[doc = "82 - EDMA_1_CH5"]
640 EDMA_1_CH5 = 82,
641 #[doc = "83 - EDMA_1_CH6"]
642 EDMA_1_CH6 = 83,
643 #[doc = "84 - EDMA_1_CH7"]
644 EDMA_1_CH7 = 84,
645 #[doc = "85 - EDMA_1_CH8"]
646 EDMA_1_CH8 = 85,
647 #[doc = "86 - EDMA_1_CH9"]
648 EDMA_1_CH9 = 86,
649 #[doc = "87 - EDMA_1_CH10"]
650 EDMA_1_CH10 = 87,
651 #[doc = "88 - EDMA_1_CH11"]
652 EDMA_1_CH11 = 88,
653 #[doc = "89 - EDMA_1_CH12"]
654 EDMA_1_CH12 = 89,
655 #[doc = "90 - EDMA_1_CH13"]
656 EDMA_1_CH13 = 90,
657 #[doc = "91 - EDMA_1_CH14"]
658 EDMA_1_CH14 = 91,
659 #[doc = "92 - EDMA_1_CH15"]
660 EDMA_1_CH15 = 92,
661 #[doc = "93 - CDOG0"]
662 CDOG0 = 93,
663 #[doc = "94 - CDOG1"]
664 CDOG1 = 94,
665 #[doc = "95 - I3C0"]
666 I3C0 = 95,
667 #[doc = "96 - I3C1"]
668 I3C1 = 96,
669 #[doc = "98 - GDET"]
670 GDET = 98,
671 #[doc = "99 - VBAT0"]
672 VBAT0 = 99,
673 #[doc = "100 - EWM0"]
674 EWM0 = 100,
675 #[doc = "101 - TSI_END_OF_SCAN"]
676 TSI_END_OF_SCAN = 101,
677 #[doc = "102 - TSI_OUT_OF_SCAN"]
678 TSI_OUT_OF_SCAN = 102,
679 #[doc = "103 - EMVSIM0"]
680 EMVSIM0 = 103,
681 #[doc = "104 - EMVSIM1"]
682 EMVSIM1 = 104,
683 #[doc = "105 - FLEXIO"]
684 FLEXIO = 105,
685 #[doc = "106 - DAC0"]
686 DAC0 = 106,
687 #[doc = "107 - DAC1"]
688 DAC1 = 107,
689 #[doc = "108 - DAC2"]
690 DAC2 = 108,
691 #[doc = "109 - HSCMP0"]
692 HSCMP0 = 109,
693 #[doc = "110 - HSCMP1"]
694 HSCMP1 = 110,
695 #[doc = "111 - HSCMP2"]
696 HSCMP2 = 111,
697 #[doc = "112 - FLEXPWM0_RELOAD_ERROR"]
698 FLEXPWM0_RELOAD_ERROR = 112,
699 #[doc = "113 - FLEXPWM0_FAULT"]
700 FLEXPWM0_FAULT = 113,
701 #[doc = "114 - FLEXPWM0_SUBMODULE0"]
702 FLEXPWM0_SUBMODULE0 = 114,
703 #[doc = "115 - FLEXPWM0_SUBMODULE1"]
704 FLEXPWM0_SUBMODULE1 = 115,
705 #[doc = "116 - FLEXPWM0_SUBMODULE2"]
706 FLEXPWM0_SUBMODULE2 = 116,
707 #[doc = "117 - FLEXPWM0_SUBMODULE3"]
708 FLEXPWM0_SUBMODULE3 = 117,
709 #[doc = "118 - FLEXPWM1_RELOAD_ERROR"]
710 FLEXPWM1_RELOAD_ERROR = 118,
711 #[doc = "119 - FLEXPWM1_FAULT"]
712 FLEXPWM1_FAULT = 119,
713 #[doc = "120 - FLEXPWM1_SUBMODULE0"]
714 FLEXPWM1_SUBMODULE0 = 120,
715 #[doc = "121 - FLEXPWM1_SUBMODULE1"]
716 FLEXPWM1_SUBMODULE1 = 121,
717 #[doc = "122 - FLEXPWM1_SUBMODULE2"]
718 FLEXPWM1_SUBMODULE2 = 122,
719 #[doc = "123 - FLEXPWM1_SUBMODULE3"]
720 FLEXPWM1_SUBMODULE3 = 123,
721 #[doc = "124 - ENC0_COMPARE"]
722 ENC0_COMPARE = 124,
723 #[doc = "125 - ENC0_HOME"]
724 ENC0_HOME = 125,
725 #[doc = "126 - ENC0_WDG_SAB"]
726 ENC0_WDG_SAB = 126,
727 #[doc = "127 - ENC0_IDX"]
728 ENC0_IDX = 127,
729 #[doc = "128 - ENC1_COMPARE"]
730 ENC1_COMPARE = 128,
731 #[doc = "129 - ENC1_HOME"]
732 ENC1_HOME = 129,
733 #[doc = "130 - ENC1_WDG_SAB"]
734 ENC1_WDG_SAB = 130,
735 #[doc = "131 - ENC1_IDX"]
736 ENC1_IDX = 131,
737 #[doc = "132 - ITRC0"]
738 ITRC0 = 132,
739 #[doc = "133 - BSP32"]
740 BSP32 = 133,
741 #[doc = "134 - ELS_ERR"]
742 ELS_ERR = 134,
743 #[doc = "135 - PKC_ERR"]
744 PKC_ERR = 135,
745 #[doc = "136 - ERM_SINGLE_BIT_ERROR"]
746 ERM_SINGLE_BIT_ERROR = 136,
747 #[doc = "137 - ERM_MULTI_BIT_ERROR"]
748 ERM_MULTI_BIT_ERROR = 137,
749 #[doc = "138 - FMU0"]
750 FMU0 = 138,
751 #[doc = "139 - ETHERNET"]
752 ETHERNET = 139,
753 #[doc = "140 - ETHERNET_PMT"]
754 ETHERNET_PMT = 140,
755 #[doc = "141 - ETHERNET_MACLP"]
756 ETHERNET_MACLP = 141,
757 #[doc = "142 - SINC_FILTER"]
758 SINC_FILTER = 142,
759 #[doc = "143 - LPTMR0"]
760 LPTMR0 = 143,
761 #[doc = "144 - LPTMR1"]
762 LPTMR1 = 144,
763 #[doc = "145 - SCG"]
764 SCG = 145,
765 #[doc = "146 - SPC"]
766 SPC = 146,
767 #[doc = "147 - WUU"]
768 WUU = 147,
769 #[doc = "148 - PORT_EFT"]
770 PORT_EFT = 148,
771 #[doc = "149 - ETB0"]
772 ETB0 = 149,
773 #[doc = "150 - SM3"]
774 SM3 = 150,
775 #[doc = "151 - TRNG0"]
776 TRNG0 = 151,
777 #[doc = "152 - WWDT0"]
778 WWDT0 = 152,
779 #[doc = "153 - WWDT1"]
780 WWDT1 = 153,
781 #[doc = "154 - CMC0"]
782 CMC0 = 154,
783 #[doc = "155 - CTI0"]
784 CTI0 = 155,
785}
786unsafe impl cortex_m::interrupt::InterruptNumber for Interrupt {
787 #[inline(always)]
788 fn number(self) -> u16 {
789 self as u16
790 }
791}
792#[doc = "SYSCON"]
793pub struct SYSCON0 {
794 _marker: PhantomData<*const ()>,
795}
796unsafe impl Send for SYSCON0 {}
797impl SYSCON0 {
798 #[doc = r"Pointer to the register block"]
799 pub const PTR: *const syscon0::RegisterBlock = 0x4000_0000 as *const _;
800 #[doc = r"Return the pointer to the register block"]
801 #[inline(always)]
802 pub const fn ptr() -> *const syscon0::RegisterBlock {
803 Self::PTR
804 }
805 #[doc = r" Steal an instance of this peripheral"]
806 #[doc = r""]
807 #[doc = r" # Safety"]
808 #[doc = r""]
809 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
810 #[doc = r" that may race with any existing instances, for example by only"]
811 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
812 #[doc = r" original peripheral and using critical sections to coordinate"]
813 #[doc = r" access between multiple new instances."]
814 #[doc = r""]
815 #[doc = r" Additionally, other software such as HALs may rely on only one"]
816 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
817 #[doc = r" no stolen instances are passed to such software."]
818 pub unsafe fn steal() -> Self {
819 Self {
820 _marker: PhantomData,
821 }
822 }
823}
824impl Deref for SYSCON0 {
825 type Target = syscon0::RegisterBlock;
826 #[inline(always)]
827 fn deref(&self) -> &Self::Target {
828 unsafe { &*Self::PTR }
829 }
830}
831impl core::fmt::Debug for SYSCON0 {
832 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
833 f.debug_struct("SYSCON0").finish()
834 }
835}
836#[doc = "SYSCON"]
837pub mod syscon0;
838#[doc = "Pin Interrupts and Pattern Match"]
839pub struct PINT0 {
840 _marker: PhantomData<*const ()>,
841}
842unsafe impl Send for PINT0 {}
843impl PINT0 {
844 #[doc = r"Pointer to the register block"]
845 pub const PTR: *const pint0::RegisterBlock = 0x4000_4000 as *const _;
846 #[doc = r"Return the pointer to the register block"]
847 #[inline(always)]
848 pub const fn ptr() -> *const pint0::RegisterBlock {
849 Self::PTR
850 }
851 #[doc = r" Steal an instance of this peripheral"]
852 #[doc = r""]
853 #[doc = r" # Safety"]
854 #[doc = r""]
855 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
856 #[doc = r" that may race with any existing instances, for example by only"]
857 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
858 #[doc = r" original peripheral and using critical sections to coordinate"]
859 #[doc = r" access between multiple new instances."]
860 #[doc = r""]
861 #[doc = r" Additionally, other software such as HALs may rely on only one"]
862 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
863 #[doc = r" no stolen instances are passed to such software."]
864 pub unsafe fn steal() -> Self {
865 Self {
866 _marker: PhantomData,
867 }
868 }
869}
870impl Deref for PINT0 {
871 type Target = pint0::RegisterBlock;
872 #[inline(always)]
873 fn deref(&self) -> &Self::Target {
874 unsafe { &*Self::PTR }
875 }
876}
877impl core::fmt::Debug for PINT0 {
878 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
879 f.debug_struct("PINT0").finish()
880 }
881}
882#[doc = "Pin Interrupts and Pattern Match"]
883pub mod pint0;
884#[doc = "INPUTMUX"]
885pub struct INPUTMUX0 {
886 _marker: PhantomData<*const ()>,
887}
888unsafe impl Send for INPUTMUX0 {}
889impl INPUTMUX0 {
890 #[doc = r"Pointer to the register block"]
891 pub const PTR: *const inputmux0::RegisterBlock = 0x4000_6000 as *const _;
892 #[doc = r"Return the pointer to the register block"]
893 #[inline(always)]
894 pub const fn ptr() -> *const inputmux0::RegisterBlock {
895 Self::PTR
896 }
897 #[doc = r" Steal an instance of this peripheral"]
898 #[doc = r""]
899 #[doc = r" # Safety"]
900 #[doc = r""]
901 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
902 #[doc = r" that may race with any existing instances, for example by only"]
903 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
904 #[doc = r" original peripheral and using critical sections to coordinate"]
905 #[doc = r" access between multiple new instances."]
906 #[doc = r""]
907 #[doc = r" Additionally, other software such as HALs may rely on only one"]
908 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
909 #[doc = r" no stolen instances are passed to such software."]
910 pub unsafe fn steal() -> Self {
911 Self {
912 _marker: PhantomData,
913 }
914 }
915}
916impl Deref for INPUTMUX0 {
917 type Target = inputmux0::RegisterBlock;
918 #[inline(always)]
919 fn deref(&self) -> &Self::Target {
920 unsafe { &*Self::PTR }
921 }
922}
923impl core::fmt::Debug for INPUTMUX0 {
924 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
925 f.debug_struct("INPUTMUX0").finish()
926 }
927}
928#[doc = "INPUTMUX"]
929pub mod inputmux0;
930#[doc = "CTIMER"]
931pub struct CTIMER0 {
932 _marker: PhantomData<*const ()>,
933}
934unsafe impl Send for CTIMER0 {}
935impl CTIMER0 {
936 #[doc = r"Pointer to the register block"]
937 pub const PTR: *const ctimer0::RegisterBlock = 0x4000_c000 as *const _;
938 #[doc = r"Return the pointer to the register block"]
939 #[inline(always)]
940 pub const fn ptr() -> *const ctimer0::RegisterBlock {
941 Self::PTR
942 }
943 #[doc = r" Steal an instance of this peripheral"]
944 #[doc = r""]
945 #[doc = r" # Safety"]
946 #[doc = r""]
947 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
948 #[doc = r" that may race with any existing instances, for example by only"]
949 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
950 #[doc = r" original peripheral and using critical sections to coordinate"]
951 #[doc = r" access between multiple new instances."]
952 #[doc = r""]
953 #[doc = r" Additionally, other software such as HALs may rely on only one"]
954 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
955 #[doc = r" no stolen instances are passed to such software."]
956 pub unsafe fn steal() -> Self {
957 Self {
958 _marker: PhantomData,
959 }
960 }
961}
962impl Deref for CTIMER0 {
963 type Target = ctimer0::RegisterBlock;
964 #[inline(always)]
965 fn deref(&self) -> &Self::Target {
966 unsafe { &*Self::PTR }
967 }
968}
969impl core::fmt::Debug for CTIMER0 {
970 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
971 f.debug_struct("CTIMER0").finish()
972 }
973}
974#[doc = "CTIMER"]
975pub mod ctimer0;
976#[doc = "CTIMER"]
977pub struct CTIMER1 {
978 _marker: PhantomData<*const ()>,
979}
980unsafe impl Send for CTIMER1 {}
981impl CTIMER1 {
982 #[doc = r"Pointer to the register block"]
983 pub const PTR: *const ctimer0::RegisterBlock = 0x4000_d000 as *const _;
984 #[doc = r"Return the pointer to the register block"]
985 #[inline(always)]
986 pub const fn ptr() -> *const ctimer0::RegisterBlock {
987 Self::PTR
988 }
989 #[doc = r" Steal an instance of this peripheral"]
990 #[doc = r""]
991 #[doc = r" # Safety"]
992 #[doc = r""]
993 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
994 #[doc = r" that may race with any existing instances, for example by only"]
995 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
996 #[doc = r" original peripheral and using critical sections to coordinate"]
997 #[doc = r" access between multiple new instances."]
998 #[doc = r""]
999 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1000 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1001 #[doc = r" no stolen instances are passed to such software."]
1002 pub unsafe fn steal() -> Self {
1003 Self {
1004 _marker: PhantomData,
1005 }
1006 }
1007}
1008impl Deref for CTIMER1 {
1009 type Target = ctimer0::RegisterBlock;
1010 #[inline(always)]
1011 fn deref(&self) -> &Self::Target {
1012 unsafe { &*Self::PTR }
1013 }
1014}
1015impl core::fmt::Debug for CTIMER1 {
1016 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1017 f.debug_struct("CTIMER1").finish()
1018 }
1019}
1020#[doc = "CTIMER"]
1021pub use self::ctimer0 as ctimer1;
1022#[doc = "CTIMER"]
1023pub struct CTIMER2 {
1024 _marker: PhantomData<*const ()>,
1025}
1026unsafe impl Send for CTIMER2 {}
1027impl CTIMER2 {
1028 #[doc = r"Pointer to the register block"]
1029 pub const PTR: *const ctimer0::RegisterBlock = 0x4000_e000 as *const _;
1030 #[doc = r"Return the pointer to the register block"]
1031 #[inline(always)]
1032 pub const fn ptr() -> *const ctimer0::RegisterBlock {
1033 Self::PTR
1034 }
1035 #[doc = r" Steal an instance of this peripheral"]
1036 #[doc = r""]
1037 #[doc = r" # Safety"]
1038 #[doc = r""]
1039 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1040 #[doc = r" that may race with any existing instances, for example by only"]
1041 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1042 #[doc = r" original peripheral and using critical sections to coordinate"]
1043 #[doc = r" access between multiple new instances."]
1044 #[doc = r""]
1045 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1046 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1047 #[doc = r" no stolen instances are passed to such software."]
1048 pub unsafe fn steal() -> Self {
1049 Self {
1050 _marker: PhantomData,
1051 }
1052 }
1053}
1054impl Deref for CTIMER2 {
1055 type Target = ctimer0::RegisterBlock;
1056 #[inline(always)]
1057 fn deref(&self) -> &Self::Target {
1058 unsafe { &*Self::PTR }
1059 }
1060}
1061impl core::fmt::Debug for CTIMER2 {
1062 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1063 f.debug_struct("CTIMER2").finish()
1064 }
1065}
1066#[doc = "CTIMER"]
1067pub use self::ctimer0 as ctimer2;
1068#[doc = "CTIMER"]
1069pub struct CTIMER3 {
1070 _marker: PhantomData<*const ()>,
1071}
1072unsafe impl Send for CTIMER3 {}
1073impl CTIMER3 {
1074 #[doc = r"Pointer to the register block"]
1075 pub const PTR: *const ctimer0::RegisterBlock = 0x4000_f000 as *const _;
1076 #[doc = r"Return the pointer to the register block"]
1077 #[inline(always)]
1078 pub const fn ptr() -> *const ctimer0::RegisterBlock {
1079 Self::PTR
1080 }
1081 #[doc = r" Steal an instance of this peripheral"]
1082 #[doc = r""]
1083 #[doc = r" # Safety"]
1084 #[doc = r""]
1085 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1086 #[doc = r" that may race with any existing instances, for example by only"]
1087 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1088 #[doc = r" original peripheral and using critical sections to coordinate"]
1089 #[doc = r" access between multiple new instances."]
1090 #[doc = r""]
1091 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1092 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1093 #[doc = r" no stolen instances are passed to such software."]
1094 pub unsafe fn steal() -> Self {
1095 Self {
1096 _marker: PhantomData,
1097 }
1098 }
1099}
1100impl Deref for CTIMER3 {
1101 type Target = ctimer0::RegisterBlock;
1102 #[inline(always)]
1103 fn deref(&self) -> &Self::Target {
1104 unsafe { &*Self::PTR }
1105 }
1106}
1107impl core::fmt::Debug for CTIMER3 {
1108 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1109 f.debug_struct("CTIMER3").finish()
1110 }
1111}
1112#[doc = "CTIMER"]
1113pub use self::ctimer0 as ctimer3;
1114#[doc = "CTIMER"]
1115pub struct CTIMER4 {
1116 _marker: PhantomData<*const ()>,
1117}
1118unsafe impl Send for CTIMER4 {}
1119impl CTIMER4 {
1120 #[doc = r"Pointer to the register block"]
1121 pub const PTR: *const ctimer0::RegisterBlock = 0x4001_0000 as *const _;
1122 #[doc = r"Return the pointer to the register block"]
1123 #[inline(always)]
1124 pub const fn ptr() -> *const ctimer0::RegisterBlock {
1125 Self::PTR
1126 }
1127 #[doc = r" Steal an instance of this peripheral"]
1128 #[doc = r""]
1129 #[doc = r" # Safety"]
1130 #[doc = r""]
1131 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1132 #[doc = r" that may race with any existing instances, for example by only"]
1133 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1134 #[doc = r" original peripheral and using critical sections to coordinate"]
1135 #[doc = r" access between multiple new instances."]
1136 #[doc = r""]
1137 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1138 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1139 #[doc = r" no stolen instances are passed to such software."]
1140 pub unsafe fn steal() -> Self {
1141 Self {
1142 _marker: PhantomData,
1143 }
1144 }
1145}
1146impl Deref for CTIMER4 {
1147 type Target = ctimer0::RegisterBlock;
1148 #[inline(always)]
1149 fn deref(&self) -> &Self::Target {
1150 unsafe { &*Self::PTR }
1151 }
1152}
1153impl core::fmt::Debug for CTIMER4 {
1154 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1155 f.debug_struct("CTIMER4").finish()
1156 }
1157}
1158#[doc = "CTIMER"]
1159pub use self::ctimer0 as ctimer4;
1160#[doc = "FREQME"]
1161pub struct FREQME0 {
1162 _marker: PhantomData<*const ()>,
1163}
1164unsafe impl Send for FREQME0 {}
1165impl FREQME0 {
1166 #[doc = r"Pointer to the register block"]
1167 pub const PTR: *const freqme0::RegisterBlock = 0x4001_1000 as *const _;
1168 #[doc = r"Return the pointer to the register block"]
1169 #[inline(always)]
1170 pub const fn ptr() -> *const freqme0::RegisterBlock {
1171 Self::PTR
1172 }
1173 #[doc = r" Steal an instance of this peripheral"]
1174 #[doc = r""]
1175 #[doc = r" # Safety"]
1176 #[doc = r""]
1177 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1178 #[doc = r" that may race with any existing instances, for example by only"]
1179 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1180 #[doc = r" original peripheral and using critical sections to coordinate"]
1181 #[doc = r" access between multiple new instances."]
1182 #[doc = r""]
1183 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1184 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1185 #[doc = r" no stolen instances are passed to such software."]
1186 pub unsafe fn steal() -> Self {
1187 Self {
1188 _marker: PhantomData,
1189 }
1190 }
1191}
1192impl Deref for FREQME0 {
1193 type Target = freqme0::RegisterBlock;
1194 #[inline(always)]
1195 fn deref(&self) -> &Self::Target {
1196 unsafe { &*Self::PTR }
1197 }
1198}
1199impl core::fmt::Debug for FREQME0 {
1200 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1201 f.debug_struct("FREQME0").finish()
1202 }
1203}
1204#[doc = "FREQME"]
1205pub mod freqme0;
1206#[doc = "UTICK"]
1207pub struct UTICK0 {
1208 _marker: PhantomData<*const ()>,
1209}
1210unsafe impl Send for UTICK0 {}
1211impl UTICK0 {
1212 #[doc = r"Pointer to the register block"]
1213 pub const PTR: *const utick0::RegisterBlock = 0x4001_2000 as *const _;
1214 #[doc = r"Return the pointer to the register block"]
1215 #[inline(always)]
1216 pub const fn ptr() -> *const utick0::RegisterBlock {
1217 Self::PTR
1218 }
1219 #[doc = r" Steal an instance of this peripheral"]
1220 #[doc = r""]
1221 #[doc = r" # Safety"]
1222 #[doc = r""]
1223 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1224 #[doc = r" that may race with any existing instances, for example by only"]
1225 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1226 #[doc = r" original peripheral and using critical sections to coordinate"]
1227 #[doc = r" access between multiple new instances."]
1228 #[doc = r""]
1229 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1230 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1231 #[doc = r" no stolen instances are passed to such software."]
1232 pub unsafe fn steal() -> Self {
1233 Self {
1234 _marker: PhantomData,
1235 }
1236 }
1237}
1238impl Deref for UTICK0 {
1239 type Target = utick0::RegisterBlock;
1240 #[inline(always)]
1241 fn deref(&self) -> &Self::Target {
1242 unsafe { &*Self::PTR }
1243 }
1244}
1245impl core::fmt::Debug for UTICK0 {
1246 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1247 f.debug_struct("UTICK0").finish()
1248 }
1249}
1250#[doc = "UTICK"]
1251pub mod utick0;
1252#[doc = "Multi-Rate Timer (MRT)"]
1253pub struct MRT0 {
1254 _marker: PhantomData<*const ()>,
1255}
1256unsafe impl Send for MRT0 {}
1257impl MRT0 {
1258 #[doc = r"Pointer to the register block"]
1259 pub const PTR: *const mrt0::RegisterBlock = 0x4001_3000 as *const _;
1260 #[doc = r"Return the pointer to the register block"]
1261 #[inline(always)]
1262 pub const fn ptr() -> *const mrt0::RegisterBlock {
1263 Self::PTR
1264 }
1265 #[doc = r" Steal an instance of this peripheral"]
1266 #[doc = r""]
1267 #[doc = r" # Safety"]
1268 #[doc = r""]
1269 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1270 #[doc = r" that may race with any existing instances, for example by only"]
1271 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1272 #[doc = r" original peripheral and using critical sections to coordinate"]
1273 #[doc = r" access between multiple new instances."]
1274 #[doc = r""]
1275 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1276 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1277 #[doc = r" no stolen instances are passed to such software."]
1278 pub unsafe fn steal() -> Self {
1279 Self {
1280 _marker: PhantomData,
1281 }
1282 }
1283}
1284impl Deref for MRT0 {
1285 type Target = mrt0::RegisterBlock;
1286 #[inline(always)]
1287 fn deref(&self) -> &Self::Target {
1288 unsafe { &*Self::PTR }
1289 }
1290}
1291impl core::fmt::Debug for MRT0 {
1292 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1293 f.debug_struct("MRT0").finish()
1294 }
1295}
1296#[doc = "Multi-Rate Timer (MRT)"]
1297pub mod mrt0;
1298#[doc = "WWDT"]
1299pub struct WWDT0 {
1300 _marker: PhantomData<*const ()>,
1301}
1302unsafe impl Send for WWDT0 {}
1303impl WWDT0 {
1304 #[doc = r"Pointer to the register block"]
1305 pub const PTR: *const wwdt0::RegisterBlock = 0x4001_6000 as *const _;
1306 #[doc = r"Return the pointer to the register block"]
1307 #[inline(always)]
1308 pub const fn ptr() -> *const wwdt0::RegisterBlock {
1309 Self::PTR
1310 }
1311 #[doc = r" Steal an instance of this peripheral"]
1312 #[doc = r""]
1313 #[doc = r" # Safety"]
1314 #[doc = r""]
1315 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1316 #[doc = r" that may race with any existing instances, for example by only"]
1317 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1318 #[doc = r" original peripheral and using critical sections to coordinate"]
1319 #[doc = r" access between multiple new instances."]
1320 #[doc = r""]
1321 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1322 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1323 #[doc = r" no stolen instances are passed to such software."]
1324 pub unsafe fn steal() -> Self {
1325 Self {
1326 _marker: PhantomData,
1327 }
1328 }
1329}
1330impl Deref for WWDT0 {
1331 type Target = wwdt0::RegisterBlock;
1332 #[inline(always)]
1333 fn deref(&self) -> &Self::Target {
1334 unsafe { &*Self::PTR }
1335 }
1336}
1337impl core::fmt::Debug for WWDT0 {
1338 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1339 f.debug_struct("WWDT0").finish()
1340 }
1341}
1342#[doc = "WWDT"]
1343pub mod wwdt0;
1344#[doc = "WWDT"]
1345pub struct WWDT1 {
1346 _marker: PhantomData<*const ()>,
1347}
1348unsafe impl Send for WWDT1 {}
1349impl WWDT1 {
1350 #[doc = r"Pointer to the register block"]
1351 pub const PTR: *const wwdt0::RegisterBlock = 0x4001_7000 as *const _;
1352 #[doc = r"Return the pointer to the register block"]
1353 #[inline(always)]
1354 pub const fn ptr() -> *const wwdt0::RegisterBlock {
1355 Self::PTR
1356 }
1357 #[doc = r" Steal an instance of this peripheral"]
1358 #[doc = r""]
1359 #[doc = r" # Safety"]
1360 #[doc = r""]
1361 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1362 #[doc = r" that may race with any existing instances, for example by only"]
1363 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1364 #[doc = r" original peripheral and using critical sections to coordinate"]
1365 #[doc = r" access between multiple new instances."]
1366 #[doc = r""]
1367 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1368 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1369 #[doc = r" no stolen instances are passed to such software."]
1370 pub unsafe fn steal() -> Self {
1371 Self {
1372 _marker: PhantomData,
1373 }
1374 }
1375}
1376impl Deref for WWDT1 {
1377 type Target = wwdt0::RegisterBlock;
1378 #[inline(always)]
1379 fn deref(&self) -> &Self::Target {
1380 unsafe { &*Self::PTR }
1381 }
1382}
1383impl core::fmt::Debug for WWDT1 {
1384 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1385 f.debug_struct("WWDT1").finish()
1386 }
1387}
1388#[doc = "WWDT"]
1389pub use self::wwdt0 as wwdt1;
1390#[doc = "CACHE64_CTRL"]
1391pub struct CACHE64_CTRL0 {
1392 _marker: PhantomData<*const ()>,
1393}
1394unsafe impl Send for CACHE64_CTRL0 {}
1395impl CACHE64_CTRL0 {
1396 #[doc = r"Pointer to the register block"]
1397 pub const PTR: *const cache64_ctrl0::RegisterBlock = 0x4001_b000 as *const _;
1398 #[doc = r"Return the pointer to the register block"]
1399 #[inline(always)]
1400 pub const fn ptr() -> *const cache64_ctrl0::RegisterBlock {
1401 Self::PTR
1402 }
1403 #[doc = r" Steal an instance of this peripheral"]
1404 #[doc = r""]
1405 #[doc = r" # Safety"]
1406 #[doc = r""]
1407 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1408 #[doc = r" that may race with any existing instances, for example by only"]
1409 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1410 #[doc = r" original peripheral and using critical sections to coordinate"]
1411 #[doc = r" access between multiple new instances."]
1412 #[doc = r""]
1413 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1414 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1415 #[doc = r" no stolen instances are passed to such software."]
1416 pub unsafe fn steal() -> Self {
1417 Self {
1418 _marker: PhantomData,
1419 }
1420 }
1421}
1422impl Deref for CACHE64_CTRL0 {
1423 type Target = cache64_ctrl0::RegisterBlock;
1424 #[inline(always)]
1425 fn deref(&self) -> &Self::Target {
1426 unsafe { &*Self::PTR }
1427 }
1428}
1429impl core::fmt::Debug for CACHE64_CTRL0 {
1430 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1431 f.debug_struct("CACHE64_CTRL0").finish()
1432 }
1433}
1434#[doc = "CACHE64_CTRL"]
1435pub mod cache64_ctrl0;
1436#[doc = "CACHE64_POLSEL"]
1437pub struct CACHE64_POLSEL0 {
1438 _marker: PhantomData<*const ()>,
1439}
1440unsafe impl Send for CACHE64_POLSEL0 {}
1441impl CACHE64_POLSEL0 {
1442 #[doc = r"Pointer to the register block"]
1443 pub const PTR: *const cache64_polsel0::RegisterBlock = 0x4001_b000 as *const _;
1444 #[doc = r"Return the pointer to the register block"]
1445 #[inline(always)]
1446 pub const fn ptr() -> *const cache64_polsel0::RegisterBlock {
1447 Self::PTR
1448 }
1449 #[doc = r" Steal an instance of this peripheral"]
1450 #[doc = r""]
1451 #[doc = r" # Safety"]
1452 #[doc = r""]
1453 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1454 #[doc = r" that may race with any existing instances, for example by only"]
1455 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1456 #[doc = r" original peripheral and using critical sections to coordinate"]
1457 #[doc = r" access between multiple new instances."]
1458 #[doc = r""]
1459 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1460 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1461 #[doc = r" no stolen instances are passed to such software."]
1462 pub unsafe fn steal() -> Self {
1463 Self {
1464 _marker: PhantomData,
1465 }
1466 }
1467}
1468impl Deref for CACHE64_POLSEL0 {
1469 type Target = cache64_polsel0::RegisterBlock;
1470 #[inline(always)]
1471 fn deref(&self) -> &Self::Target {
1472 unsafe { &*Self::PTR }
1473 }
1474}
1475impl core::fmt::Debug for CACHE64_POLSEL0 {
1476 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1477 f.debug_struct("CACHE64_POLSEL0").finish()
1478 }
1479}
1480#[doc = "CACHE64_POLSEL"]
1481pub mod cache64_polsel0;
1482#[doc = "I3C"]
1483pub struct I3C0 {
1484 _marker: PhantomData<*const ()>,
1485}
1486unsafe impl Send for I3C0 {}
1487impl I3C0 {
1488 #[doc = r"Pointer to the register block"]
1489 pub const PTR: *const i3c0::RegisterBlock = 0x4002_1000 as *const _;
1490 #[doc = r"Return the pointer to the register block"]
1491 #[inline(always)]
1492 pub const fn ptr() -> *const i3c0::RegisterBlock {
1493 Self::PTR
1494 }
1495 #[doc = r" Steal an instance of this peripheral"]
1496 #[doc = r""]
1497 #[doc = r" # Safety"]
1498 #[doc = r""]
1499 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1500 #[doc = r" that may race with any existing instances, for example by only"]
1501 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1502 #[doc = r" original peripheral and using critical sections to coordinate"]
1503 #[doc = r" access between multiple new instances."]
1504 #[doc = r""]
1505 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1506 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1507 #[doc = r" no stolen instances are passed to such software."]
1508 pub unsafe fn steal() -> Self {
1509 Self {
1510 _marker: PhantomData,
1511 }
1512 }
1513}
1514impl Deref for I3C0 {
1515 type Target = i3c0::RegisterBlock;
1516 #[inline(always)]
1517 fn deref(&self) -> &Self::Target {
1518 unsafe { &*Self::PTR }
1519 }
1520}
1521impl core::fmt::Debug for I3C0 {
1522 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1523 f.debug_struct("I3C0").finish()
1524 }
1525}
1526#[doc = "I3C"]
1527pub mod i3c0;
1528#[doc = "I3C"]
1529pub struct I3C1 {
1530 _marker: PhantomData<*const ()>,
1531}
1532unsafe impl Send for I3C1 {}
1533impl I3C1 {
1534 #[doc = r"Pointer to the register block"]
1535 pub const PTR: *const i3c0::RegisterBlock = 0x4002_2000 as *const _;
1536 #[doc = r"Return the pointer to the register block"]
1537 #[inline(always)]
1538 pub const fn ptr() -> *const i3c0::RegisterBlock {
1539 Self::PTR
1540 }
1541 #[doc = r" Steal an instance of this peripheral"]
1542 #[doc = r""]
1543 #[doc = r" # Safety"]
1544 #[doc = r""]
1545 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1546 #[doc = r" that may race with any existing instances, for example by only"]
1547 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1548 #[doc = r" original peripheral and using critical sections to coordinate"]
1549 #[doc = r" access between multiple new instances."]
1550 #[doc = r""]
1551 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1552 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1553 #[doc = r" no stolen instances are passed to such software."]
1554 pub unsafe fn steal() -> Self {
1555 Self {
1556 _marker: PhantomData,
1557 }
1558 }
1559}
1560impl Deref for I3C1 {
1561 type Target = i3c0::RegisterBlock;
1562 #[inline(always)]
1563 fn deref(&self) -> &Self::Target {
1564 unsafe { &*Self::PTR }
1565 }
1566}
1567impl core::fmt::Debug for I3C1 {
1568 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1569 f.debug_struct("I3C1").finish()
1570 }
1571}
1572#[doc = "I3C"]
1573pub use self::i3c0 as i3c1;
1574#[doc = "no description available"]
1575pub struct GDET0 {
1576 _marker: PhantomData<*const ()>,
1577}
1578unsafe impl Send for GDET0 {}
1579impl GDET0 {
1580 #[doc = r"Pointer to the register block"]
1581 pub const PTR: *const gdet0::RegisterBlock = 0x4002_4000 as *const _;
1582 #[doc = r"Return the pointer to the register block"]
1583 #[inline(always)]
1584 pub const fn ptr() -> *const gdet0::RegisterBlock {
1585 Self::PTR
1586 }
1587 #[doc = r" Steal an instance of this peripheral"]
1588 #[doc = r""]
1589 #[doc = r" # Safety"]
1590 #[doc = r""]
1591 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1592 #[doc = r" that may race with any existing instances, for example by only"]
1593 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1594 #[doc = r" original peripheral and using critical sections to coordinate"]
1595 #[doc = r" access between multiple new instances."]
1596 #[doc = r""]
1597 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1598 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1599 #[doc = r" no stolen instances are passed to such software."]
1600 pub unsafe fn steal() -> Self {
1601 Self {
1602 _marker: PhantomData,
1603 }
1604 }
1605}
1606impl Deref for GDET0 {
1607 type Target = gdet0::RegisterBlock;
1608 #[inline(always)]
1609 fn deref(&self) -> &Self::Target {
1610 unsafe { &*Self::PTR }
1611 }
1612}
1613impl core::fmt::Debug for GDET0 {
1614 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1615 f.debug_struct("GDET0").finish()
1616 }
1617}
1618#[doc = "no description available"]
1619pub mod gdet0;
1620#[doc = "no description available"]
1621pub struct GDET1 {
1622 _marker: PhantomData<*const ()>,
1623}
1624unsafe impl Send for GDET1 {}
1625impl GDET1 {
1626 #[doc = r"Pointer to the register block"]
1627 pub const PTR: *const gdet0::RegisterBlock = 0x4002_5000 as *const _;
1628 #[doc = r"Return the pointer to the register block"]
1629 #[inline(always)]
1630 pub const fn ptr() -> *const gdet0::RegisterBlock {
1631 Self::PTR
1632 }
1633 #[doc = r" Steal an instance of this peripheral"]
1634 #[doc = r""]
1635 #[doc = r" # Safety"]
1636 #[doc = r""]
1637 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1638 #[doc = r" that may race with any existing instances, for example by only"]
1639 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1640 #[doc = r" original peripheral and using critical sections to coordinate"]
1641 #[doc = r" access between multiple new instances."]
1642 #[doc = r""]
1643 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1644 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1645 #[doc = r" no stolen instances are passed to such software."]
1646 pub unsafe fn steal() -> Self {
1647 Self {
1648 _marker: PhantomData,
1649 }
1650 }
1651}
1652impl Deref for GDET1 {
1653 type Target = gdet0::RegisterBlock;
1654 #[inline(always)]
1655 fn deref(&self) -> &Self::Target {
1656 unsafe { &*Self::PTR }
1657 }
1658}
1659impl core::fmt::Debug for GDET1 {
1660 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1661 f.debug_struct("GDET1").finish()
1662 }
1663}
1664#[doc = "no description available"]
1665pub use self::gdet0 as gdet1;
1666#[doc = "Intrusion and Tamper Response Controller"]
1667pub struct ITRC0 {
1668 _marker: PhantomData<*const ()>,
1669}
1670unsafe impl Send for ITRC0 {}
1671impl ITRC0 {
1672 #[doc = r"Pointer to the register block"]
1673 pub const PTR: *const itrc0::RegisterBlock = 0x4002_6000 as *const _;
1674 #[doc = r"Return the pointer to the register block"]
1675 #[inline(always)]
1676 pub const fn ptr() -> *const itrc0::RegisterBlock {
1677 Self::PTR
1678 }
1679 #[doc = r" Steal an instance of this peripheral"]
1680 #[doc = r""]
1681 #[doc = r" # Safety"]
1682 #[doc = r""]
1683 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1684 #[doc = r" that may race with any existing instances, for example by only"]
1685 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1686 #[doc = r" original peripheral and using critical sections to coordinate"]
1687 #[doc = r" access between multiple new instances."]
1688 #[doc = r""]
1689 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1690 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1691 #[doc = r" no stolen instances are passed to such software."]
1692 pub unsafe fn steal() -> Self {
1693 Self {
1694 _marker: PhantomData,
1695 }
1696 }
1697}
1698impl Deref for ITRC0 {
1699 type Target = itrc0::RegisterBlock;
1700 #[inline(always)]
1701 fn deref(&self) -> &Self::Target {
1702 unsafe { &*Self::PTR }
1703 }
1704}
1705impl core::fmt::Debug for ITRC0 {
1706 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1707 f.debug_struct("ITRC0").finish()
1708 }
1709}
1710#[doc = "Intrusion and Tamper Response Controller"]
1711pub mod itrc0;
1712#[doc = "no description available"]
1713pub struct PKC0 {
1714 _marker: PhantomData<*const ()>,
1715}
1716unsafe impl Send for PKC0 {}
1717impl PKC0 {
1718 #[doc = r"Pointer to the register block"]
1719 pub const PTR: *const pkc0::RegisterBlock = 0x4002_b000 as *const _;
1720 #[doc = r"Return the pointer to the register block"]
1721 #[inline(always)]
1722 pub const fn ptr() -> *const pkc0::RegisterBlock {
1723 Self::PTR
1724 }
1725 #[doc = r" Steal an instance of this peripheral"]
1726 #[doc = r""]
1727 #[doc = r" # Safety"]
1728 #[doc = r""]
1729 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1730 #[doc = r" that may race with any existing instances, for example by only"]
1731 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1732 #[doc = r" original peripheral and using critical sections to coordinate"]
1733 #[doc = r" access between multiple new instances."]
1734 #[doc = r""]
1735 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1736 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1737 #[doc = r" no stolen instances are passed to such software."]
1738 pub unsafe fn steal() -> Self {
1739 Self {
1740 _marker: PhantomData,
1741 }
1742 }
1743}
1744impl Deref for PKC0 {
1745 type Target = pkc0::RegisterBlock;
1746 #[inline(always)]
1747 fn deref(&self) -> &Self::Target {
1748 unsafe { &*Self::PTR }
1749 }
1750}
1751impl core::fmt::Debug for PKC0 {
1752 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1753 f.debug_struct("PKC0").finish()
1754 }
1755}
1756#[doc = "no description available"]
1757pub mod pkc0;
1758#[doc = "PUF"]
1759pub struct PUF {
1760 _marker: PhantomData<*const ()>,
1761}
1762unsafe impl Send for PUF {}
1763impl PUF {
1764 #[doc = r"Pointer to the register block"]
1765 pub const PTR: *const puf::RegisterBlock = 0x4002_c000 as *const _;
1766 #[doc = r"Return the pointer to the register block"]
1767 #[inline(always)]
1768 pub const fn ptr() -> *const puf::RegisterBlock {
1769 Self::PTR
1770 }
1771 #[doc = r" Steal an instance of this peripheral"]
1772 #[doc = r""]
1773 #[doc = r" # Safety"]
1774 #[doc = r""]
1775 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1776 #[doc = r" that may race with any existing instances, for example by only"]
1777 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1778 #[doc = r" original peripheral and using critical sections to coordinate"]
1779 #[doc = r" access between multiple new instances."]
1780 #[doc = r""]
1781 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1782 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1783 #[doc = r" no stolen instances are passed to such software."]
1784 pub unsafe fn steal() -> Self {
1785 Self {
1786 _marker: PhantomData,
1787 }
1788 }
1789}
1790impl Deref for PUF {
1791 type Target = puf::RegisterBlock;
1792 #[inline(always)]
1793 fn deref(&self) -> &Self::Target {
1794 unsafe { &*Self::PTR }
1795 }
1796}
1797impl core::fmt::Debug for PUF {
1798 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1799 f.debug_struct("PUF").finish()
1800 }
1801}
1802#[doc = "PUF"]
1803pub mod puf;
1804#[doc = "PUF Key Context Management"]
1805pub struct PUF_CTRL {
1806 _marker: PhantomData<*const ()>,
1807}
1808unsafe impl Send for PUF_CTRL {}
1809impl PUF_CTRL {
1810 #[doc = r"Pointer to the register block"]
1811 pub const PTR: *const puf_ctrl::RegisterBlock = 0x4002_c000 as *const _;
1812 #[doc = r"Return the pointer to the register block"]
1813 #[inline(always)]
1814 pub const fn ptr() -> *const puf_ctrl::RegisterBlock {
1815 Self::PTR
1816 }
1817 #[doc = r" Steal an instance of this peripheral"]
1818 #[doc = r""]
1819 #[doc = r" # Safety"]
1820 #[doc = r""]
1821 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1822 #[doc = r" that may race with any existing instances, for example by only"]
1823 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1824 #[doc = r" original peripheral and using critical sections to coordinate"]
1825 #[doc = r" access between multiple new instances."]
1826 #[doc = r""]
1827 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1828 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1829 #[doc = r" no stolen instances are passed to such software."]
1830 pub unsafe fn steal() -> Self {
1831 Self {
1832 _marker: PhantomData,
1833 }
1834 }
1835}
1836impl Deref for PUF_CTRL {
1837 type Target = puf_ctrl::RegisterBlock;
1838 #[inline(always)]
1839 fn deref(&self) -> &Self::Target {
1840 unsafe { &*Self::PTR }
1841 }
1842}
1843impl core::fmt::Debug for PUF_CTRL {
1844 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1845 f.debug_struct("PUF_CTRL").finish()
1846 }
1847}
1848#[doc = "PUF Key Context Management"]
1849pub mod puf_ctrl;
1850#[doc = "SAFO_SM3_SGI"]
1851pub struct SM3_0 {
1852 _marker: PhantomData<*const ()>,
1853}
1854unsafe impl Send for SM3_0 {}
1855impl SM3_0 {
1856 #[doc = r"Pointer to the register block"]
1857 pub const PTR: *const sm3_0::RegisterBlock = 0x4003_1000 as *const _;
1858 #[doc = r"Return the pointer to the register block"]
1859 #[inline(always)]
1860 pub const fn ptr() -> *const sm3_0::RegisterBlock {
1861 Self::PTR
1862 }
1863 #[doc = r" Steal an instance of this peripheral"]
1864 #[doc = r""]
1865 #[doc = r" # Safety"]
1866 #[doc = r""]
1867 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1868 #[doc = r" that may race with any existing instances, for example by only"]
1869 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1870 #[doc = r" original peripheral and using critical sections to coordinate"]
1871 #[doc = r" access between multiple new instances."]
1872 #[doc = r""]
1873 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1874 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1875 #[doc = r" no stolen instances are passed to such software."]
1876 pub unsafe fn steal() -> Self {
1877 Self {
1878 _marker: PhantomData,
1879 }
1880 }
1881}
1882impl Deref for SM3_0 {
1883 type Target = sm3_0::RegisterBlock;
1884 #[inline(always)]
1885 fn deref(&self) -> &Self::Target {
1886 unsafe { &*Self::PTR }
1887 }
1888}
1889impl core::fmt::Debug for SM3_0 {
1890 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1891 f.debug_struct("SM3_0").finish()
1892 }
1893}
1894#[doc = "SAFO_SM3_SGI"]
1895pub mod sm3_0;
1896#[doc = "CoolFlux BSP32"]
1897pub struct BSP32_0 {
1898 _marker: PhantomData<*const ()>,
1899}
1900unsafe impl Send for BSP32_0 {}
1901impl BSP32_0 {
1902 #[doc = r"Pointer to the register block"]
1903 pub const PTR: *const bsp32_0::RegisterBlock = 0x4003_2000 as *const _;
1904 #[doc = r"Return the pointer to the register block"]
1905 #[inline(always)]
1906 pub const fn ptr() -> *const bsp32_0::RegisterBlock {
1907 Self::PTR
1908 }
1909 #[doc = r" Steal an instance of this peripheral"]
1910 #[doc = r""]
1911 #[doc = r" # Safety"]
1912 #[doc = r""]
1913 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1914 #[doc = r" that may race with any existing instances, for example by only"]
1915 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1916 #[doc = r" original peripheral and using critical sections to coordinate"]
1917 #[doc = r" access between multiple new instances."]
1918 #[doc = r""]
1919 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1920 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1921 #[doc = r" no stolen instances are passed to such software."]
1922 pub unsafe fn steal() -> Self {
1923 Self {
1924 _marker: PhantomData,
1925 }
1926 }
1927}
1928impl Deref for BSP32_0 {
1929 type Target = bsp32_0::RegisterBlock;
1930 #[inline(always)]
1931 fn deref(&self) -> &Self::Target {
1932 unsafe { &*Self::PTR }
1933 }
1934}
1935impl core::fmt::Debug for BSP32_0 {
1936 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1937 f.debug_struct("BSP32_0").finish()
1938 }
1939}
1940#[doc = "CoolFlux BSP32"]
1941pub mod bsp32_0;
1942#[doc = "SmartDMA"]
1943pub struct SMARTDMA0 {
1944 _marker: PhantomData<*const ()>,
1945}
1946unsafe impl Send for SMARTDMA0 {}
1947impl SMARTDMA0 {
1948 #[doc = r"Pointer to the register block"]
1949 pub const PTR: *const smartdma0::RegisterBlock = 0x4003_3000 as *const _;
1950 #[doc = r"Return the pointer to the register block"]
1951 #[inline(always)]
1952 pub const fn ptr() -> *const smartdma0::RegisterBlock {
1953 Self::PTR
1954 }
1955 #[doc = r" Steal an instance of this peripheral"]
1956 #[doc = r""]
1957 #[doc = r" # Safety"]
1958 #[doc = r""]
1959 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1960 #[doc = r" that may race with any existing instances, for example by only"]
1961 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1962 #[doc = r" original peripheral and using critical sections to coordinate"]
1963 #[doc = r" access between multiple new instances."]
1964 #[doc = r""]
1965 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1966 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1967 #[doc = r" no stolen instances are passed to such software."]
1968 pub unsafe fn steal() -> Self {
1969 Self {
1970 _marker: PhantomData,
1971 }
1972 }
1973}
1974impl Deref for SMARTDMA0 {
1975 type Target = smartdma0::RegisterBlock;
1976 #[inline(always)]
1977 fn deref(&self) -> &Self::Target {
1978 unsafe { &*Self::PTR }
1979 }
1980}
1981impl core::fmt::Debug for SMARTDMA0 {
1982 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1983 f.debug_struct("SMARTDMA0").finish()
1984 }
1985}
1986#[doc = "SmartDMA"]
1987pub mod smartdma0;
1988#[doc = "Programmable Logic Unit (PLU)"]
1989pub struct PLU0 {
1990 _marker: PhantomData<*const ()>,
1991}
1992unsafe impl Send for PLU0 {}
1993impl PLU0 {
1994 #[doc = r"Pointer to the register block"]
1995 pub const PTR: *const plu0::RegisterBlock = 0x4003_4000 as *const _;
1996 #[doc = r"Return the pointer to the register block"]
1997 #[inline(always)]
1998 pub const fn ptr() -> *const plu0::RegisterBlock {
1999 Self::PTR
2000 }
2001 #[doc = r" Steal an instance of this peripheral"]
2002 #[doc = r""]
2003 #[doc = r" # Safety"]
2004 #[doc = r""]
2005 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2006 #[doc = r" that may race with any existing instances, for example by only"]
2007 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2008 #[doc = r" original peripheral and using critical sections to coordinate"]
2009 #[doc = r" access between multiple new instances."]
2010 #[doc = r""]
2011 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2012 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2013 #[doc = r" no stolen instances are passed to such software."]
2014 pub unsafe fn steal() -> Self {
2015 Self {
2016 _marker: PhantomData,
2017 }
2018 }
2019}
2020impl Deref for PLU0 {
2021 type Target = plu0::RegisterBlock;
2022 #[inline(always)]
2023 fn deref(&self) -> &Self::Target {
2024 unsafe { &*Self::PTR }
2025 }
2026}
2027impl core::fmt::Debug for PLU0 {
2028 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2029 f.debug_struct("PLU0").finish()
2030 }
2031}
2032#[doc = "Programmable Logic Unit (PLU)"]
2033pub mod plu0;
2034#[doc = "PORT"]
2035pub struct PORT0 {
2036 _marker: PhantomData<*const ()>,
2037}
2038unsafe impl Send for PORT0 {}
2039impl PORT0 {
2040 #[doc = r"Pointer to the register block"]
2041 pub const PTR: *const port0::RegisterBlock = 0x4011_6000 as *const _;
2042 #[doc = r"Return the pointer to the register block"]
2043 #[inline(always)]
2044 pub const fn ptr() -> *const port0::RegisterBlock {
2045 Self::PTR
2046 }
2047 #[doc = r" Steal an instance of this peripheral"]
2048 #[doc = r""]
2049 #[doc = r" # Safety"]
2050 #[doc = r""]
2051 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2052 #[doc = r" that may race with any existing instances, for example by only"]
2053 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2054 #[doc = r" original peripheral and using critical sections to coordinate"]
2055 #[doc = r" access between multiple new instances."]
2056 #[doc = r""]
2057 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2058 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2059 #[doc = r" no stolen instances are passed to such software."]
2060 pub unsafe fn steal() -> Self {
2061 Self {
2062 _marker: PhantomData,
2063 }
2064 }
2065}
2066impl Deref for PORT0 {
2067 type Target = port0::RegisterBlock;
2068 #[inline(always)]
2069 fn deref(&self) -> &Self::Target {
2070 unsafe { &*Self::PTR }
2071 }
2072}
2073impl core::fmt::Debug for PORT0 {
2074 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2075 f.debug_struct("PORT0").finish()
2076 }
2077}
2078#[doc = "PORT"]
2079pub mod port0;
2080#[doc = "PORT"]
2081pub struct PORT5 {
2082 _marker: PhantomData<*const ()>,
2083}
2084unsafe impl Send for PORT5 {}
2085impl PORT5 {
2086 #[doc = r"Pointer to the register block"]
2087 pub const PTR: *const port0::RegisterBlock = 0x4004_2000 as *const _;
2088 #[doc = r"Return the pointer to the register block"]
2089 #[inline(always)]
2090 pub const fn ptr() -> *const port0::RegisterBlock {
2091 Self::PTR
2092 }
2093 #[doc = r" Steal an instance of this peripheral"]
2094 #[doc = r""]
2095 #[doc = r" # Safety"]
2096 #[doc = r""]
2097 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2098 #[doc = r" that may race with any existing instances, for example by only"]
2099 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2100 #[doc = r" original peripheral and using critical sections to coordinate"]
2101 #[doc = r" access between multiple new instances."]
2102 #[doc = r""]
2103 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2104 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2105 #[doc = r" no stolen instances are passed to such software."]
2106 pub unsafe fn steal() -> Self {
2107 Self {
2108 _marker: PhantomData,
2109 }
2110 }
2111}
2112impl Deref for PORT5 {
2113 type Target = port0::RegisterBlock;
2114 #[inline(always)]
2115 fn deref(&self) -> &Self::Target {
2116 unsafe { &*Self::PTR }
2117 }
2118}
2119impl core::fmt::Debug for PORT5 {
2120 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2121 f.debug_struct("PORT5").finish()
2122 }
2123}
2124#[doc = "PORT"]
2125pub use self::port0 as port5;
2126#[doc = "Flash"]
2127pub struct FMU0 {
2128 _marker: PhantomData<*const ()>,
2129}
2130unsafe impl Send for FMU0 {}
2131impl FMU0 {
2132 #[doc = r"Pointer to the register block"]
2133 pub const PTR: *const fmu0::RegisterBlock = 0x4004_3000 as *const _;
2134 #[doc = r"Return the pointer to the register block"]
2135 #[inline(always)]
2136 pub const fn ptr() -> *const fmu0::RegisterBlock {
2137 Self::PTR
2138 }
2139 #[doc = r" Steal an instance of this peripheral"]
2140 #[doc = r""]
2141 #[doc = r" # Safety"]
2142 #[doc = r""]
2143 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2144 #[doc = r" that may race with any existing instances, for example by only"]
2145 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2146 #[doc = r" original peripheral and using critical sections to coordinate"]
2147 #[doc = r" access between multiple new instances."]
2148 #[doc = r""]
2149 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2150 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2151 #[doc = r" no stolen instances are passed to such software."]
2152 pub unsafe fn steal() -> Self {
2153 Self {
2154 _marker: PhantomData,
2155 }
2156 }
2157}
2158impl Deref for FMU0 {
2159 type Target = fmu0::RegisterBlock;
2160 #[inline(always)]
2161 fn deref(&self) -> &Self::Target {
2162 unsafe { &*Self::PTR }
2163 }
2164}
2165impl core::fmt::Debug for FMU0 {
2166 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2167 f.debug_struct("FMU0").finish()
2168 }
2169}
2170#[doc = "Flash"]
2171pub mod fmu0;
2172#[doc = "SCG"]
2173pub struct SCG0 {
2174 _marker: PhantomData<*const ()>,
2175}
2176unsafe impl Send for SCG0 {}
2177impl SCG0 {
2178 #[doc = r"Pointer to the register block"]
2179 pub const PTR: *const scg0::RegisterBlock = 0x4004_4000 as *const _;
2180 #[doc = r"Return the pointer to the register block"]
2181 #[inline(always)]
2182 pub const fn ptr() -> *const scg0::RegisterBlock {
2183 Self::PTR
2184 }
2185 #[doc = r" Steal an instance of this peripheral"]
2186 #[doc = r""]
2187 #[doc = r" # Safety"]
2188 #[doc = r""]
2189 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2190 #[doc = r" that may race with any existing instances, for example by only"]
2191 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2192 #[doc = r" original peripheral and using critical sections to coordinate"]
2193 #[doc = r" access between multiple new instances."]
2194 #[doc = r""]
2195 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2196 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2197 #[doc = r" no stolen instances are passed to such software."]
2198 pub unsafe fn steal() -> Self {
2199 Self {
2200 _marker: PhantomData,
2201 }
2202 }
2203}
2204impl Deref for SCG0 {
2205 type Target = scg0::RegisterBlock;
2206 #[inline(always)]
2207 fn deref(&self) -> &Self::Target {
2208 unsafe { &*Self::PTR }
2209 }
2210}
2211impl core::fmt::Debug for SCG0 {
2212 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2213 f.debug_struct("SCG0").finish()
2214 }
2215}
2216#[doc = "SCG"]
2217pub mod scg0;
2218#[doc = "SPC"]
2219pub struct SPC0 {
2220 _marker: PhantomData<*const ()>,
2221}
2222unsafe impl Send for SPC0 {}
2223impl SPC0 {
2224 #[doc = r"Pointer to the register block"]
2225 pub const PTR: *const spc0::RegisterBlock = 0x4004_5000 as *const _;
2226 #[doc = r"Return the pointer to the register block"]
2227 #[inline(always)]
2228 pub const fn ptr() -> *const spc0::RegisterBlock {
2229 Self::PTR
2230 }
2231 #[doc = r" Steal an instance of this peripheral"]
2232 #[doc = r""]
2233 #[doc = r" # Safety"]
2234 #[doc = r""]
2235 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2236 #[doc = r" that may race with any existing instances, for example by only"]
2237 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2238 #[doc = r" original peripheral and using critical sections to coordinate"]
2239 #[doc = r" access between multiple new instances."]
2240 #[doc = r""]
2241 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2242 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2243 #[doc = r" no stolen instances are passed to such software."]
2244 pub unsafe fn steal() -> Self {
2245 Self {
2246 _marker: PhantomData,
2247 }
2248 }
2249}
2250impl Deref for SPC0 {
2251 type Target = spc0::RegisterBlock;
2252 #[inline(always)]
2253 fn deref(&self) -> &Self::Target {
2254 unsafe { &*Self::PTR }
2255 }
2256}
2257impl core::fmt::Debug for SPC0 {
2258 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2259 f.debug_struct("SPC0").finish()
2260 }
2261}
2262#[doc = "SPC"]
2263pub mod spc0;
2264#[doc = "WUU"]
2265pub struct WUU0 {
2266 _marker: PhantomData<*const ()>,
2267}
2268unsafe impl Send for WUU0 {}
2269impl WUU0 {
2270 #[doc = r"Pointer to the register block"]
2271 pub const PTR: *const wuu0::RegisterBlock = 0x4004_6000 as *const _;
2272 #[doc = r"Return the pointer to the register block"]
2273 #[inline(always)]
2274 pub const fn ptr() -> *const wuu0::RegisterBlock {
2275 Self::PTR
2276 }
2277 #[doc = r" Steal an instance of this peripheral"]
2278 #[doc = r""]
2279 #[doc = r" # Safety"]
2280 #[doc = r""]
2281 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2282 #[doc = r" that may race with any existing instances, for example by only"]
2283 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2284 #[doc = r" original peripheral and using critical sections to coordinate"]
2285 #[doc = r" access between multiple new instances."]
2286 #[doc = r""]
2287 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2288 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2289 #[doc = r" no stolen instances are passed to such software."]
2290 pub unsafe fn steal() -> Self {
2291 Self {
2292 _marker: PhantomData,
2293 }
2294 }
2295}
2296impl Deref for WUU0 {
2297 type Target = wuu0::RegisterBlock;
2298 #[inline(always)]
2299 fn deref(&self) -> &Self::Target {
2300 unsafe { &*Self::PTR }
2301 }
2302}
2303impl core::fmt::Debug for WUU0 {
2304 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2305 f.debug_struct("WUU0").finish()
2306 }
2307}
2308#[doc = "WUU"]
2309pub mod wuu0;
2310#[doc = "CMC"]
2311pub struct CMC0 {
2312 _marker: PhantomData<*const ()>,
2313}
2314unsafe impl Send for CMC0 {}
2315impl CMC0 {
2316 #[doc = r"Pointer to the register block"]
2317 pub const PTR: *const cmc0::RegisterBlock = 0x4004_8000 as *const _;
2318 #[doc = r"Return the pointer to the register block"]
2319 #[inline(always)]
2320 pub const fn ptr() -> *const cmc0::RegisterBlock {
2321 Self::PTR
2322 }
2323 #[doc = r" Steal an instance of this peripheral"]
2324 #[doc = r""]
2325 #[doc = r" # Safety"]
2326 #[doc = r""]
2327 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2328 #[doc = r" that may race with any existing instances, for example by only"]
2329 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2330 #[doc = r" original peripheral and using critical sections to coordinate"]
2331 #[doc = r" access between multiple new instances."]
2332 #[doc = r""]
2333 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2334 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2335 #[doc = r" no stolen instances are passed to such software."]
2336 pub unsafe fn steal() -> Self {
2337 Self {
2338 _marker: PhantomData,
2339 }
2340 }
2341}
2342impl Deref for CMC0 {
2343 type Target = cmc0::RegisterBlock;
2344 #[inline(always)]
2345 fn deref(&self) -> &Self::Target {
2346 unsafe { &*Self::PTR }
2347 }
2348}
2349impl core::fmt::Debug for CMC0 {
2350 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2351 f.debug_struct("CMC0").finish()
2352 }
2353}
2354#[doc = "CMC"]
2355pub mod cmc0;
2356#[doc = "OSTIMER"]
2357pub struct OSTIMER0 {
2358 _marker: PhantomData<*const ()>,
2359}
2360unsafe impl Send for OSTIMER0 {}
2361impl OSTIMER0 {
2362 #[doc = r"Pointer to the register block"]
2363 pub const PTR: *const ostimer0::RegisterBlock = 0x4004_9000 as *const _;
2364 #[doc = r"Return the pointer to the register block"]
2365 #[inline(always)]
2366 pub const fn ptr() -> *const ostimer0::RegisterBlock {
2367 Self::PTR
2368 }
2369 #[doc = r" Steal an instance of this peripheral"]
2370 #[doc = r""]
2371 #[doc = r" # Safety"]
2372 #[doc = r""]
2373 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2374 #[doc = r" that may race with any existing instances, for example by only"]
2375 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2376 #[doc = r" original peripheral and using critical sections to coordinate"]
2377 #[doc = r" access between multiple new instances."]
2378 #[doc = r""]
2379 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2380 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2381 #[doc = r" no stolen instances are passed to such software."]
2382 pub unsafe fn steal() -> Self {
2383 Self {
2384 _marker: PhantomData,
2385 }
2386 }
2387}
2388impl Deref for OSTIMER0 {
2389 type Target = ostimer0::RegisterBlock;
2390 #[inline(always)]
2391 fn deref(&self) -> &Self::Target {
2392 unsafe { &*Self::PTR }
2393 }
2394}
2395impl core::fmt::Debug for OSTIMER0 {
2396 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2397 f.debug_struct("OSTIMER0").finish()
2398 }
2399}
2400#[doc = "OSTIMER"]
2401pub mod ostimer0;
2402#[doc = "LPTMR"]
2403pub struct LPTMR0 {
2404 _marker: PhantomData<*const ()>,
2405}
2406unsafe impl Send for LPTMR0 {}
2407impl LPTMR0 {
2408 #[doc = r"Pointer to the register block"]
2409 pub const PTR: *const lptmr0::RegisterBlock = 0x4004_a000 as *const _;
2410 #[doc = r"Return the pointer to the register block"]
2411 #[inline(always)]
2412 pub const fn ptr() -> *const lptmr0::RegisterBlock {
2413 Self::PTR
2414 }
2415 #[doc = r" Steal an instance of this peripheral"]
2416 #[doc = r""]
2417 #[doc = r" # Safety"]
2418 #[doc = r""]
2419 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2420 #[doc = r" that may race with any existing instances, for example by only"]
2421 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2422 #[doc = r" original peripheral and using critical sections to coordinate"]
2423 #[doc = r" access between multiple new instances."]
2424 #[doc = r""]
2425 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2426 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2427 #[doc = r" no stolen instances are passed to such software."]
2428 pub unsafe fn steal() -> Self {
2429 Self {
2430 _marker: PhantomData,
2431 }
2432 }
2433}
2434impl Deref for LPTMR0 {
2435 type Target = lptmr0::RegisterBlock;
2436 #[inline(always)]
2437 fn deref(&self) -> &Self::Target {
2438 unsafe { &*Self::PTR }
2439 }
2440}
2441impl core::fmt::Debug for LPTMR0 {
2442 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2443 f.debug_struct("LPTMR0").finish()
2444 }
2445}
2446#[doc = "LPTMR"]
2447pub mod lptmr0;
2448#[doc = "LPTMR"]
2449pub struct LPTMR1 {
2450 _marker: PhantomData<*const ()>,
2451}
2452unsafe impl Send for LPTMR1 {}
2453impl LPTMR1 {
2454 #[doc = r"Pointer to the register block"]
2455 pub const PTR: *const lptmr0::RegisterBlock = 0x4004_b000 as *const _;
2456 #[doc = r"Return the pointer to the register block"]
2457 #[inline(always)]
2458 pub const fn ptr() -> *const lptmr0::RegisterBlock {
2459 Self::PTR
2460 }
2461 #[doc = r" Steal an instance of this peripheral"]
2462 #[doc = r""]
2463 #[doc = r" # Safety"]
2464 #[doc = r""]
2465 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2466 #[doc = r" that may race with any existing instances, for example by only"]
2467 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2468 #[doc = r" original peripheral and using critical sections to coordinate"]
2469 #[doc = r" access between multiple new instances."]
2470 #[doc = r""]
2471 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2472 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2473 #[doc = r" no stolen instances are passed to such software."]
2474 pub unsafe fn steal() -> Self {
2475 Self {
2476 _marker: PhantomData,
2477 }
2478 }
2479}
2480impl Deref for LPTMR1 {
2481 type Target = lptmr0::RegisterBlock;
2482 #[inline(always)]
2483 fn deref(&self) -> &Self::Target {
2484 unsafe { &*Self::PTR }
2485 }
2486}
2487impl core::fmt::Debug for LPTMR1 {
2488 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2489 f.debug_struct("LPTMR1").finish()
2490 }
2491}
2492#[doc = "LPTMR"]
2493pub use self::lptmr0 as lptmr1;
2494#[doc = "RTC"]
2495pub struct RTC0 {
2496 _marker: PhantomData<*const ()>,
2497}
2498unsafe impl Send for RTC0 {}
2499impl RTC0 {
2500 #[doc = r"Pointer to the register block"]
2501 pub const PTR: *const rtc0::RegisterBlock = 0x4004_c000 as *const _;
2502 #[doc = r"Return the pointer to the register block"]
2503 #[inline(always)]
2504 pub const fn ptr() -> *const rtc0::RegisterBlock {
2505 Self::PTR
2506 }
2507 #[doc = r" Steal an instance of this peripheral"]
2508 #[doc = r""]
2509 #[doc = r" # Safety"]
2510 #[doc = r""]
2511 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2512 #[doc = r" that may race with any existing instances, for example by only"]
2513 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2514 #[doc = r" original peripheral and using critical sections to coordinate"]
2515 #[doc = r" access between multiple new instances."]
2516 #[doc = r""]
2517 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2518 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2519 #[doc = r" no stolen instances are passed to such software."]
2520 pub unsafe fn steal() -> Self {
2521 Self {
2522 _marker: PhantomData,
2523 }
2524 }
2525}
2526impl Deref for RTC0 {
2527 type Target = rtc0::RegisterBlock;
2528 #[inline(always)]
2529 fn deref(&self) -> &Self::Target {
2530 unsafe { &*Self::PTR }
2531 }
2532}
2533impl core::fmt::Debug for RTC0 {
2534 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2535 f.debug_struct("RTC0").finish()
2536 }
2537}
2538#[doc = "RTC"]
2539pub mod rtc0;
2540#[doc = "RTC_SUBSYSTEM"]
2541pub struct RTC_SUBSYSTEM0 {
2542 _marker: PhantomData<*const ()>,
2543}
2544unsafe impl Send for RTC_SUBSYSTEM0 {}
2545impl RTC_SUBSYSTEM0 {
2546 #[doc = r"Pointer to the register block"]
2547 pub const PTR: *const rtc_subsystem0::RegisterBlock = 0x4004_c000 as *const _;
2548 #[doc = r"Return the pointer to the register block"]
2549 #[inline(always)]
2550 pub const fn ptr() -> *const rtc_subsystem0::RegisterBlock {
2551 Self::PTR
2552 }
2553 #[doc = r" Steal an instance of this peripheral"]
2554 #[doc = r""]
2555 #[doc = r" # Safety"]
2556 #[doc = r""]
2557 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2558 #[doc = r" that may race with any existing instances, for example by only"]
2559 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2560 #[doc = r" original peripheral and using critical sections to coordinate"]
2561 #[doc = r" access between multiple new instances."]
2562 #[doc = r""]
2563 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2564 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2565 #[doc = r" no stolen instances are passed to such software."]
2566 pub unsafe fn steal() -> Self {
2567 Self {
2568 _marker: PhantomData,
2569 }
2570 }
2571}
2572impl Deref for RTC_SUBSYSTEM0 {
2573 type Target = rtc_subsystem0::RegisterBlock;
2574 #[inline(always)]
2575 fn deref(&self) -> &Self::Target {
2576 unsafe { &*Self::PTR }
2577 }
2578}
2579impl core::fmt::Debug for RTC_SUBSYSTEM0 {
2580 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2581 f.debug_struct("RTC_SUBSYSTEM0").finish()
2582 }
2583}
2584#[doc = "RTC_SUBSYSTEM"]
2585pub mod rtc_subsystem0;
2586#[doc = "TSI"]
2587pub struct TSI0 {
2588 _marker: PhantomData<*const ()>,
2589}
2590unsafe impl Send for TSI0 {}
2591impl TSI0 {
2592 #[doc = r"Pointer to the register block"]
2593 pub const PTR: *const tsi0::RegisterBlock = 0x4005_0000 as *const _;
2594 #[doc = r"Return the pointer to the register block"]
2595 #[inline(always)]
2596 pub const fn ptr() -> *const tsi0::RegisterBlock {
2597 Self::PTR
2598 }
2599 #[doc = r" Steal an instance of this peripheral"]
2600 #[doc = r""]
2601 #[doc = r" # Safety"]
2602 #[doc = r""]
2603 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2604 #[doc = r" that may race with any existing instances, for example by only"]
2605 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2606 #[doc = r" original peripheral and using critical sections to coordinate"]
2607 #[doc = r" access between multiple new instances."]
2608 #[doc = r""]
2609 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2610 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2611 #[doc = r" no stolen instances are passed to such software."]
2612 pub unsafe fn steal() -> Self {
2613 Self {
2614 _marker: PhantomData,
2615 }
2616 }
2617}
2618impl Deref for TSI0 {
2619 type Target = tsi0::RegisterBlock;
2620 #[inline(always)]
2621 fn deref(&self) -> &Self::Target {
2622 unsafe { &*Self::PTR }
2623 }
2624}
2625impl core::fmt::Debug for TSI0 {
2626 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2627 f.debug_struct("TSI0").finish()
2628 }
2629}
2630#[doc = "TSI"]
2631pub mod tsi0;
2632#[doc = "LPCMP"]
2633pub struct CMP0 {
2634 _marker: PhantomData<*const ()>,
2635}
2636unsafe impl Send for CMP0 {}
2637impl CMP0 {
2638 #[doc = r"Pointer to the register block"]
2639 pub const PTR: *const cmp0::RegisterBlock = 0x4005_1000 as *const _;
2640 #[doc = r"Return the pointer to the register block"]
2641 #[inline(always)]
2642 pub const fn ptr() -> *const cmp0::RegisterBlock {
2643 Self::PTR
2644 }
2645 #[doc = r" Steal an instance of this peripheral"]
2646 #[doc = r""]
2647 #[doc = r" # Safety"]
2648 #[doc = r""]
2649 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2650 #[doc = r" that may race with any existing instances, for example by only"]
2651 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2652 #[doc = r" original peripheral and using critical sections to coordinate"]
2653 #[doc = r" access between multiple new instances."]
2654 #[doc = r""]
2655 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2656 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2657 #[doc = r" no stolen instances are passed to such software."]
2658 pub unsafe fn steal() -> Self {
2659 Self {
2660 _marker: PhantomData,
2661 }
2662 }
2663}
2664impl Deref for CMP0 {
2665 type Target = cmp0::RegisterBlock;
2666 #[inline(always)]
2667 fn deref(&self) -> &Self::Target {
2668 unsafe { &*Self::PTR }
2669 }
2670}
2671impl core::fmt::Debug for CMP0 {
2672 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2673 f.debug_struct("CMP0").finish()
2674 }
2675}
2676#[doc = "LPCMP"]
2677pub mod cmp0;
2678#[doc = "LPCMP"]
2679pub struct CMP1 {
2680 _marker: PhantomData<*const ()>,
2681}
2682unsafe impl Send for CMP1 {}
2683impl CMP1 {
2684 #[doc = r"Pointer to the register block"]
2685 pub const PTR: *const cmp0::RegisterBlock = 0x4005_2000 as *const _;
2686 #[doc = r"Return the pointer to the register block"]
2687 #[inline(always)]
2688 pub const fn ptr() -> *const cmp0::RegisterBlock {
2689 Self::PTR
2690 }
2691 #[doc = r" Steal an instance of this peripheral"]
2692 #[doc = r""]
2693 #[doc = r" # Safety"]
2694 #[doc = r""]
2695 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2696 #[doc = r" that may race with any existing instances, for example by only"]
2697 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2698 #[doc = r" original peripheral and using critical sections to coordinate"]
2699 #[doc = r" access between multiple new instances."]
2700 #[doc = r""]
2701 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2702 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2703 #[doc = r" no stolen instances are passed to such software."]
2704 pub unsafe fn steal() -> Self {
2705 Self {
2706 _marker: PhantomData,
2707 }
2708 }
2709}
2710impl Deref for CMP1 {
2711 type Target = cmp0::RegisterBlock;
2712 #[inline(always)]
2713 fn deref(&self) -> &Self::Target {
2714 unsafe { &*Self::PTR }
2715 }
2716}
2717impl core::fmt::Debug for CMP1 {
2718 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2719 f.debug_struct("CMP1").finish()
2720 }
2721}
2722#[doc = "LPCMP"]
2723pub use self::cmp0 as cmp1;
2724#[doc = "LPCMP"]
2725pub struct CMP2 {
2726 _marker: PhantomData<*const ()>,
2727}
2728unsafe impl Send for CMP2 {}
2729impl CMP2 {
2730 #[doc = r"Pointer to the register block"]
2731 pub const PTR: *const cmp0::RegisterBlock = 0x4005_3000 as *const _;
2732 #[doc = r"Return the pointer to the register block"]
2733 #[inline(always)]
2734 pub const fn ptr() -> *const cmp0::RegisterBlock {
2735 Self::PTR
2736 }
2737 #[doc = r" Steal an instance of this peripheral"]
2738 #[doc = r""]
2739 #[doc = r" # Safety"]
2740 #[doc = r""]
2741 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2742 #[doc = r" that may race with any existing instances, for example by only"]
2743 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2744 #[doc = r" original peripheral and using critical sections to coordinate"]
2745 #[doc = r" access between multiple new instances."]
2746 #[doc = r""]
2747 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2748 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2749 #[doc = r" no stolen instances are passed to such software."]
2750 pub unsafe fn steal() -> Self {
2751 Self {
2752 _marker: PhantomData,
2753 }
2754 }
2755}
2756impl Deref for CMP2 {
2757 type Target = cmp0::RegisterBlock;
2758 #[inline(always)]
2759 fn deref(&self) -> &Self::Target {
2760 unsafe { &*Self::PTR }
2761 }
2762}
2763impl core::fmt::Debug for CMP2 {
2764 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2765 f.debug_struct("CMP2").finish()
2766 }
2767}
2768#[doc = "LPCMP"]
2769pub use self::cmp0 as cmp2;
2770#[doc = "no description available"]
2771pub struct ELS {
2772 _marker: PhantomData<*const ()>,
2773}
2774unsafe impl Send for ELS {}
2775impl ELS {
2776 #[doc = r"Pointer to the register block"]
2777 pub const PTR: *const els::RegisterBlock = 0x4005_4000 as *const _;
2778 #[doc = r"Return the pointer to the register block"]
2779 #[inline(always)]
2780 pub const fn ptr() -> *const els::RegisterBlock {
2781 Self::PTR
2782 }
2783 #[doc = r" Steal an instance of this peripheral"]
2784 #[doc = r""]
2785 #[doc = r" # Safety"]
2786 #[doc = r""]
2787 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2788 #[doc = r" that may race with any existing instances, for example by only"]
2789 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2790 #[doc = r" original peripheral and using critical sections to coordinate"]
2791 #[doc = r" access between multiple new instances."]
2792 #[doc = r""]
2793 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2794 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2795 #[doc = r" no stolen instances are passed to such software."]
2796 pub unsafe fn steal() -> Self {
2797 Self {
2798 _marker: PhantomData,
2799 }
2800 }
2801}
2802impl Deref for ELS {
2803 type Target = els::RegisterBlock;
2804 #[inline(always)]
2805 fn deref(&self) -> &Self::Target {
2806 unsafe { &*Self::PTR }
2807 }
2808}
2809impl core::fmt::Debug for ELS {
2810 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2811 f.debug_struct("ELS").finish()
2812 }
2813}
2814#[doc = "no description available"]
2815pub mod els;
2816#[doc = "TDET"]
2817pub struct TDET0 {
2818 _marker: PhantomData<*const ()>,
2819}
2820unsafe impl Send for TDET0 {}
2821impl TDET0 {
2822 #[doc = r"Pointer to the register block"]
2823 pub const PTR: *const tdet0::RegisterBlock = 0x4005_8000 as *const _;
2824 #[doc = r"Return the pointer to the register block"]
2825 #[inline(always)]
2826 pub const fn ptr() -> *const tdet0::RegisterBlock {
2827 Self::PTR
2828 }
2829 #[doc = r" Steal an instance of this peripheral"]
2830 #[doc = r""]
2831 #[doc = r" # Safety"]
2832 #[doc = r""]
2833 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2834 #[doc = r" that may race with any existing instances, for example by only"]
2835 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2836 #[doc = r" original peripheral and using critical sections to coordinate"]
2837 #[doc = r" access between multiple new instances."]
2838 #[doc = r""]
2839 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2840 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2841 #[doc = r" no stolen instances are passed to such software."]
2842 pub unsafe fn steal() -> Self {
2843 Self {
2844 _marker: PhantomData,
2845 }
2846 }
2847}
2848impl Deref for TDET0 {
2849 type Target = tdet0::RegisterBlock;
2850 #[inline(always)]
2851 fn deref(&self) -> &Self::Target {
2852 unsafe { &*Self::PTR }
2853 }
2854}
2855impl core::fmt::Debug for TDET0 {
2856 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2857 f.debug_struct("TDET0").finish()
2858 }
2859}
2860#[doc = "TDET"]
2861pub mod tdet0;
2862#[doc = "VBAT"]
2863pub struct VBAT0 {
2864 _marker: PhantomData<*const ()>,
2865}
2866unsafe impl Send for VBAT0 {}
2867impl VBAT0 {
2868 #[doc = r"Pointer to the register block"]
2869 pub const PTR: *const vbat0::RegisterBlock = 0x4005_9000 as *const _;
2870 #[doc = r"Return the pointer to the register block"]
2871 #[inline(always)]
2872 pub const fn ptr() -> *const vbat0::RegisterBlock {
2873 Self::PTR
2874 }
2875 #[doc = r" Steal an instance of this peripheral"]
2876 #[doc = r""]
2877 #[doc = r" # Safety"]
2878 #[doc = r""]
2879 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2880 #[doc = r" that may race with any existing instances, for example by only"]
2881 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2882 #[doc = r" original peripheral and using critical sections to coordinate"]
2883 #[doc = r" access between multiple new instances."]
2884 #[doc = r""]
2885 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2886 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2887 #[doc = r" no stolen instances are passed to such software."]
2888 pub unsafe fn steal() -> Self {
2889 Self {
2890 _marker: PhantomData,
2891 }
2892 }
2893}
2894impl Deref for VBAT0 {
2895 type Target = vbat0::RegisterBlock;
2896 #[inline(always)]
2897 fn deref(&self) -> &Self::Target {
2898 unsafe { &*Self::PTR }
2899 }
2900}
2901impl core::fmt::Debug for VBAT0 {
2902 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2903 f.debug_struct("VBAT0").finish()
2904 }
2905}
2906#[doc = "VBAT"]
2907pub mod vbat0;
2908#[doc = "TRNG0"]
2909pub struct TRNG0 {
2910 _marker: PhantomData<*const ()>,
2911}
2912unsafe impl Send for TRNG0 {}
2913impl TRNG0 {
2914 #[doc = r"Pointer to the register block"]
2915 pub const PTR: *const trng0::RegisterBlock = 0x4005_a000 as *const _;
2916 #[doc = r"Return the pointer to the register block"]
2917 #[inline(always)]
2918 pub const fn ptr() -> *const trng0::RegisterBlock {
2919 Self::PTR
2920 }
2921 #[doc = r" Steal an instance of this peripheral"]
2922 #[doc = r""]
2923 #[doc = r" # Safety"]
2924 #[doc = r""]
2925 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2926 #[doc = r" that may race with any existing instances, for example by only"]
2927 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2928 #[doc = r" original peripheral and using critical sections to coordinate"]
2929 #[doc = r" access between multiple new instances."]
2930 #[doc = r""]
2931 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2932 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2933 #[doc = r" no stolen instances are passed to such software."]
2934 pub unsafe fn steal() -> Self {
2935 Self {
2936 _marker: PhantomData,
2937 }
2938 }
2939}
2940impl Deref for TRNG0 {
2941 type Target = trng0::RegisterBlock;
2942 #[inline(always)]
2943 fn deref(&self) -> &Self::Target {
2944 unsafe { &*Self::PTR }
2945 }
2946}
2947impl core::fmt::Debug for TRNG0 {
2948 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2949 f.debug_struct("TRNG0").finish()
2950 }
2951}
2952#[doc = "TRNG0"]
2953pub mod trng0;
2954#[doc = "EIM"]
2955pub struct EIM0 {
2956 _marker: PhantomData<*const ()>,
2957}
2958unsafe impl Send for EIM0 {}
2959impl EIM0 {
2960 #[doc = r"Pointer to the register block"]
2961 pub const PTR: *const eim0::RegisterBlock = 0x4005_b000 as *const _;
2962 #[doc = r"Return the pointer to the register block"]
2963 #[inline(always)]
2964 pub const fn ptr() -> *const eim0::RegisterBlock {
2965 Self::PTR
2966 }
2967 #[doc = r" Steal an instance of this peripheral"]
2968 #[doc = r""]
2969 #[doc = r" # Safety"]
2970 #[doc = r""]
2971 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2972 #[doc = r" that may race with any existing instances, for example by only"]
2973 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2974 #[doc = r" original peripheral and using critical sections to coordinate"]
2975 #[doc = r" access between multiple new instances."]
2976 #[doc = r""]
2977 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2978 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2979 #[doc = r" no stolen instances are passed to such software."]
2980 pub unsafe fn steal() -> Self {
2981 Self {
2982 _marker: PhantomData,
2983 }
2984 }
2985}
2986impl Deref for EIM0 {
2987 type Target = eim0::RegisterBlock;
2988 #[inline(always)]
2989 fn deref(&self) -> &Self::Target {
2990 unsafe { &*Self::PTR }
2991 }
2992}
2993impl core::fmt::Debug for EIM0 {
2994 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2995 f.debug_struct("EIM0").finish()
2996 }
2997}
2998#[doc = "EIM"]
2999pub mod eim0;
3000#[doc = "ERM"]
3001pub struct ERM0 {
3002 _marker: PhantomData<*const ()>,
3003}
3004unsafe impl Send for ERM0 {}
3005impl ERM0 {
3006 #[doc = r"Pointer to the register block"]
3007 pub const PTR: *const erm0::RegisterBlock = 0x4005_c000 as *const _;
3008 #[doc = r"Return the pointer to the register block"]
3009 #[inline(always)]
3010 pub const fn ptr() -> *const erm0::RegisterBlock {
3011 Self::PTR
3012 }
3013 #[doc = r" Steal an instance of this peripheral"]
3014 #[doc = r""]
3015 #[doc = r" # Safety"]
3016 #[doc = r""]
3017 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3018 #[doc = r" that may race with any existing instances, for example by only"]
3019 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3020 #[doc = r" original peripheral and using critical sections to coordinate"]
3021 #[doc = r" access between multiple new instances."]
3022 #[doc = r""]
3023 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3024 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3025 #[doc = r" no stolen instances are passed to such software."]
3026 pub unsafe fn steal() -> Self {
3027 Self {
3028 _marker: PhantomData,
3029 }
3030 }
3031}
3032impl Deref for ERM0 {
3033 type Target = erm0::RegisterBlock;
3034 #[inline(always)]
3035 fn deref(&self) -> &Self::Target {
3036 unsafe { &*Self::PTR }
3037 }
3038}
3039impl core::fmt::Debug for ERM0 {
3040 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3041 f.debug_struct("ERM0").finish()
3042 }
3043}
3044#[doc = "ERM"]
3045pub mod erm0;
3046#[doc = "INTM"]
3047pub struct INTM0 {
3048 _marker: PhantomData<*const ()>,
3049}
3050unsafe impl Send for INTM0 {}
3051impl INTM0 {
3052 #[doc = r"Pointer to the register block"]
3053 pub const PTR: *const intm0::RegisterBlock = 0x4005_d000 as *const _;
3054 #[doc = r"Return the pointer to the register block"]
3055 #[inline(always)]
3056 pub const fn ptr() -> *const intm0::RegisterBlock {
3057 Self::PTR
3058 }
3059 #[doc = r" Steal an instance of this peripheral"]
3060 #[doc = r""]
3061 #[doc = r" # Safety"]
3062 #[doc = r""]
3063 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3064 #[doc = r" that may race with any existing instances, for example by only"]
3065 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3066 #[doc = r" original peripheral and using critical sections to coordinate"]
3067 #[doc = r" access between multiple new instances."]
3068 #[doc = r""]
3069 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3070 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3071 #[doc = r" no stolen instances are passed to such software."]
3072 pub unsafe fn steal() -> Self {
3073 Self {
3074 _marker: PhantomData,
3075 }
3076 }
3077}
3078impl Deref for INTM0 {
3079 type Target = intm0::RegisterBlock;
3080 #[inline(always)]
3081 fn deref(&self) -> &Self::Target {
3082 unsafe { &*Self::PTR }
3083 }
3084}
3085impl core::fmt::Debug for INTM0 {
3086 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3087 f.debug_struct("INTM0").finish()
3088 }
3089}
3090#[doc = "INTM"]
3091pub mod intm0;
3092#[doc = "DMA MP"]
3093pub struct DMA0 {
3094 _marker: PhantomData<*const ()>,
3095}
3096unsafe impl Send for DMA0 {}
3097impl DMA0 {
3098 #[doc = r"Pointer to the register block"]
3099 pub const PTR: *const dma0::RegisterBlock = 0x4008_0000 as *const _;
3100 #[doc = r"Return the pointer to the register block"]
3101 #[inline(always)]
3102 pub const fn ptr() -> *const dma0::RegisterBlock {
3103 Self::PTR
3104 }
3105 #[doc = r" Steal an instance of this peripheral"]
3106 #[doc = r""]
3107 #[doc = r" # Safety"]
3108 #[doc = r""]
3109 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3110 #[doc = r" that may race with any existing instances, for example by only"]
3111 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3112 #[doc = r" original peripheral and using critical sections to coordinate"]
3113 #[doc = r" access between multiple new instances."]
3114 #[doc = r""]
3115 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3116 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3117 #[doc = r" no stolen instances are passed to such software."]
3118 pub unsafe fn steal() -> Self {
3119 Self {
3120 _marker: PhantomData,
3121 }
3122 }
3123}
3124impl Deref for DMA0 {
3125 type Target = dma0::RegisterBlock;
3126 #[inline(always)]
3127 fn deref(&self) -> &Self::Target {
3128 unsafe { &*Self::PTR }
3129 }
3130}
3131impl core::fmt::Debug for DMA0 {
3132 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3133 f.debug_struct("DMA0").finish()
3134 }
3135}
3136#[doc = "DMA MP"]
3137pub mod dma0;
3138#[doc = "DMA MP"]
3139pub struct DMA1 {
3140 _marker: PhantomData<*const ()>,
3141}
3142unsafe impl Send for DMA1 {}
3143impl DMA1 {
3144 #[doc = r"Pointer to the register block"]
3145 pub const PTR: *const dma0::RegisterBlock = 0x400a_0000 as *const _;
3146 #[doc = r"Return the pointer to the register block"]
3147 #[inline(always)]
3148 pub const fn ptr() -> *const dma0::RegisterBlock {
3149 Self::PTR
3150 }
3151 #[doc = r" Steal an instance of this peripheral"]
3152 #[doc = r""]
3153 #[doc = r" # Safety"]
3154 #[doc = r""]
3155 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3156 #[doc = r" that may race with any existing instances, for example by only"]
3157 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3158 #[doc = r" original peripheral and using critical sections to coordinate"]
3159 #[doc = r" access between multiple new instances."]
3160 #[doc = r""]
3161 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3162 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3163 #[doc = r" no stolen instances are passed to such software."]
3164 pub unsafe fn steal() -> Self {
3165 Self {
3166 _marker: PhantomData,
3167 }
3168 }
3169}
3170impl Deref for DMA1 {
3171 type Target = dma0::RegisterBlock;
3172 #[inline(always)]
3173 fn deref(&self) -> &Self::Target {
3174 unsafe { &*Self::PTR }
3175 }
3176}
3177impl core::fmt::Debug for DMA1 {
3178 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3179 f.debug_struct("DMA1").finish()
3180 }
3181}
3182#[doc = "DMA MP"]
3183pub use self::dma0 as dma1;
3184#[doc = "DMA TCD"]
3185pub struct EDMA_0_TCD {
3186 _marker: PhantomData<*const ()>,
3187}
3188unsafe impl Send for EDMA_0_TCD {}
3189impl EDMA_0_TCD {
3190 #[doc = r"Pointer to the register block"]
3191 pub const PTR: *const edma_0_tcd::RegisterBlock = 0x4008_1000 as *const _;
3192 #[doc = r"Return the pointer to the register block"]
3193 #[inline(always)]
3194 pub const fn ptr() -> *const edma_0_tcd::RegisterBlock {
3195 Self::PTR
3196 }
3197 #[doc = r" Steal an instance of this peripheral"]
3198 #[doc = r""]
3199 #[doc = r" # Safety"]
3200 #[doc = r""]
3201 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3202 #[doc = r" that may race with any existing instances, for example by only"]
3203 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3204 #[doc = r" original peripheral and using critical sections to coordinate"]
3205 #[doc = r" access between multiple new instances."]
3206 #[doc = r""]
3207 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3208 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3209 #[doc = r" no stolen instances are passed to such software."]
3210 pub unsafe fn steal() -> Self {
3211 Self {
3212 _marker: PhantomData,
3213 }
3214 }
3215}
3216impl Deref for EDMA_0_TCD {
3217 type Target = edma_0_tcd::RegisterBlock;
3218 #[inline(always)]
3219 fn deref(&self) -> &Self::Target {
3220 unsafe { &*Self::PTR }
3221 }
3222}
3223impl core::fmt::Debug for EDMA_0_TCD {
3224 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3225 f.debug_struct("EDMA_0_TCD").finish()
3226 }
3227}
3228#[doc = "DMA TCD"]
3229pub mod edma_0_tcd;
3230#[doc = "SCT"]
3231pub struct SCT0 {
3232 _marker: PhantomData<*const ()>,
3233}
3234unsafe impl Send for SCT0 {}
3235impl SCT0 {
3236 #[doc = r"Pointer to the register block"]
3237 pub const PTR: *const sct0::RegisterBlock = 0x4009_1000 as *const _;
3238 #[doc = r"Return the pointer to the register block"]
3239 #[inline(always)]
3240 pub const fn ptr() -> *const sct0::RegisterBlock {
3241 Self::PTR
3242 }
3243 #[doc = r" Steal an instance of this peripheral"]
3244 #[doc = r""]
3245 #[doc = r" # Safety"]
3246 #[doc = r""]
3247 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3248 #[doc = r" that may race with any existing instances, for example by only"]
3249 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3250 #[doc = r" original peripheral and using critical sections to coordinate"]
3251 #[doc = r" access between multiple new instances."]
3252 #[doc = r""]
3253 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3254 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3255 #[doc = r" no stolen instances are passed to such software."]
3256 pub unsafe fn steal() -> Self {
3257 Self {
3258 _marker: PhantomData,
3259 }
3260 }
3261}
3262impl Deref for SCT0 {
3263 type Target = sct0::RegisterBlock;
3264 #[inline(always)]
3265 fn deref(&self) -> &Self::Target {
3266 unsafe { &*Self::PTR }
3267 }
3268}
3269impl core::fmt::Debug for SCT0 {
3270 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3271 f.debug_struct("SCT0").finish()
3272 }
3273}
3274#[doc = "SCT"]
3275pub mod sct0;
3276#[doc = "LPSPI"]
3277pub struct LPSPI0 {
3278 _marker: PhantomData<*const ()>,
3279}
3280unsafe impl Send for LPSPI0 {}
3281impl LPSPI0 {
3282 #[doc = r"Pointer to the register block"]
3283 pub const PTR: *const lpspi0::RegisterBlock = 0x4009_2000 as *const _;
3284 #[doc = r"Return the pointer to the register block"]
3285 #[inline(always)]
3286 pub const fn ptr() -> *const lpspi0::RegisterBlock {
3287 Self::PTR
3288 }
3289 #[doc = r" Steal an instance of this peripheral"]
3290 #[doc = r""]
3291 #[doc = r" # Safety"]
3292 #[doc = r""]
3293 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3294 #[doc = r" that may race with any existing instances, for example by only"]
3295 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3296 #[doc = r" original peripheral and using critical sections to coordinate"]
3297 #[doc = r" access between multiple new instances."]
3298 #[doc = r""]
3299 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3300 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3301 #[doc = r" no stolen instances are passed to such software."]
3302 pub unsafe fn steal() -> Self {
3303 Self {
3304 _marker: PhantomData,
3305 }
3306 }
3307}
3308impl Deref for LPSPI0 {
3309 type Target = lpspi0::RegisterBlock;
3310 #[inline(always)]
3311 fn deref(&self) -> &Self::Target {
3312 unsafe { &*Self::PTR }
3313 }
3314}
3315impl core::fmt::Debug for LPSPI0 {
3316 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3317 f.debug_struct("LPSPI0").finish()
3318 }
3319}
3320#[doc = "LPSPI"]
3321pub mod lpspi0;
3322#[doc = "LPSPI"]
3323pub struct LPSPI1 {
3324 _marker: PhantomData<*const ()>,
3325}
3326unsafe impl Send for LPSPI1 {}
3327impl LPSPI1 {
3328 #[doc = r"Pointer to the register block"]
3329 pub const PTR: *const lpspi0::RegisterBlock = 0x4009_3000 as *const _;
3330 #[doc = r"Return the pointer to the register block"]
3331 #[inline(always)]
3332 pub const fn ptr() -> *const lpspi0::RegisterBlock {
3333 Self::PTR
3334 }
3335 #[doc = r" Steal an instance of this peripheral"]
3336 #[doc = r""]
3337 #[doc = r" # Safety"]
3338 #[doc = r""]
3339 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3340 #[doc = r" that may race with any existing instances, for example by only"]
3341 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3342 #[doc = r" original peripheral and using critical sections to coordinate"]
3343 #[doc = r" access between multiple new instances."]
3344 #[doc = r""]
3345 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3346 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3347 #[doc = r" no stolen instances are passed to such software."]
3348 pub unsafe fn steal() -> Self {
3349 Self {
3350 _marker: PhantomData,
3351 }
3352 }
3353}
3354impl Deref for LPSPI1 {
3355 type Target = lpspi0::RegisterBlock;
3356 #[inline(always)]
3357 fn deref(&self) -> &Self::Target {
3358 unsafe { &*Self::PTR }
3359 }
3360}
3361impl core::fmt::Debug for LPSPI1 {
3362 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3363 f.debug_struct("LPSPI1").finish()
3364 }
3365}
3366#[doc = "LPSPI"]
3367pub use self::lpspi0 as lpspi1;
3368#[doc = "LPSPI"]
3369pub struct LPSPI2 {
3370 _marker: PhantomData<*const ()>,
3371}
3372unsafe impl Send for LPSPI2 {}
3373impl LPSPI2 {
3374 #[doc = r"Pointer to the register block"]
3375 pub const PTR: *const lpspi0::RegisterBlock = 0x4009_4000 as *const _;
3376 #[doc = r"Return the pointer to the register block"]
3377 #[inline(always)]
3378 pub const fn ptr() -> *const lpspi0::RegisterBlock {
3379 Self::PTR
3380 }
3381 #[doc = r" Steal an instance of this peripheral"]
3382 #[doc = r""]
3383 #[doc = r" # Safety"]
3384 #[doc = r""]
3385 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3386 #[doc = r" that may race with any existing instances, for example by only"]
3387 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3388 #[doc = r" original peripheral and using critical sections to coordinate"]
3389 #[doc = r" access between multiple new instances."]
3390 #[doc = r""]
3391 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3392 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3393 #[doc = r" no stolen instances are passed to such software."]
3394 pub unsafe fn steal() -> Self {
3395 Self {
3396 _marker: PhantomData,
3397 }
3398 }
3399}
3400impl Deref for LPSPI2 {
3401 type Target = lpspi0::RegisterBlock;
3402 #[inline(always)]
3403 fn deref(&self) -> &Self::Target {
3404 unsafe { &*Self::PTR }
3405 }
3406}
3407impl core::fmt::Debug for LPSPI2 {
3408 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3409 f.debug_struct("LPSPI2").finish()
3410 }
3411}
3412#[doc = "LPSPI"]
3413pub use self::lpspi0 as lpspi2;
3414#[doc = "LPSPI"]
3415pub struct LPSPI3 {
3416 _marker: PhantomData<*const ()>,
3417}
3418unsafe impl Send for LPSPI3 {}
3419impl LPSPI3 {
3420 #[doc = r"Pointer to the register block"]
3421 pub const PTR: *const lpspi0::RegisterBlock = 0x4009_5000 as *const _;
3422 #[doc = r"Return the pointer to the register block"]
3423 #[inline(always)]
3424 pub const fn ptr() -> *const lpspi0::RegisterBlock {
3425 Self::PTR
3426 }
3427 #[doc = r" Steal an instance of this peripheral"]
3428 #[doc = r""]
3429 #[doc = r" # Safety"]
3430 #[doc = r""]
3431 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3432 #[doc = r" that may race with any existing instances, for example by only"]
3433 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3434 #[doc = r" original peripheral and using critical sections to coordinate"]
3435 #[doc = r" access between multiple new instances."]
3436 #[doc = r""]
3437 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3438 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3439 #[doc = r" no stolen instances are passed to such software."]
3440 pub unsafe fn steal() -> Self {
3441 Self {
3442 _marker: PhantomData,
3443 }
3444 }
3445}
3446impl Deref for LPSPI3 {
3447 type Target = lpspi0::RegisterBlock;
3448 #[inline(always)]
3449 fn deref(&self) -> &Self::Target {
3450 unsafe { &*Self::PTR }
3451 }
3452}
3453impl core::fmt::Debug for LPSPI3 {
3454 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3455 f.debug_struct("LPSPI3").finish()
3456 }
3457}
3458#[doc = "LPSPI"]
3459pub use self::lpspi0 as lpspi3;
3460#[doc = "LPSPI"]
3461pub struct LPSPI4 {
3462 _marker: PhantomData<*const ()>,
3463}
3464unsafe impl Send for LPSPI4 {}
3465impl LPSPI4 {
3466 #[doc = r"Pointer to the register block"]
3467 pub const PTR: *const lpspi0::RegisterBlock = 0x400b_4000 as *const _;
3468 #[doc = r"Return the pointer to the register block"]
3469 #[inline(always)]
3470 pub const fn ptr() -> *const lpspi0::RegisterBlock {
3471 Self::PTR
3472 }
3473 #[doc = r" Steal an instance of this peripheral"]
3474 #[doc = r""]
3475 #[doc = r" # Safety"]
3476 #[doc = r""]
3477 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3478 #[doc = r" that may race with any existing instances, for example by only"]
3479 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3480 #[doc = r" original peripheral and using critical sections to coordinate"]
3481 #[doc = r" access between multiple new instances."]
3482 #[doc = r""]
3483 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3484 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3485 #[doc = r" no stolen instances are passed to such software."]
3486 pub unsafe fn steal() -> Self {
3487 Self {
3488 _marker: PhantomData,
3489 }
3490 }
3491}
3492impl Deref for LPSPI4 {
3493 type Target = lpspi0::RegisterBlock;
3494 #[inline(always)]
3495 fn deref(&self) -> &Self::Target {
3496 unsafe { &*Self::PTR }
3497 }
3498}
3499impl core::fmt::Debug for LPSPI4 {
3500 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3501 f.debug_struct("LPSPI4").finish()
3502 }
3503}
3504#[doc = "LPSPI"]
3505pub use self::lpspi0 as lpspi4;
3506#[doc = "LPSPI"]
3507pub struct LPSPI5 {
3508 _marker: PhantomData<*const ()>,
3509}
3510unsafe impl Send for LPSPI5 {}
3511impl LPSPI5 {
3512 #[doc = r"Pointer to the register block"]
3513 pub const PTR: *const lpspi0::RegisterBlock = 0x400b_5000 as *const _;
3514 #[doc = r"Return the pointer to the register block"]
3515 #[inline(always)]
3516 pub const fn ptr() -> *const lpspi0::RegisterBlock {
3517 Self::PTR
3518 }
3519 #[doc = r" Steal an instance of this peripheral"]
3520 #[doc = r""]
3521 #[doc = r" # Safety"]
3522 #[doc = r""]
3523 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3524 #[doc = r" that may race with any existing instances, for example by only"]
3525 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3526 #[doc = r" original peripheral and using critical sections to coordinate"]
3527 #[doc = r" access between multiple new instances."]
3528 #[doc = r""]
3529 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3530 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3531 #[doc = r" no stolen instances are passed to such software."]
3532 pub unsafe fn steal() -> Self {
3533 Self {
3534 _marker: PhantomData,
3535 }
3536 }
3537}
3538impl Deref for LPSPI5 {
3539 type Target = lpspi0::RegisterBlock;
3540 #[inline(always)]
3541 fn deref(&self) -> &Self::Target {
3542 unsafe { &*Self::PTR }
3543 }
3544}
3545impl core::fmt::Debug for LPSPI5 {
3546 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3547 f.debug_struct("LPSPI5").finish()
3548 }
3549}
3550#[doc = "LPSPI"]
3551pub use self::lpspi0 as lpspi5;
3552#[doc = "LPSPI"]
3553pub struct LPSPI6 {
3554 _marker: PhantomData<*const ()>,
3555}
3556unsafe impl Send for LPSPI6 {}
3557impl LPSPI6 {
3558 #[doc = r"Pointer to the register block"]
3559 pub const PTR: *const lpspi0::RegisterBlock = 0x400b_6000 as *const _;
3560 #[doc = r"Return the pointer to the register block"]
3561 #[inline(always)]
3562 pub const fn ptr() -> *const lpspi0::RegisterBlock {
3563 Self::PTR
3564 }
3565 #[doc = r" Steal an instance of this peripheral"]
3566 #[doc = r""]
3567 #[doc = r" # Safety"]
3568 #[doc = r""]
3569 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3570 #[doc = r" that may race with any existing instances, for example by only"]
3571 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3572 #[doc = r" original peripheral and using critical sections to coordinate"]
3573 #[doc = r" access between multiple new instances."]
3574 #[doc = r""]
3575 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3576 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3577 #[doc = r" no stolen instances are passed to such software."]
3578 pub unsafe fn steal() -> Self {
3579 Self {
3580 _marker: PhantomData,
3581 }
3582 }
3583}
3584impl Deref for LPSPI6 {
3585 type Target = lpspi0::RegisterBlock;
3586 #[inline(always)]
3587 fn deref(&self) -> &Self::Target {
3588 unsafe { &*Self::PTR }
3589 }
3590}
3591impl core::fmt::Debug for LPSPI6 {
3592 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3593 f.debug_struct("LPSPI6").finish()
3594 }
3595}
3596#[doc = "LPSPI"]
3597pub use self::lpspi0 as lpspi6;
3598#[doc = "LPSPI"]
3599pub struct LPSPI7 {
3600 _marker: PhantomData<*const ()>,
3601}
3602unsafe impl Send for LPSPI7 {}
3603impl LPSPI7 {
3604 #[doc = r"Pointer to the register block"]
3605 pub const PTR: *const lpspi0::RegisterBlock = 0x400b_7000 as *const _;
3606 #[doc = r"Return the pointer to the register block"]
3607 #[inline(always)]
3608 pub const fn ptr() -> *const lpspi0::RegisterBlock {
3609 Self::PTR
3610 }
3611 #[doc = r" Steal an instance of this peripheral"]
3612 #[doc = r""]
3613 #[doc = r" # Safety"]
3614 #[doc = r""]
3615 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3616 #[doc = r" that may race with any existing instances, for example by only"]
3617 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3618 #[doc = r" original peripheral and using critical sections to coordinate"]
3619 #[doc = r" access between multiple new instances."]
3620 #[doc = r""]
3621 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3622 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3623 #[doc = r" no stolen instances are passed to such software."]
3624 pub unsafe fn steal() -> Self {
3625 Self {
3626 _marker: PhantomData,
3627 }
3628 }
3629}
3630impl Deref for LPSPI7 {
3631 type Target = lpspi0::RegisterBlock;
3632 #[inline(always)]
3633 fn deref(&self) -> &Self::Target {
3634 unsafe { &*Self::PTR }
3635 }
3636}
3637impl core::fmt::Debug for LPSPI7 {
3638 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3639 f.debug_struct("LPSPI7").finish()
3640 }
3641}
3642#[doc = "LPSPI"]
3643pub use self::lpspi0 as lpspi7;
3644#[doc = "LPSPI"]
3645pub struct LPSPI8 {
3646 _marker: PhantomData<*const ()>,
3647}
3648unsafe impl Send for LPSPI8 {}
3649impl LPSPI8 {
3650 #[doc = r"Pointer to the register block"]
3651 pub const PTR: *const lpspi0::RegisterBlock = 0x400b_8000 as *const _;
3652 #[doc = r"Return the pointer to the register block"]
3653 #[inline(always)]
3654 pub const fn ptr() -> *const lpspi0::RegisterBlock {
3655 Self::PTR
3656 }
3657 #[doc = r" Steal an instance of this peripheral"]
3658 #[doc = r""]
3659 #[doc = r" # Safety"]
3660 #[doc = r""]
3661 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3662 #[doc = r" that may race with any existing instances, for example by only"]
3663 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3664 #[doc = r" original peripheral and using critical sections to coordinate"]
3665 #[doc = r" access between multiple new instances."]
3666 #[doc = r""]
3667 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3668 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3669 #[doc = r" no stolen instances are passed to such software."]
3670 pub unsafe fn steal() -> Self {
3671 Self {
3672 _marker: PhantomData,
3673 }
3674 }
3675}
3676impl Deref for LPSPI8 {
3677 type Target = lpspi0::RegisterBlock;
3678 #[inline(always)]
3679 fn deref(&self) -> &Self::Target {
3680 unsafe { &*Self::PTR }
3681 }
3682}
3683impl core::fmt::Debug for LPSPI8 {
3684 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3685 f.debug_struct("LPSPI8").finish()
3686 }
3687}
3688#[doc = "LPSPI"]
3689pub use self::lpspi0 as lpspi8;
3690#[doc = "LPSPI"]
3691pub struct LPSPI9 {
3692 _marker: PhantomData<*const ()>,
3693}
3694unsafe impl Send for LPSPI9 {}
3695impl LPSPI9 {
3696 #[doc = r"Pointer to the register block"]
3697 pub const PTR: *const lpspi0::RegisterBlock = 0x400b_9000 as *const _;
3698 #[doc = r"Return the pointer to the register block"]
3699 #[inline(always)]
3700 pub const fn ptr() -> *const lpspi0::RegisterBlock {
3701 Self::PTR
3702 }
3703 #[doc = r" Steal an instance of this peripheral"]
3704 #[doc = r""]
3705 #[doc = r" # Safety"]
3706 #[doc = r""]
3707 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3708 #[doc = r" that may race with any existing instances, for example by only"]
3709 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3710 #[doc = r" original peripheral and using critical sections to coordinate"]
3711 #[doc = r" access between multiple new instances."]
3712 #[doc = r""]
3713 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3714 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3715 #[doc = r" no stolen instances are passed to such software."]
3716 pub unsafe fn steal() -> Self {
3717 Self {
3718 _marker: PhantomData,
3719 }
3720 }
3721}
3722impl Deref for LPSPI9 {
3723 type Target = lpspi0::RegisterBlock;
3724 #[inline(always)]
3725 fn deref(&self) -> &Self::Target {
3726 unsafe { &*Self::PTR }
3727 }
3728}
3729impl core::fmt::Debug for LPSPI9 {
3730 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3731 f.debug_struct("LPSPI9").finish()
3732 }
3733}
3734#[doc = "LPSPI"]
3735pub use self::lpspi0 as lpspi9;
3736#[doc = "LPUART"]
3737pub struct LPUART0 {
3738 _marker: PhantomData<*const ()>,
3739}
3740unsafe impl Send for LPUART0 {}
3741impl LPUART0 {
3742 #[doc = r"Pointer to the register block"]
3743 pub const PTR: *const lpuart0::RegisterBlock = 0x4009_2000 as *const _;
3744 #[doc = r"Return the pointer to the register block"]
3745 #[inline(always)]
3746 pub const fn ptr() -> *const lpuart0::RegisterBlock {
3747 Self::PTR
3748 }
3749 #[doc = r" Steal an instance of this peripheral"]
3750 #[doc = r""]
3751 #[doc = r" # Safety"]
3752 #[doc = r""]
3753 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3754 #[doc = r" that may race with any existing instances, for example by only"]
3755 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3756 #[doc = r" original peripheral and using critical sections to coordinate"]
3757 #[doc = r" access between multiple new instances."]
3758 #[doc = r""]
3759 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3760 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3761 #[doc = r" no stolen instances are passed to such software."]
3762 pub unsafe fn steal() -> Self {
3763 Self {
3764 _marker: PhantomData,
3765 }
3766 }
3767}
3768impl Deref for LPUART0 {
3769 type Target = lpuart0::RegisterBlock;
3770 #[inline(always)]
3771 fn deref(&self) -> &Self::Target {
3772 unsafe { &*Self::PTR }
3773 }
3774}
3775impl core::fmt::Debug for LPUART0 {
3776 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3777 f.debug_struct("LPUART0").finish()
3778 }
3779}
3780#[doc = "LPUART"]
3781pub mod lpuart0;
3782#[doc = "LPUART"]
3783pub struct LPUART1 {
3784 _marker: PhantomData<*const ()>,
3785}
3786unsafe impl Send for LPUART1 {}
3787impl LPUART1 {
3788 #[doc = r"Pointer to the register block"]
3789 pub const PTR: *const lpuart0::RegisterBlock = 0x4009_3000 as *const _;
3790 #[doc = r"Return the pointer to the register block"]
3791 #[inline(always)]
3792 pub const fn ptr() -> *const lpuart0::RegisterBlock {
3793 Self::PTR
3794 }
3795 #[doc = r" Steal an instance of this peripheral"]
3796 #[doc = r""]
3797 #[doc = r" # Safety"]
3798 #[doc = r""]
3799 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3800 #[doc = r" that may race with any existing instances, for example by only"]
3801 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3802 #[doc = r" original peripheral and using critical sections to coordinate"]
3803 #[doc = r" access between multiple new instances."]
3804 #[doc = r""]
3805 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3806 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3807 #[doc = r" no stolen instances are passed to such software."]
3808 pub unsafe fn steal() -> Self {
3809 Self {
3810 _marker: PhantomData,
3811 }
3812 }
3813}
3814impl Deref for LPUART1 {
3815 type Target = lpuart0::RegisterBlock;
3816 #[inline(always)]
3817 fn deref(&self) -> &Self::Target {
3818 unsafe { &*Self::PTR }
3819 }
3820}
3821impl core::fmt::Debug for LPUART1 {
3822 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3823 f.debug_struct("LPUART1").finish()
3824 }
3825}
3826#[doc = "LPUART"]
3827pub use self::lpuart0 as lpuart1;
3828#[doc = "LPUART"]
3829pub struct LPUART2 {
3830 _marker: PhantomData<*const ()>,
3831}
3832unsafe impl Send for LPUART2 {}
3833impl LPUART2 {
3834 #[doc = r"Pointer to the register block"]
3835 pub const PTR: *const lpuart0::RegisterBlock = 0x4009_4000 as *const _;
3836 #[doc = r"Return the pointer to the register block"]
3837 #[inline(always)]
3838 pub const fn ptr() -> *const lpuart0::RegisterBlock {
3839 Self::PTR
3840 }
3841 #[doc = r" Steal an instance of this peripheral"]
3842 #[doc = r""]
3843 #[doc = r" # Safety"]
3844 #[doc = r""]
3845 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3846 #[doc = r" that may race with any existing instances, for example by only"]
3847 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3848 #[doc = r" original peripheral and using critical sections to coordinate"]
3849 #[doc = r" access between multiple new instances."]
3850 #[doc = r""]
3851 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3852 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3853 #[doc = r" no stolen instances are passed to such software."]
3854 pub unsafe fn steal() -> Self {
3855 Self {
3856 _marker: PhantomData,
3857 }
3858 }
3859}
3860impl Deref for LPUART2 {
3861 type Target = lpuart0::RegisterBlock;
3862 #[inline(always)]
3863 fn deref(&self) -> &Self::Target {
3864 unsafe { &*Self::PTR }
3865 }
3866}
3867impl core::fmt::Debug for LPUART2 {
3868 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3869 f.debug_struct("LPUART2").finish()
3870 }
3871}
3872#[doc = "LPUART"]
3873pub use self::lpuart0 as lpuart2;
3874#[doc = "LPUART"]
3875pub struct LPUART3 {
3876 _marker: PhantomData<*const ()>,
3877}
3878unsafe impl Send for LPUART3 {}
3879impl LPUART3 {
3880 #[doc = r"Pointer to the register block"]
3881 pub const PTR: *const lpuart0::RegisterBlock = 0x4009_5000 as *const _;
3882 #[doc = r"Return the pointer to the register block"]
3883 #[inline(always)]
3884 pub const fn ptr() -> *const lpuart0::RegisterBlock {
3885 Self::PTR
3886 }
3887 #[doc = r" Steal an instance of this peripheral"]
3888 #[doc = r""]
3889 #[doc = r" # Safety"]
3890 #[doc = r""]
3891 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3892 #[doc = r" that may race with any existing instances, for example by only"]
3893 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3894 #[doc = r" original peripheral and using critical sections to coordinate"]
3895 #[doc = r" access between multiple new instances."]
3896 #[doc = r""]
3897 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3898 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3899 #[doc = r" no stolen instances are passed to such software."]
3900 pub unsafe fn steal() -> Self {
3901 Self {
3902 _marker: PhantomData,
3903 }
3904 }
3905}
3906impl Deref for LPUART3 {
3907 type Target = lpuart0::RegisterBlock;
3908 #[inline(always)]
3909 fn deref(&self) -> &Self::Target {
3910 unsafe { &*Self::PTR }
3911 }
3912}
3913impl core::fmt::Debug for LPUART3 {
3914 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3915 f.debug_struct("LPUART3").finish()
3916 }
3917}
3918#[doc = "LPUART"]
3919pub use self::lpuart0 as lpuart3;
3920#[doc = "LPUART"]
3921pub struct LPUART4 {
3922 _marker: PhantomData<*const ()>,
3923}
3924unsafe impl Send for LPUART4 {}
3925impl LPUART4 {
3926 #[doc = r"Pointer to the register block"]
3927 pub const PTR: *const lpuart0::RegisterBlock = 0x400b_4000 as *const _;
3928 #[doc = r"Return the pointer to the register block"]
3929 #[inline(always)]
3930 pub const fn ptr() -> *const lpuart0::RegisterBlock {
3931 Self::PTR
3932 }
3933 #[doc = r" Steal an instance of this peripheral"]
3934 #[doc = r""]
3935 #[doc = r" # Safety"]
3936 #[doc = r""]
3937 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3938 #[doc = r" that may race with any existing instances, for example by only"]
3939 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3940 #[doc = r" original peripheral and using critical sections to coordinate"]
3941 #[doc = r" access between multiple new instances."]
3942 #[doc = r""]
3943 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3944 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3945 #[doc = r" no stolen instances are passed to such software."]
3946 pub unsafe fn steal() -> Self {
3947 Self {
3948 _marker: PhantomData,
3949 }
3950 }
3951}
3952impl Deref for LPUART4 {
3953 type Target = lpuart0::RegisterBlock;
3954 #[inline(always)]
3955 fn deref(&self) -> &Self::Target {
3956 unsafe { &*Self::PTR }
3957 }
3958}
3959impl core::fmt::Debug for LPUART4 {
3960 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3961 f.debug_struct("LPUART4").finish()
3962 }
3963}
3964#[doc = "LPUART"]
3965pub use self::lpuart0 as lpuart4;
3966#[doc = "LPUART"]
3967pub struct LPUART5 {
3968 _marker: PhantomData<*const ()>,
3969}
3970unsafe impl Send for LPUART5 {}
3971impl LPUART5 {
3972 #[doc = r"Pointer to the register block"]
3973 pub const PTR: *const lpuart0::RegisterBlock = 0x400b_5000 as *const _;
3974 #[doc = r"Return the pointer to the register block"]
3975 #[inline(always)]
3976 pub const fn ptr() -> *const lpuart0::RegisterBlock {
3977 Self::PTR
3978 }
3979 #[doc = r" Steal an instance of this peripheral"]
3980 #[doc = r""]
3981 #[doc = r" # Safety"]
3982 #[doc = r""]
3983 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3984 #[doc = r" that may race with any existing instances, for example by only"]
3985 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3986 #[doc = r" original peripheral and using critical sections to coordinate"]
3987 #[doc = r" access between multiple new instances."]
3988 #[doc = r""]
3989 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3990 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3991 #[doc = r" no stolen instances are passed to such software."]
3992 pub unsafe fn steal() -> Self {
3993 Self {
3994 _marker: PhantomData,
3995 }
3996 }
3997}
3998impl Deref for LPUART5 {
3999 type Target = lpuart0::RegisterBlock;
4000 #[inline(always)]
4001 fn deref(&self) -> &Self::Target {
4002 unsafe { &*Self::PTR }
4003 }
4004}
4005impl core::fmt::Debug for LPUART5 {
4006 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4007 f.debug_struct("LPUART5").finish()
4008 }
4009}
4010#[doc = "LPUART"]
4011pub use self::lpuart0 as lpuart5;
4012#[doc = "LPUART"]
4013pub struct LPUART6 {
4014 _marker: PhantomData<*const ()>,
4015}
4016unsafe impl Send for LPUART6 {}
4017impl LPUART6 {
4018 #[doc = r"Pointer to the register block"]
4019 pub const PTR: *const lpuart0::RegisterBlock = 0x400b_6000 as *const _;
4020 #[doc = r"Return the pointer to the register block"]
4021 #[inline(always)]
4022 pub const fn ptr() -> *const lpuart0::RegisterBlock {
4023 Self::PTR
4024 }
4025 #[doc = r" Steal an instance of this peripheral"]
4026 #[doc = r""]
4027 #[doc = r" # Safety"]
4028 #[doc = r""]
4029 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4030 #[doc = r" that may race with any existing instances, for example by only"]
4031 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4032 #[doc = r" original peripheral and using critical sections to coordinate"]
4033 #[doc = r" access between multiple new instances."]
4034 #[doc = r""]
4035 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4036 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4037 #[doc = r" no stolen instances are passed to such software."]
4038 pub unsafe fn steal() -> Self {
4039 Self {
4040 _marker: PhantomData,
4041 }
4042 }
4043}
4044impl Deref for LPUART6 {
4045 type Target = lpuart0::RegisterBlock;
4046 #[inline(always)]
4047 fn deref(&self) -> &Self::Target {
4048 unsafe { &*Self::PTR }
4049 }
4050}
4051impl core::fmt::Debug for LPUART6 {
4052 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4053 f.debug_struct("LPUART6").finish()
4054 }
4055}
4056#[doc = "LPUART"]
4057pub use self::lpuart0 as lpuart6;
4058#[doc = "LPUART"]
4059pub struct LPUART7 {
4060 _marker: PhantomData<*const ()>,
4061}
4062unsafe impl Send for LPUART7 {}
4063impl LPUART7 {
4064 #[doc = r"Pointer to the register block"]
4065 pub const PTR: *const lpuart0::RegisterBlock = 0x400b_7000 as *const _;
4066 #[doc = r"Return the pointer to the register block"]
4067 #[inline(always)]
4068 pub const fn ptr() -> *const lpuart0::RegisterBlock {
4069 Self::PTR
4070 }
4071 #[doc = r" Steal an instance of this peripheral"]
4072 #[doc = r""]
4073 #[doc = r" # Safety"]
4074 #[doc = r""]
4075 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4076 #[doc = r" that may race with any existing instances, for example by only"]
4077 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4078 #[doc = r" original peripheral and using critical sections to coordinate"]
4079 #[doc = r" access between multiple new instances."]
4080 #[doc = r""]
4081 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4082 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4083 #[doc = r" no stolen instances are passed to such software."]
4084 pub unsafe fn steal() -> Self {
4085 Self {
4086 _marker: PhantomData,
4087 }
4088 }
4089}
4090impl Deref for LPUART7 {
4091 type Target = lpuart0::RegisterBlock;
4092 #[inline(always)]
4093 fn deref(&self) -> &Self::Target {
4094 unsafe { &*Self::PTR }
4095 }
4096}
4097impl core::fmt::Debug for LPUART7 {
4098 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4099 f.debug_struct("LPUART7").finish()
4100 }
4101}
4102#[doc = "LPUART"]
4103pub use self::lpuart0 as lpuart7;
4104#[doc = "LPUART"]
4105pub struct LPUART8 {
4106 _marker: PhantomData<*const ()>,
4107}
4108unsafe impl Send for LPUART8 {}
4109impl LPUART8 {
4110 #[doc = r"Pointer to the register block"]
4111 pub const PTR: *const lpuart0::RegisterBlock = 0x400b_8000 as *const _;
4112 #[doc = r"Return the pointer to the register block"]
4113 #[inline(always)]
4114 pub const fn ptr() -> *const lpuart0::RegisterBlock {
4115 Self::PTR
4116 }
4117 #[doc = r" Steal an instance of this peripheral"]
4118 #[doc = r""]
4119 #[doc = r" # Safety"]
4120 #[doc = r""]
4121 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4122 #[doc = r" that may race with any existing instances, for example by only"]
4123 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4124 #[doc = r" original peripheral and using critical sections to coordinate"]
4125 #[doc = r" access between multiple new instances."]
4126 #[doc = r""]
4127 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4128 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4129 #[doc = r" no stolen instances are passed to such software."]
4130 pub unsafe fn steal() -> Self {
4131 Self {
4132 _marker: PhantomData,
4133 }
4134 }
4135}
4136impl Deref for LPUART8 {
4137 type Target = lpuart0::RegisterBlock;
4138 #[inline(always)]
4139 fn deref(&self) -> &Self::Target {
4140 unsafe { &*Self::PTR }
4141 }
4142}
4143impl core::fmt::Debug for LPUART8 {
4144 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4145 f.debug_struct("LPUART8").finish()
4146 }
4147}
4148#[doc = "LPUART"]
4149pub use self::lpuart0 as lpuart8;
4150#[doc = "LPUART"]
4151pub struct LPUART9 {
4152 _marker: PhantomData<*const ()>,
4153}
4154unsafe impl Send for LPUART9 {}
4155impl LPUART9 {
4156 #[doc = r"Pointer to the register block"]
4157 pub const PTR: *const lpuart0::RegisterBlock = 0x400b_9000 as *const _;
4158 #[doc = r"Return the pointer to the register block"]
4159 #[inline(always)]
4160 pub const fn ptr() -> *const lpuart0::RegisterBlock {
4161 Self::PTR
4162 }
4163 #[doc = r" Steal an instance of this peripheral"]
4164 #[doc = r""]
4165 #[doc = r" # Safety"]
4166 #[doc = r""]
4167 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4168 #[doc = r" that may race with any existing instances, for example by only"]
4169 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4170 #[doc = r" original peripheral and using critical sections to coordinate"]
4171 #[doc = r" access between multiple new instances."]
4172 #[doc = r""]
4173 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4174 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4175 #[doc = r" no stolen instances are passed to such software."]
4176 pub unsafe fn steal() -> Self {
4177 Self {
4178 _marker: PhantomData,
4179 }
4180 }
4181}
4182impl Deref for LPUART9 {
4183 type Target = lpuart0::RegisterBlock;
4184 #[inline(always)]
4185 fn deref(&self) -> &Self::Target {
4186 unsafe { &*Self::PTR }
4187 }
4188}
4189impl core::fmt::Debug for LPUART9 {
4190 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4191 f.debug_struct("LPUART9").finish()
4192 }
4193}
4194#[doc = "LPUART"]
4195pub use self::lpuart0 as lpuart9;
4196#[doc = "LP_FLEXCOMM"]
4197pub struct LP_FLEXCOMM0 {
4198 _marker: PhantomData<*const ()>,
4199}
4200unsafe impl Send for LP_FLEXCOMM0 {}
4201impl LP_FLEXCOMM0 {
4202 #[doc = r"Pointer to the register block"]
4203 pub const PTR: *const lp_flexcomm0::RegisterBlock = 0x4009_2000 as *const _;
4204 #[doc = r"Return the pointer to the register block"]
4205 #[inline(always)]
4206 pub const fn ptr() -> *const lp_flexcomm0::RegisterBlock {
4207 Self::PTR
4208 }
4209 #[doc = r" Steal an instance of this peripheral"]
4210 #[doc = r""]
4211 #[doc = r" # Safety"]
4212 #[doc = r""]
4213 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4214 #[doc = r" that may race with any existing instances, for example by only"]
4215 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4216 #[doc = r" original peripheral and using critical sections to coordinate"]
4217 #[doc = r" access between multiple new instances."]
4218 #[doc = r""]
4219 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4220 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4221 #[doc = r" no stolen instances are passed to such software."]
4222 pub unsafe fn steal() -> Self {
4223 Self {
4224 _marker: PhantomData,
4225 }
4226 }
4227}
4228impl Deref for LP_FLEXCOMM0 {
4229 type Target = lp_flexcomm0::RegisterBlock;
4230 #[inline(always)]
4231 fn deref(&self) -> &Self::Target {
4232 unsafe { &*Self::PTR }
4233 }
4234}
4235impl core::fmt::Debug for LP_FLEXCOMM0 {
4236 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4237 f.debug_struct("LP_FLEXCOMM0").finish()
4238 }
4239}
4240#[doc = "LP_FLEXCOMM"]
4241pub mod lp_flexcomm0;
4242#[doc = "LP_FLEXCOMM"]
4243pub struct LP_FLEXCOMM1 {
4244 _marker: PhantomData<*const ()>,
4245}
4246unsafe impl Send for LP_FLEXCOMM1 {}
4247impl LP_FLEXCOMM1 {
4248 #[doc = r"Pointer to the register block"]
4249 pub const PTR: *const lp_flexcomm0::RegisterBlock = 0x4009_3000 as *const _;
4250 #[doc = r"Return the pointer to the register block"]
4251 #[inline(always)]
4252 pub const fn ptr() -> *const lp_flexcomm0::RegisterBlock {
4253 Self::PTR
4254 }
4255 #[doc = r" Steal an instance of this peripheral"]
4256 #[doc = r""]
4257 #[doc = r" # Safety"]
4258 #[doc = r""]
4259 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4260 #[doc = r" that may race with any existing instances, for example by only"]
4261 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4262 #[doc = r" original peripheral and using critical sections to coordinate"]
4263 #[doc = r" access between multiple new instances."]
4264 #[doc = r""]
4265 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4266 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4267 #[doc = r" no stolen instances are passed to such software."]
4268 pub unsafe fn steal() -> Self {
4269 Self {
4270 _marker: PhantomData,
4271 }
4272 }
4273}
4274impl Deref for LP_FLEXCOMM1 {
4275 type Target = lp_flexcomm0::RegisterBlock;
4276 #[inline(always)]
4277 fn deref(&self) -> &Self::Target {
4278 unsafe { &*Self::PTR }
4279 }
4280}
4281impl core::fmt::Debug for LP_FLEXCOMM1 {
4282 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4283 f.debug_struct("LP_FLEXCOMM1").finish()
4284 }
4285}
4286#[doc = "LP_FLEXCOMM"]
4287pub use self::lp_flexcomm0 as lp_flexcomm1;
4288#[doc = "LP_FLEXCOMM"]
4289pub struct LP_FLEXCOMM2 {
4290 _marker: PhantomData<*const ()>,
4291}
4292unsafe impl Send for LP_FLEXCOMM2 {}
4293impl LP_FLEXCOMM2 {
4294 #[doc = r"Pointer to the register block"]
4295 pub const PTR: *const lp_flexcomm0::RegisterBlock = 0x4009_4000 as *const _;
4296 #[doc = r"Return the pointer to the register block"]
4297 #[inline(always)]
4298 pub const fn ptr() -> *const lp_flexcomm0::RegisterBlock {
4299 Self::PTR
4300 }
4301 #[doc = r" Steal an instance of this peripheral"]
4302 #[doc = r""]
4303 #[doc = r" # Safety"]
4304 #[doc = r""]
4305 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4306 #[doc = r" that may race with any existing instances, for example by only"]
4307 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4308 #[doc = r" original peripheral and using critical sections to coordinate"]
4309 #[doc = r" access between multiple new instances."]
4310 #[doc = r""]
4311 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4312 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4313 #[doc = r" no stolen instances are passed to such software."]
4314 pub unsafe fn steal() -> Self {
4315 Self {
4316 _marker: PhantomData,
4317 }
4318 }
4319}
4320impl Deref for LP_FLEXCOMM2 {
4321 type Target = lp_flexcomm0::RegisterBlock;
4322 #[inline(always)]
4323 fn deref(&self) -> &Self::Target {
4324 unsafe { &*Self::PTR }
4325 }
4326}
4327impl core::fmt::Debug for LP_FLEXCOMM2 {
4328 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4329 f.debug_struct("LP_FLEXCOMM2").finish()
4330 }
4331}
4332#[doc = "LP_FLEXCOMM"]
4333pub use self::lp_flexcomm0 as lp_flexcomm2;
4334#[doc = "LP_FLEXCOMM"]
4335pub struct LP_FLEXCOMM3 {
4336 _marker: PhantomData<*const ()>,
4337}
4338unsafe impl Send for LP_FLEXCOMM3 {}
4339impl LP_FLEXCOMM3 {
4340 #[doc = r"Pointer to the register block"]
4341 pub const PTR: *const lp_flexcomm0::RegisterBlock = 0x4009_5000 as *const _;
4342 #[doc = r"Return the pointer to the register block"]
4343 #[inline(always)]
4344 pub const fn ptr() -> *const lp_flexcomm0::RegisterBlock {
4345 Self::PTR
4346 }
4347 #[doc = r" Steal an instance of this peripheral"]
4348 #[doc = r""]
4349 #[doc = r" # Safety"]
4350 #[doc = r""]
4351 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4352 #[doc = r" that may race with any existing instances, for example by only"]
4353 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4354 #[doc = r" original peripheral and using critical sections to coordinate"]
4355 #[doc = r" access between multiple new instances."]
4356 #[doc = r""]
4357 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4358 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4359 #[doc = r" no stolen instances are passed to such software."]
4360 pub unsafe fn steal() -> Self {
4361 Self {
4362 _marker: PhantomData,
4363 }
4364 }
4365}
4366impl Deref for LP_FLEXCOMM3 {
4367 type Target = lp_flexcomm0::RegisterBlock;
4368 #[inline(always)]
4369 fn deref(&self) -> &Self::Target {
4370 unsafe { &*Self::PTR }
4371 }
4372}
4373impl core::fmt::Debug for LP_FLEXCOMM3 {
4374 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4375 f.debug_struct("LP_FLEXCOMM3").finish()
4376 }
4377}
4378#[doc = "LP_FLEXCOMM"]
4379pub use self::lp_flexcomm0 as lp_flexcomm3;
4380#[doc = "LP_FLEXCOMM"]
4381pub struct LP_FLEXCOMM4 {
4382 _marker: PhantomData<*const ()>,
4383}
4384unsafe impl Send for LP_FLEXCOMM4 {}
4385impl LP_FLEXCOMM4 {
4386 #[doc = r"Pointer to the register block"]
4387 pub const PTR: *const lp_flexcomm0::RegisterBlock = 0x400b_4000 as *const _;
4388 #[doc = r"Return the pointer to the register block"]
4389 #[inline(always)]
4390 pub const fn ptr() -> *const lp_flexcomm0::RegisterBlock {
4391 Self::PTR
4392 }
4393 #[doc = r" Steal an instance of this peripheral"]
4394 #[doc = r""]
4395 #[doc = r" # Safety"]
4396 #[doc = r""]
4397 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4398 #[doc = r" that may race with any existing instances, for example by only"]
4399 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4400 #[doc = r" original peripheral and using critical sections to coordinate"]
4401 #[doc = r" access between multiple new instances."]
4402 #[doc = r""]
4403 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4404 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4405 #[doc = r" no stolen instances are passed to such software."]
4406 pub unsafe fn steal() -> Self {
4407 Self {
4408 _marker: PhantomData,
4409 }
4410 }
4411}
4412impl Deref for LP_FLEXCOMM4 {
4413 type Target = lp_flexcomm0::RegisterBlock;
4414 #[inline(always)]
4415 fn deref(&self) -> &Self::Target {
4416 unsafe { &*Self::PTR }
4417 }
4418}
4419impl core::fmt::Debug for LP_FLEXCOMM4 {
4420 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4421 f.debug_struct("LP_FLEXCOMM4").finish()
4422 }
4423}
4424#[doc = "LP_FLEXCOMM"]
4425pub use self::lp_flexcomm0 as lp_flexcomm4;
4426#[doc = "LP_FLEXCOMM"]
4427pub struct LP_FLEXCOMM5 {
4428 _marker: PhantomData<*const ()>,
4429}
4430unsafe impl Send for LP_FLEXCOMM5 {}
4431impl LP_FLEXCOMM5 {
4432 #[doc = r"Pointer to the register block"]
4433 pub const PTR: *const lp_flexcomm0::RegisterBlock = 0x400b_5000 as *const _;
4434 #[doc = r"Return the pointer to the register block"]
4435 #[inline(always)]
4436 pub const fn ptr() -> *const lp_flexcomm0::RegisterBlock {
4437 Self::PTR
4438 }
4439 #[doc = r" Steal an instance of this peripheral"]
4440 #[doc = r""]
4441 #[doc = r" # Safety"]
4442 #[doc = r""]
4443 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4444 #[doc = r" that may race with any existing instances, for example by only"]
4445 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4446 #[doc = r" original peripheral and using critical sections to coordinate"]
4447 #[doc = r" access between multiple new instances."]
4448 #[doc = r""]
4449 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4450 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4451 #[doc = r" no stolen instances are passed to such software."]
4452 pub unsafe fn steal() -> Self {
4453 Self {
4454 _marker: PhantomData,
4455 }
4456 }
4457}
4458impl Deref for LP_FLEXCOMM5 {
4459 type Target = lp_flexcomm0::RegisterBlock;
4460 #[inline(always)]
4461 fn deref(&self) -> &Self::Target {
4462 unsafe { &*Self::PTR }
4463 }
4464}
4465impl core::fmt::Debug for LP_FLEXCOMM5 {
4466 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4467 f.debug_struct("LP_FLEXCOMM5").finish()
4468 }
4469}
4470#[doc = "LP_FLEXCOMM"]
4471pub use self::lp_flexcomm0 as lp_flexcomm5;
4472#[doc = "LP_FLEXCOMM"]
4473pub struct LP_FLEXCOMM6 {
4474 _marker: PhantomData<*const ()>,
4475}
4476unsafe impl Send for LP_FLEXCOMM6 {}
4477impl LP_FLEXCOMM6 {
4478 #[doc = r"Pointer to the register block"]
4479 pub const PTR: *const lp_flexcomm0::RegisterBlock = 0x400b_6000 as *const _;
4480 #[doc = r"Return the pointer to the register block"]
4481 #[inline(always)]
4482 pub const fn ptr() -> *const lp_flexcomm0::RegisterBlock {
4483 Self::PTR
4484 }
4485 #[doc = r" Steal an instance of this peripheral"]
4486 #[doc = r""]
4487 #[doc = r" # Safety"]
4488 #[doc = r""]
4489 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4490 #[doc = r" that may race with any existing instances, for example by only"]
4491 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4492 #[doc = r" original peripheral and using critical sections to coordinate"]
4493 #[doc = r" access between multiple new instances."]
4494 #[doc = r""]
4495 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4496 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4497 #[doc = r" no stolen instances are passed to such software."]
4498 pub unsafe fn steal() -> Self {
4499 Self {
4500 _marker: PhantomData,
4501 }
4502 }
4503}
4504impl Deref for LP_FLEXCOMM6 {
4505 type Target = lp_flexcomm0::RegisterBlock;
4506 #[inline(always)]
4507 fn deref(&self) -> &Self::Target {
4508 unsafe { &*Self::PTR }
4509 }
4510}
4511impl core::fmt::Debug for LP_FLEXCOMM6 {
4512 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4513 f.debug_struct("LP_FLEXCOMM6").finish()
4514 }
4515}
4516#[doc = "LP_FLEXCOMM"]
4517pub use self::lp_flexcomm0 as lp_flexcomm6;
4518#[doc = "LP_FLEXCOMM"]
4519pub struct LP_FLEXCOMM7 {
4520 _marker: PhantomData<*const ()>,
4521}
4522unsafe impl Send for LP_FLEXCOMM7 {}
4523impl LP_FLEXCOMM7 {
4524 #[doc = r"Pointer to the register block"]
4525 pub const PTR: *const lp_flexcomm0::RegisterBlock = 0x400b_7000 as *const _;
4526 #[doc = r"Return the pointer to the register block"]
4527 #[inline(always)]
4528 pub const fn ptr() -> *const lp_flexcomm0::RegisterBlock {
4529 Self::PTR
4530 }
4531 #[doc = r" Steal an instance of this peripheral"]
4532 #[doc = r""]
4533 #[doc = r" # Safety"]
4534 #[doc = r""]
4535 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4536 #[doc = r" that may race with any existing instances, for example by only"]
4537 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4538 #[doc = r" original peripheral and using critical sections to coordinate"]
4539 #[doc = r" access between multiple new instances."]
4540 #[doc = r""]
4541 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4542 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4543 #[doc = r" no stolen instances are passed to such software."]
4544 pub unsafe fn steal() -> Self {
4545 Self {
4546 _marker: PhantomData,
4547 }
4548 }
4549}
4550impl Deref for LP_FLEXCOMM7 {
4551 type Target = lp_flexcomm0::RegisterBlock;
4552 #[inline(always)]
4553 fn deref(&self) -> &Self::Target {
4554 unsafe { &*Self::PTR }
4555 }
4556}
4557impl core::fmt::Debug for LP_FLEXCOMM7 {
4558 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4559 f.debug_struct("LP_FLEXCOMM7").finish()
4560 }
4561}
4562#[doc = "LP_FLEXCOMM"]
4563pub use self::lp_flexcomm0 as lp_flexcomm7;
4564#[doc = "LP_FLEXCOMM"]
4565pub struct LP_FLEXCOMM8 {
4566 _marker: PhantomData<*const ()>,
4567}
4568unsafe impl Send for LP_FLEXCOMM8 {}
4569impl LP_FLEXCOMM8 {
4570 #[doc = r"Pointer to the register block"]
4571 pub const PTR: *const lp_flexcomm0::RegisterBlock = 0x400b_8000 as *const _;
4572 #[doc = r"Return the pointer to the register block"]
4573 #[inline(always)]
4574 pub const fn ptr() -> *const lp_flexcomm0::RegisterBlock {
4575 Self::PTR
4576 }
4577 #[doc = r" Steal an instance of this peripheral"]
4578 #[doc = r""]
4579 #[doc = r" # Safety"]
4580 #[doc = r""]
4581 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4582 #[doc = r" that may race with any existing instances, for example by only"]
4583 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4584 #[doc = r" original peripheral and using critical sections to coordinate"]
4585 #[doc = r" access between multiple new instances."]
4586 #[doc = r""]
4587 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4588 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4589 #[doc = r" no stolen instances are passed to such software."]
4590 pub unsafe fn steal() -> Self {
4591 Self {
4592 _marker: PhantomData,
4593 }
4594 }
4595}
4596impl Deref for LP_FLEXCOMM8 {
4597 type Target = lp_flexcomm0::RegisterBlock;
4598 #[inline(always)]
4599 fn deref(&self) -> &Self::Target {
4600 unsafe { &*Self::PTR }
4601 }
4602}
4603impl core::fmt::Debug for LP_FLEXCOMM8 {
4604 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4605 f.debug_struct("LP_FLEXCOMM8").finish()
4606 }
4607}
4608#[doc = "LP_FLEXCOMM"]
4609pub use self::lp_flexcomm0 as lp_flexcomm8;
4610#[doc = "LP_FLEXCOMM"]
4611pub struct LP_FLEXCOMM9 {
4612 _marker: PhantomData<*const ()>,
4613}
4614unsafe impl Send for LP_FLEXCOMM9 {}
4615impl LP_FLEXCOMM9 {
4616 #[doc = r"Pointer to the register block"]
4617 pub const PTR: *const lp_flexcomm0::RegisterBlock = 0x400b_9000 as *const _;
4618 #[doc = r"Return the pointer to the register block"]
4619 #[inline(always)]
4620 pub const fn ptr() -> *const lp_flexcomm0::RegisterBlock {
4621 Self::PTR
4622 }
4623 #[doc = r" Steal an instance of this peripheral"]
4624 #[doc = r""]
4625 #[doc = r" # Safety"]
4626 #[doc = r""]
4627 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4628 #[doc = r" that may race with any existing instances, for example by only"]
4629 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4630 #[doc = r" original peripheral and using critical sections to coordinate"]
4631 #[doc = r" access between multiple new instances."]
4632 #[doc = r""]
4633 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4634 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4635 #[doc = r" no stolen instances are passed to such software."]
4636 pub unsafe fn steal() -> Self {
4637 Self {
4638 _marker: PhantomData,
4639 }
4640 }
4641}
4642impl Deref for LP_FLEXCOMM9 {
4643 type Target = lp_flexcomm0::RegisterBlock;
4644 #[inline(always)]
4645 fn deref(&self) -> &Self::Target {
4646 unsafe { &*Self::PTR }
4647 }
4648}
4649impl core::fmt::Debug for LP_FLEXCOMM9 {
4650 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4651 f.debug_struct("LP_FLEXCOMM9").finish()
4652 }
4653}
4654#[doc = "LP_FLEXCOMM"]
4655pub use self::lp_flexcomm0 as lp_flexcomm9;
4656#[doc = "LPI2C"]
4657pub struct LPI2C0 {
4658 _marker: PhantomData<*const ()>,
4659}
4660unsafe impl Send for LPI2C0 {}
4661impl LPI2C0 {
4662 #[doc = r"Pointer to the register block"]
4663 pub const PTR: *const lpi2c0::RegisterBlock = 0x4009_2800 as *const _;
4664 #[doc = r"Return the pointer to the register block"]
4665 #[inline(always)]
4666 pub const fn ptr() -> *const lpi2c0::RegisterBlock {
4667 Self::PTR
4668 }
4669 #[doc = r" Steal an instance of this peripheral"]
4670 #[doc = r""]
4671 #[doc = r" # Safety"]
4672 #[doc = r""]
4673 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4674 #[doc = r" that may race with any existing instances, for example by only"]
4675 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4676 #[doc = r" original peripheral and using critical sections to coordinate"]
4677 #[doc = r" access between multiple new instances."]
4678 #[doc = r""]
4679 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4680 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4681 #[doc = r" no stolen instances are passed to such software."]
4682 pub unsafe fn steal() -> Self {
4683 Self {
4684 _marker: PhantomData,
4685 }
4686 }
4687}
4688impl Deref for LPI2C0 {
4689 type Target = lpi2c0::RegisterBlock;
4690 #[inline(always)]
4691 fn deref(&self) -> &Self::Target {
4692 unsafe { &*Self::PTR }
4693 }
4694}
4695impl core::fmt::Debug for LPI2C0 {
4696 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4697 f.debug_struct("LPI2C0").finish()
4698 }
4699}
4700#[doc = "LPI2C"]
4701pub mod lpi2c0;
4702#[doc = "LPI2C"]
4703pub struct LPI2C1 {
4704 _marker: PhantomData<*const ()>,
4705}
4706unsafe impl Send for LPI2C1 {}
4707impl LPI2C1 {
4708 #[doc = r"Pointer to the register block"]
4709 pub const PTR: *const lpi2c0::RegisterBlock = 0x4009_3800 as *const _;
4710 #[doc = r"Return the pointer to the register block"]
4711 #[inline(always)]
4712 pub const fn ptr() -> *const lpi2c0::RegisterBlock {
4713 Self::PTR
4714 }
4715 #[doc = r" Steal an instance of this peripheral"]
4716 #[doc = r""]
4717 #[doc = r" # Safety"]
4718 #[doc = r""]
4719 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4720 #[doc = r" that may race with any existing instances, for example by only"]
4721 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4722 #[doc = r" original peripheral and using critical sections to coordinate"]
4723 #[doc = r" access between multiple new instances."]
4724 #[doc = r""]
4725 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4726 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4727 #[doc = r" no stolen instances are passed to such software."]
4728 pub unsafe fn steal() -> Self {
4729 Self {
4730 _marker: PhantomData,
4731 }
4732 }
4733}
4734impl Deref for LPI2C1 {
4735 type Target = lpi2c0::RegisterBlock;
4736 #[inline(always)]
4737 fn deref(&self) -> &Self::Target {
4738 unsafe { &*Self::PTR }
4739 }
4740}
4741impl core::fmt::Debug for LPI2C1 {
4742 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4743 f.debug_struct("LPI2C1").finish()
4744 }
4745}
4746#[doc = "LPI2C"]
4747pub use self::lpi2c0 as lpi2c1;
4748#[doc = "LPI2C"]
4749pub struct LPI2C2 {
4750 _marker: PhantomData<*const ()>,
4751}
4752unsafe impl Send for LPI2C2 {}
4753impl LPI2C2 {
4754 #[doc = r"Pointer to the register block"]
4755 pub const PTR: *const lpi2c0::RegisterBlock = 0x4009_4800 as *const _;
4756 #[doc = r"Return the pointer to the register block"]
4757 #[inline(always)]
4758 pub const fn ptr() -> *const lpi2c0::RegisterBlock {
4759 Self::PTR
4760 }
4761 #[doc = r" Steal an instance of this peripheral"]
4762 #[doc = r""]
4763 #[doc = r" # Safety"]
4764 #[doc = r""]
4765 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4766 #[doc = r" that may race with any existing instances, for example by only"]
4767 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4768 #[doc = r" original peripheral and using critical sections to coordinate"]
4769 #[doc = r" access between multiple new instances."]
4770 #[doc = r""]
4771 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4772 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4773 #[doc = r" no stolen instances are passed to such software."]
4774 pub unsafe fn steal() -> Self {
4775 Self {
4776 _marker: PhantomData,
4777 }
4778 }
4779}
4780impl Deref for LPI2C2 {
4781 type Target = lpi2c0::RegisterBlock;
4782 #[inline(always)]
4783 fn deref(&self) -> &Self::Target {
4784 unsafe { &*Self::PTR }
4785 }
4786}
4787impl core::fmt::Debug for LPI2C2 {
4788 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4789 f.debug_struct("LPI2C2").finish()
4790 }
4791}
4792#[doc = "LPI2C"]
4793pub use self::lpi2c0 as lpi2c2;
4794#[doc = "LPI2C"]
4795pub struct LPI2C3 {
4796 _marker: PhantomData<*const ()>,
4797}
4798unsafe impl Send for LPI2C3 {}
4799impl LPI2C3 {
4800 #[doc = r"Pointer to the register block"]
4801 pub const PTR: *const lpi2c0::RegisterBlock = 0x4009_5800 as *const _;
4802 #[doc = r"Return the pointer to the register block"]
4803 #[inline(always)]
4804 pub const fn ptr() -> *const lpi2c0::RegisterBlock {
4805 Self::PTR
4806 }
4807 #[doc = r" Steal an instance of this peripheral"]
4808 #[doc = r""]
4809 #[doc = r" # Safety"]
4810 #[doc = r""]
4811 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4812 #[doc = r" that may race with any existing instances, for example by only"]
4813 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4814 #[doc = r" original peripheral and using critical sections to coordinate"]
4815 #[doc = r" access between multiple new instances."]
4816 #[doc = r""]
4817 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4818 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4819 #[doc = r" no stolen instances are passed to such software."]
4820 pub unsafe fn steal() -> Self {
4821 Self {
4822 _marker: PhantomData,
4823 }
4824 }
4825}
4826impl Deref for LPI2C3 {
4827 type Target = lpi2c0::RegisterBlock;
4828 #[inline(always)]
4829 fn deref(&self) -> &Self::Target {
4830 unsafe { &*Self::PTR }
4831 }
4832}
4833impl core::fmt::Debug for LPI2C3 {
4834 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4835 f.debug_struct("LPI2C3").finish()
4836 }
4837}
4838#[doc = "LPI2C"]
4839pub use self::lpi2c0 as lpi2c3;
4840#[doc = "LPI2C"]
4841pub struct LPI2C4 {
4842 _marker: PhantomData<*const ()>,
4843}
4844unsafe impl Send for LPI2C4 {}
4845impl LPI2C4 {
4846 #[doc = r"Pointer to the register block"]
4847 pub const PTR: *const lpi2c0::RegisterBlock = 0x400b_4800 as *const _;
4848 #[doc = r"Return the pointer to the register block"]
4849 #[inline(always)]
4850 pub const fn ptr() -> *const lpi2c0::RegisterBlock {
4851 Self::PTR
4852 }
4853 #[doc = r" Steal an instance of this peripheral"]
4854 #[doc = r""]
4855 #[doc = r" # Safety"]
4856 #[doc = r""]
4857 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4858 #[doc = r" that may race with any existing instances, for example by only"]
4859 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4860 #[doc = r" original peripheral and using critical sections to coordinate"]
4861 #[doc = r" access between multiple new instances."]
4862 #[doc = r""]
4863 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4864 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4865 #[doc = r" no stolen instances are passed to such software."]
4866 pub unsafe fn steal() -> Self {
4867 Self {
4868 _marker: PhantomData,
4869 }
4870 }
4871}
4872impl Deref for LPI2C4 {
4873 type Target = lpi2c0::RegisterBlock;
4874 #[inline(always)]
4875 fn deref(&self) -> &Self::Target {
4876 unsafe { &*Self::PTR }
4877 }
4878}
4879impl core::fmt::Debug for LPI2C4 {
4880 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4881 f.debug_struct("LPI2C4").finish()
4882 }
4883}
4884#[doc = "LPI2C"]
4885pub use self::lpi2c0 as lpi2c4;
4886#[doc = "LPI2C"]
4887pub struct LPI2C5 {
4888 _marker: PhantomData<*const ()>,
4889}
4890unsafe impl Send for LPI2C5 {}
4891impl LPI2C5 {
4892 #[doc = r"Pointer to the register block"]
4893 pub const PTR: *const lpi2c0::RegisterBlock = 0x400b_5800 as *const _;
4894 #[doc = r"Return the pointer to the register block"]
4895 #[inline(always)]
4896 pub const fn ptr() -> *const lpi2c0::RegisterBlock {
4897 Self::PTR
4898 }
4899 #[doc = r" Steal an instance of this peripheral"]
4900 #[doc = r""]
4901 #[doc = r" # Safety"]
4902 #[doc = r""]
4903 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4904 #[doc = r" that may race with any existing instances, for example by only"]
4905 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4906 #[doc = r" original peripheral and using critical sections to coordinate"]
4907 #[doc = r" access between multiple new instances."]
4908 #[doc = r""]
4909 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4910 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4911 #[doc = r" no stolen instances are passed to such software."]
4912 pub unsafe fn steal() -> Self {
4913 Self {
4914 _marker: PhantomData,
4915 }
4916 }
4917}
4918impl Deref for LPI2C5 {
4919 type Target = lpi2c0::RegisterBlock;
4920 #[inline(always)]
4921 fn deref(&self) -> &Self::Target {
4922 unsafe { &*Self::PTR }
4923 }
4924}
4925impl core::fmt::Debug for LPI2C5 {
4926 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4927 f.debug_struct("LPI2C5").finish()
4928 }
4929}
4930#[doc = "LPI2C"]
4931pub use self::lpi2c0 as lpi2c5;
4932#[doc = "LPI2C"]
4933pub struct LPI2C6 {
4934 _marker: PhantomData<*const ()>,
4935}
4936unsafe impl Send for LPI2C6 {}
4937impl LPI2C6 {
4938 #[doc = r"Pointer to the register block"]
4939 pub const PTR: *const lpi2c0::RegisterBlock = 0x400b_6800 as *const _;
4940 #[doc = r"Return the pointer to the register block"]
4941 #[inline(always)]
4942 pub const fn ptr() -> *const lpi2c0::RegisterBlock {
4943 Self::PTR
4944 }
4945 #[doc = r" Steal an instance of this peripheral"]
4946 #[doc = r""]
4947 #[doc = r" # Safety"]
4948 #[doc = r""]
4949 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4950 #[doc = r" that may race with any existing instances, for example by only"]
4951 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4952 #[doc = r" original peripheral and using critical sections to coordinate"]
4953 #[doc = r" access between multiple new instances."]
4954 #[doc = r""]
4955 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4956 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4957 #[doc = r" no stolen instances are passed to such software."]
4958 pub unsafe fn steal() -> Self {
4959 Self {
4960 _marker: PhantomData,
4961 }
4962 }
4963}
4964impl Deref for LPI2C6 {
4965 type Target = lpi2c0::RegisterBlock;
4966 #[inline(always)]
4967 fn deref(&self) -> &Self::Target {
4968 unsafe { &*Self::PTR }
4969 }
4970}
4971impl core::fmt::Debug for LPI2C6 {
4972 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4973 f.debug_struct("LPI2C6").finish()
4974 }
4975}
4976#[doc = "LPI2C"]
4977pub use self::lpi2c0 as lpi2c6;
4978#[doc = "LPI2C"]
4979pub struct LPI2C7 {
4980 _marker: PhantomData<*const ()>,
4981}
4982unsafe impl Send for LPI2C7 {}
4983impl LPI2C7 {
4984 #[doc = r"Pointer to the register block"]
4985 pub const PTR: *const lpi2c0::RegisterBlock = 0x400b_7800 as *const _;
4986 #[doc = r"Return the pointer to the register block"]
4987 #[inline(always)]
4988 pub const fn ptr() -> *const lpi2c0::RegisterBlock {
4989 Self::PTR
4990 }
4991 #[doc = r" Steal an instance of this peripheral"]
4992 #[doc = r""]
4993 #[doc = r" # Safety"]
4994 #[doc = r""]
4995 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4996 #[doc = r" that may race with any existing instances, for example by only"]
4997 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4998 #[doc = r" original peripheral and using critical sections to coordinate"]
4999 #[doc = r" access between multiple new instances."]
5000 #[doc = r""]
5001 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5002 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5003 #[doc = r" no stolen instances are passed to such software."]
5004 pub unsafe fn steal() -> Self {
5005 Self {
5006 _marker: PhantomData,
5007 }
5008 }
5009}
5010impl Deref for LPI2C7 {
5011 type Target = lpi2c0::RegisterBlock;
5012 #[inline(always)]
5013 fn deref(&self) -> &Self::Target {
5014 unsafe { &*Self::PTR }
5015 }
5016}
5017impl core::fmt::Debug for LPI2C7 {
5018 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5019 f.debug_struct("LPI2C7").finish()
5020 }
5021}
5022#[doc = "LPI2C"]
5023pub use self::lpi2c0 as lpi2c7;
5024#[doc = "LPI2C"]
5025pub struct LPI2C8 {
5026 _marker: PhantomData<*const ()>,
5027}
5028unsafe impl Send for LPI2C8 {}
5029impl LPI2C8 {
5030 #[doc = r"Pointer to the register block"]
5031 pub const PTR: *const lpi2c0::RegisterBlock = 0x400b_8800 as *const _;
5032 #[doc = r"Return the pointer to the register block"]
5033 #[inline(always)]
5034 pub const fn ptr() -> *const lpi2c0::RegisterBlock {
5035 Self::PTR
5036 }
5037 #[doc = r" Steal an instance of this peripheral"]
5038 #[doc = r""]
5039 #[doc = r" # Safety"]
5040 #[doc = r""]
5041 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5042 #[doc = r" that may race with any existing instances, for example by only"]
5043 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5044 #[doc = r" original peripheral and using critical sections to coordinate"]
5045 #[doc = r" access between multiple new instances."]
5046 #[doc = r""]
5047 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5048 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5049 #[doc = r" no stolen instances are passed to such software."]
5050 pub unsafe fn steal() -> Self {
5051 Self {
5052 _marker: PhantomData,
5053 }
5054 }
5055}
5056impl Deref for LPI2C8 {
5057 type Target = lpi2c0::RegisterBlock;
5058 #[inline(always)]
5059 fn deref(&self) -> &Self::Target {
5060 unsafe { &*Self::PTR }
5061 }
5062}
5063impl core::fmt::Debug for LPI2C8 {
5064 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5065 f.debug_struct("LPI2C8").finish()
5066 }
5067}
5068#[doc = "LPI2C"]
5069pub use self::lpi2c0 as lpi2c8;
5070#[doc = "LPI2C"]
5071pub struct LPI2C9 {
5072 _marker: PhantomData<*const ()>,
5073}
5074unsafe impl Send for LPI2C9 {}
5075impl LPI2C9 {
5076 #[doc = r"Pointer to the register block"]
5077 pub const PTR: *const lpi2c0::RegisterBlock = 0x400b_9800 as *const _;
5078 #[doc = r"Return the pointer to the register block"]
5079 #[inline(always)]
5080 pub const fn ptr() -> *const lpi2c0::RegisterBlock {
5081 Self::PTR
5082 }
5083 #[doc = r" Steal an instance of this peripheral"]
5084 #[doc = r""]
5085 #[doc = r" # Safety"]
5086 #[doc = r""]
5087 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5088 #[doc = r" that may race with any existing instances, for example by only"]
5089 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5090 #[doc = r" original peripheral and using critical sections to coordinate"]
5091 #[doc = r" access between multiple new instances."]
5092 #[doc = r""]
5093 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5094 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5095 #[doc = r" no stolen instances are passed to such software."]
5096 pub unsafe fn steal() -> Self {
5097 Self {
5098 _marker: PhantomData,
5099 }
5100 }
5101}
5102impl Deref for LPI2C9 {
5103 type Target = lpi2c0::RegisterBlock;
5104 #[inline(always)]
5105 fn deref(&self) -> &Self::Target {
5106 unsafe { &*Self::PTR }
5107 }
5108}
5109impl core::fmt::Debug for LPI2C9 {
5110 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5111 f.debug_struct("LPI2C9").finish()
5112 }
5113}
5114#[doc = "LPI2C"]
5115pub use self::lpi2c0 as lpi2c9;
5116#[doc = "GPIO"]
5117pub struct GPIO0 {
5118 _marker: PhantomData<*const ()>,
5119}
5120unsafe impl Send for GPIO0 {}
5121impl GPIO0 {
5122 #[doc = r"Pointer to the register block"]
5123 pub const PTR: *const gpio0::RegisterBlock = 0x4009_6000 as *const _;
5124 #[doc = r"Return the pointer to the register block"]
5125 #[inline(always)]
5126 pub const fn ptr() -> *const gpio0::RegisterBlock {
5127 Self::PTR
5128 }
5129 #[doc = r" Steal an instance of this peripheral"]
5130 #[doc = r""]
5131 #[doc = r" # Safety"]
5132 #[doc = r""]
5133 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5134 #[doc = r" that may race with any existing instances, for example by only"]
5135 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5136 #[doc = r" original peripheral and using critical sections to coordinate"]
5137 #[doc = r" access between multiple new instances."]
5138 #[doc = r""]
5139 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5140 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5141 #[doc = r" no stolen instances are passed to such software."]
5142 pub unsafe fn steal() -> Self {
5143 Self {
5144 _marker: PhantomData,
5145 }
5146 }
5147}
5148impl Deref for GPIO0 {
5149 type Target = gpio0::RegisterBlock;
5150 #[inline(always)]
5151 fn deref(&self) -> &Self::Target {
5152 unsafe { &*Self::PTR }
5153 }
5154}
5155impl core::fmt::Debug for GPIO0 {
5156 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5157 f.debug_struct("GPIO0").finish()
5158 }
5159}
5160#[doc = "GPIO"]
5161pub mod gpio0;
5162#[doc = "GPIO"]
5163pub struct GPIO5 {
5164 _marker: PhantomData<*const ()>,
5165}
5166unsafe impl Send for GPIO5 {}
5167impl GPIO5 {
5168 #[doc = r"Pointer to the register block"]
5169 pub const PTR: *const gpio0::RegisterBlock = 0x4004_0000 as *const _;
5170 #[doc = r"Return the pointer to the register block"]
5171 #[inline(always)]
5172 pub const fn ptr() -> *const gpio0::RegisterBlock {
5173 Self::PTR
5174 }
5175 #[doc = r" Steal an instance of this peripheral"]
5176 #[doc = r""]
5177 #[doc = r" # Safety"]
5178 #[doc = r""]
5179 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5180 #[doc = r" that may race with any existing instances, for example by only"]
5181 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5182 #[doc = r" original peripheral and using critical sections to coordinate"]
5183 #[doc = r" access between multiple new instances."]
5184 #[doc = r""]
5185 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5186 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5187 #[doc = r" no stolen instances are passed to such software."]
5188 pub unsafe fn steal() -> Self {
5189 Self {
5190 _marker: PhantomData,
5191 }
5192 }
5193}
5194impl Deref for GPIO5 {
5195 type Target = gpio0::RegisterBlock;
5196 #[inline(always)]
5197 fn deref(&self) -> &Self::Target {
5198 unsafe { &*Self::PTR }
5199 }
5200}
5201impl core::fmt::Debug for GPIO5 {
5202 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5203 f.debug_struct("GPIO5").finish()
5204 }
5205}
5206#[doc = "GPIO"]
5207pub use self::gpio0 as gpio5;
5208#[doc = "GPIO"]
5209pub struct GPIO1 {
5210 _marker: PhantomData<*const ()>,
5211}
5212unsafe impl Send for GPIO1 {}
5213impl GPIO1 {
5214 #[doc = r"Pointer to the register block"]
5215 pub const PTR: *const gpio0::RegisterBlock = 0x4009_8000 as *const _;
5216 #[doc = r"Return the pointer to the register block"]
5217 #[inline(always)]
5218 pub const fn ptr() -> *const gpio0::RegisterBlock {
5219 Self::PTR
5220 }
5221 #[doc = r" Steal an instance of this peripheral"]
5222 #[doc = r""]
5223 #[doc = r" # Safety"]
5224 #[doc = r""]
5225 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5226 #[doc = r" that may race with any existing instances, for example by only"]
5227 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5228 #[doc = r" original peripheral and using critical sections to coordinate"]
5229 #[doc = r" access between multiple new instances."]
5230 #[doc = r""]
5231 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5232 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5233 #[doc = r" no stolen instances are passed to such software."]
5234 pub unsafe fn steal() -> Self {
5235 Self {
5236 _marker: PhantomData,
5237 }
5238 }
5239}
5240impl Deref for GPIO1 {
5241 type Target = gpio0::RegisterBlock;
5242 #[inline(always)]
5243 fn deref(&self) -> &Self::Target {
5244 unsafe { &*Self::PTR }
5245 }
5246}
5247impl core::fmt::Debug for GPIO1 {
5248 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5249 f.debug_struct("GPIO1").finish()
5250 }
5251}
5252#[doc = "GPIO"]
5253pub use self::gpio0 as gpio1;
5254#[doc = "GPIO"]
5255pub struct GPIO2 {
5256 _marker: PhantomData<*const ()>,
5257}
5258unsafe impl Send for GPIO2 {}
5259impl GPIO2 {
5260 #[doc = r"Pointer to the register block"]
5261 pub const PTR: *const gpio0::RegisterBlock = 0x4009_a000 as *const _;
5262 #[doc = r"Return the pointer to the register block"]
5263 #[inline(always)]
5264 pub const fn ptr() -> *const gpio0::RegisterBlock {
5265 Self::PTR
5266 }
5267 #[doc = r" Steal an instance of this peripheral"]
5268 #[doc = r""]
5269 #[doc = r" # Safety"]
5270 #[doc = r""]
5271 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5272 #[doc = r" that may race with any existing instances, for example by only"]
5273 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5274 #[doc = r" original peripheral and using critical sections to coordinate"]
5275 #[doc = r" access between multiple new instances."]
5276 #[doc = r""]
5277 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5278 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5279 #[doc = r" no stolen instances are passed to such software."]
5280 pub unsafe fn steal() -> Self {
5281 Self {
5282 _marker: PhantomData,
5283 }
5284 }
5285}
5286impl Deref for GPIO2 {
5287 type Target = gpio0::RegisterBlock;
5288 #[inline(always)]
5289 fn deref(&self) -> &Self::Target {
5290 unsafe { &*Self::PTR }
5291 }
5292}
5293impl core::fmt::Debug for GPIO2 {
5294 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5295 f.debug_struct("GPIO2").finish()
5296 }
5297}
5298#[doc = "GPIO"]
5299pub use self::gpio0 as gpio2;
5300#[doc = "GPIO"]
5301pub struct GPIO3 {
5302 _marker: PhantomData<*const ()>,
5303}
5304unsafe impl Send for GPIO3 {}
5305impl GPIO3 {
5306 #[doc = r"Pointer to the register block"]
5307 pub const PTR: *const gpio0::RegisterBlock = 0x4009_c000 as *const _;
5308 #[doc = r"Return the pointer to the register block"]
5309 #[inline(always)]
5310 pub const fn ptr() -> *const gpio0::RegisterBlock {
5311 Self::PTR
5312 }
5313 #[doc = r" Steal an instance of this peripheral"]
5314 #[doc = r""]
5315 #[doc = r" # Safety"]
5316 #[doc = r""]
5317 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5318 #[doc = r" that may race with any existing instances, for example by only"]
5319 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5320 #[doc = r" original peripheral and using critical sections to coordinate"]
5321 #[doc = r" access between multiple new instances."]
5322 #[doc = r""]
5323 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5324 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5325 #[doc = r" no stolen instances are passed to such software."]
5326 pub unsafe fn steal() -> Self {
5327 Self {
5328 _marker: PhantomData,
5329 }
5330 }
5331}
5332impl Deref for GPIO3 {
5333 type Target = gpio0::RegisterBlock;
5334 #[inline(always)]
5335 fn deref(&self) -> &Self::Target {
5336 unsafe { &*Self::PTR }
5337 }
5338}
5339impl core::fmt::Debug for GPIO3 {
5340 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5341 f.debug_struct("GPIO3").finish()
5342 }
5343}
5344#[doc = "GPIO"]
5345pub use self::gpio0 as gpio3;
5346#[doc = "GPIO"]
5347pub struct GPIO4 {
5348 _marker: PhantomData<*const ()>,
5349}
5350unsafe impl Send for GPIO4 {}
5351impl GPIO4 {
5352 #[doc = r"Pointer to the register block"]
5353 pub const PTR: *const gpio0::RegisterBlock = 0x4009_e000 as *const _;
5354 #[doc = r"Return the pointer to the register block"]
5355 #[inline(always)]
5356 pub const fn ptr() -> *const gpio0::RegisterBlock {
5357 Self::PTR
5358 }
5359 #[doc = r" Steal an instance of this peripheral"]
5360 #[doc = r""]
5361 #[doc = r" # Safety"]
5362 #[doc = r""]
5363 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5364 #[doc = r" that may race with any existing instances, for example by only"]
5365 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5366 #[doc = r" original peripheral and using critical sections to coordinate"]
5367 #[doc = r" access between multiple new instances."]
5368 #[doc = r""]
5369 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5370 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5371 #[doc = r" no stolen instances are passed to such software."]
5372 pub unsafe fn steal() -> Self {
5373 Self {
5374 _marker: PhantomData,
5375 }
5376 }
5377}
5378impl Deref for GPIO4 {
5379 type Target = gpio0::RegisterBlock;
5380 #[inline(always)]
5381 fn deref(&self) -> &Self::Target {
5382 unsafe { &*Self::PTR }
5383 }
5384}
5385impl core::fmt::Debug for GPIO4 {
5386 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5387 f.debug_struct("GPIO4").finish()
5388 }
5389}
5390#[doc = "GPIO"]
5391pub use self::gpio0 as gpio4;
5392#[doc = "DMA TCD"]
5393pub struct EDMA_1_TCD {
5394 _marker: PhantomData<*const ()>,
5395}
5396unsafe impl Send for EDMA_1_TCD {}
5397impl EDMA_1_TCD {
5398 #[doc = r"Pointer to the register block"]
5399 pub const PTR: *const edma_0_tcd::RegisterBlock = 0x400a_1000 as *const _;
5400 #[doc = r"Return the pointer to the register block"]
5401 #[inline(always)]
5402 pub const fn ptr() -> *const edma_0_tcd::RegisterBlock {
5403 Self::PTR
5404 }
5405 #[doc = r" Steal an instance of this peripheral"]
5406 #[doc = r""]
5407 #[doc = r" # Safety"]
5408 #[doc = r""]
5409 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5410 #[doc = r" that may race with any existing instances, for example by only"]
5411 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5412 #[doc = r" original peripheral and using critical sections to coordinate"]
5413 #[doc = r" access between multiple new instances."]
5414 #[doc = r""]
5415 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5416 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5417 #[doc = r" no stolen instances are passed to such software."]
5418 pub unsafe fn steal() -> Self {
5419 Self {
5420 _marker: PhantomData,
5421 }
5422 }
5423}
5424impl Deref for EDMA_1_TCD {
5425 type Target = edma_0_tcd::RegisterBlock;
5426 #[inline(always)]
5427 fn deref(&self) -> &Self::Target {
5428 unsafe { &*Self::PTR }
5429 }
5430}
5431impl core::fmt::Debug for EDMA_1_TCD {
5432 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5433 f.debug_struct("EDMA_1_TCD").finish()
5434 }
5435}
5436#[doc = "DMA TCD"]
5437pub use self::edma_0_tcd as edma_1_tcd;
5438#[doc = "SEMA42"]
5439pub struct SEMA42_0 {
5440 _marker: PhantomData<*const ()>,
5441}
5442unsafe impl Send for SEMA42_0 {}
5443impl SEMA42_0 {
5444 #[doc = r"Pointer to the register block"]
5445 pub const PTR: *const sema42_0::RegisterBlock = 0x400b_1000 as *const _;
5446 #[doc = r"Return the pointer to the register block"]
5447 #[inline(always)]
5448 pub const fn ptr() -> *const sema42_0::RegisterBlock {
5449 Self::PTR
5450 }
5451 #[doc = r" Steal an instance of this peripheral"]
5452 #[doc = r""]
5453 #[doc = r" # Safety"]
5454 #[doc = r""]
5455 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5456 #[doc = r" that may race with any existing instances, for example by only"]
5457 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5458 #[doc = r" original peripheral and using critical sections to coordinate"]
5459 #[doc = r" access between multiple new instances."]
5460 #[doc = r""]
5461 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5462 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5463 #[doc = r" no stolen instances are passed to such software."]
5464 pub unsafe fn steal() -> Self {
5465 Self {
5466 _marker: PhantomData,
5467 }
5468 }
5469}
5470impl Deref for SEMA42_0 {
5471 type Target = sema42_0::RegisterBlock;
5472 #[inline(always)]
5473 fn deref(&self) -> &Self::Target {
5474 unsafe { &*Self::PTR }
5475 }
5476}
5477impl core::fmt::Debug for SEMA42_0 {
5478 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5479 f.debug_struct("SEMA42_0").finish()
5480 }
5481}
5482#[doc = "SEMA42"]
5483pub mod sema42_0;
5484#[doc = "MAILBOX"]
5485pub struct MAILBOX {
5486 _marker: PhantomData<*const ()>,
5487}
5488unsafe impl Send for MAILBOX {}
5489impl MAILBOX {
5490 #[doc = r"Pointer to the register block"]
5491 pub const PTR: *const mailbox::RegisterBlock = 0x400b_2000 as *const _;
5492 #[doc = r"Return the pointer to the register block"]
5493 #[inline(always)]
5494 pub const fn ptr() -> *const mailbox::RegisterBlock {
5495 Self::PTR
5496 }
5497 #[doc = r" Steal an instance of this peripheral"]
5498 #[doc = r""]
5499 #[doc = r" # Safety"]
5500 #[doc = r""]
5501 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5502 #[doc = r" that may race with any existing instances, for example by only"]
5503 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5504 #[doc = r" original peripheral and using critical sections to coordinate"]
5505 #[doc = r" access between multiple new instances."]
5506 #[doc = r""]
5507 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5508 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5509 #[doc = r" no stolen instances are passed to such software."]
5510 pub unsafe fn steal() -> Self {
5511 Self {
5512 _marker: PhantomData,
5513 }
5514 }
5515}
5516impl Deref for MAILBOX {
5517 type Target = mailbox::RegisterBlock;
5518 #[inline(always)]
5519 fn deref(&self) -> &Self::Target {
5520 unsafe { &*Self::PTR }
5521 }
5522}
5523impl core::fmt::Debug for MAILBOX {
5524 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5525 f.debug_struct("MAILBOX").finish()
5526 }
5527}
5528#[doc = "MAILBOX"]
5529pub mod mailbox;
5530#[doc = "CDOG"]
5531pub struct CDOG0 {
5532 _marker: PhantomData<*const ()>,
5533}
5534unsafe impl Send for CDOG0 {}
5535impl CDOG0 {
5536 #[doc = r"Pointer to the register block"]
5537 pub const PTR: *const cdog0::RegisterBlock = 0x400b_b000 as *const _;
5538 #[doc = r"Return the pointer to the register block"]
5539 #[inline(always)]
5540 pub const fn ptr() -> *const cdog0::RegisterBlock {
5541 Self::PTR
5542 }
5543 #[doc = r" Steal an instance of this peripheral"]
5544 #[doc = r""]
5545 #[doc = r" # Safety"]
5546 #[doc = r""]
5547 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5548 #[doc = r" that may race with any existing instances, for example by only"]
5549 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5550 #[doc = r" original peripheral and using critical sections to coordinate"]
5551 #[doc = r" access between multiple new instances."]
5552 #[doc = r""]
5553 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5554 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5555 #[doc = r" no stolen instances are passed to such software."]
5556 pub unsafe fn steal() -> Self {
5557 Self {
5558 _marker: PhantomData,
5559 }
5560 }
5561}
5562impl Deref for CDOG0 {
5563 type Target = cdog0::RegisterBlock;
5564 #[inline(always)]
5565 fn deref(&self) -> &Self::Target {
5566 unsafe { &*Self::PTR }
5567 }
5568}
5569impl core::fmt::Debug for CDOG0 {
5570 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5571 f.debug_struct("CDOG0").finish()
5572 }
5573}
5574#[doc = "CDOG"]
5575pub mod cdog0;
5576#[doc = "CDOG"]
5577pub struct CDOG1 {
5578 _marker: PhantomData<*const ()>,
5579}
5580unsafe impl Send for CDOG1 {}
5581impl CDOG1 {
5582 #[doc = r"Pointer to the register block"]
5583 pub const PTR: *const cdog0::RegisterBlock = 0x400b_c000 as *const _;
5584 #[doc = r"Return the pointer to the register block"]
5585 #[inline(always)]
5586 pub const fn ptr() -> *const cdog0::RegisterBlock {
5587 Self::PTR
5588 }
5589 #[doc = r" Steal an instance of this peripheral"]
5590 #[doc = r""]
5591 #[doc = r" # Safety"]
5592 #[doc = r""]
5593 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5594 #[doc = r" that may race with any existing instances, for example by only"]
5595 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5596 #[doc = r" original peripheral and using critical sections to coordinate"]
5597 #[doc = r" access between multiple new instances."]
5598 #[doc = r""]
5599 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5600 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5601 #[doc = r" no stolen instances are passed to such software."]
5602 pub unsafe fn steal() -> Self {
5603 Self {
5604 _marker: PhantomData,
5605 }
5606 }
5607}
5608impl Deref for CDOG1 {
5609 type Target = cdog0::RegisterBlock;
5610 #[inline(always)]
5611 fn deref(&self) -> &Self::Target {
5612 unsafe { &*Self::PTR }
5613 }
5614}
5615impl core::fmt::Debug for CDOG1 {
5616 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5617 f.debug_struct("CDOG1").finish()
5618 }
5619}
5620#[doc = "CDOG"]
5621pub use self::cdog0 as cdog1;
5622#[doc = "DBGMB"]
5623pub struct DM0 {
5624 _marker: PhantomData<*const ()>,
5625}
5626unsafe impl Send for DM0 {}
5627impl DM0 {
5628 #[doc = r"Pointer to the register block"]
5629 pub const PTR: *const dm0::RegisterBlock = 0x400b_d000 as *const _;
5630 #[doc = r"Return the pointer to the register block"]
5631 #[inline(always)]
5632 pub const fn ptr() -> *const dm0::RegisterBlock {
5633 Self::PTR
5634 }
5635 #[doc = r" Steal an instance of this peripheral"]
5636 #[doc = r""]
5637 #[doc = r" # Safety"]
5638 #[doc = r""]
5639 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5640 #[doc = r" that may race with any existing instances, for example by only"]
5641 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5642 #[doc = r" original peripheral and using critical sections to coordinate"]
5643 #[doc = r" access between multiple new instances."]
5644 #[doc = r""]
5645 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5646 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5647 #[doc = r" no stolen instances are passed to such software."]
5648 pub unsafe fn steal() -> Self {
5649 Self {
5650 _marker: PhantomData,
5651 }
5652 }
5653}
5654impl Deref for DM0 {
5655 type Target = dm0::RegisterBlock;
5656 #[inline(always)]
5657 fn deref(&self) -> &Self::Target {
5658 unsafe { &*Self::PTR }
5659 }
5660}
5661impl core::fmt::Debug for DM0 {
5662 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5663 f.debug_struct("DM0").finish()
5664 }
5665}
5666#[doc = "DBGMB"]
5667pub mod dm0;
5668#[doc = "PowerQuad"]
5669pub struct POWERQUAD {
5670 _marker: PhantomData<*const ()>,
5671}
5672unsafe impl Send for POWERQUAD {}
5673impl POWERQUAD {
5674 #[doc = r"Pointer to the register block"]
5675 pub const PTR: *const powerquad::RegisterBlock = 0x400b_f000 as *const _;
5676 #[doc = r"Return the pointer to the register block"]
5677 #[inline(always)]
5678 pub const fn ptr() -> *const powerquad::RegisterBlock {
5679 Self::PTR
5680 }
5681 #[doc = r" Steal an instance of this peripheral"]
5682 #[doc = r""]
5683 #[doc = r" # Safety"]
5684 #[doc = r""]
5685 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5686 #[doc = r" that may race with any existing instances, for example by only"]
5687 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5688 #[doc = r" original peripheral and using critical sections to coordinate"]
5689 #[doc = r" access between multiple new instances."]
5690 #[doc = r""]
5691 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5692 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5693 #[doc = r" no stolen instances are passed to such software."]
5694 pub unsafe fn steal() -> Self {
5695 Self {
5696 _marker: PhantomData,
5697 }
5698 }
5699}
5700impl Deref for POWERQUAD {
5701 type Target = powerquad::RegisterBlock;
5702 #[inline(always)]
5703 fn deref(&self) -> &Self::Target {
5704 unsafe { &*Self::PTR }
5705 }
5706}
5707impl core::fmt::Debug for POWERQUAD {
5708 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5709 f.debug_struct("POWERQUAD").finish()
5710 }
5711}
5712#[doc = "PowerQuad"]
5713pub mod powerquad;
5714#[doc = "EWM"]
5715pub struct EWM0 {
5716 _marker: PhantomData<*const ()>,
5717}
5718unsafe impl Send for EWM0 {}
5719impl EWM0 {
5720 #[doc = r"Pointer to the register block"]
5721 pub const PTR: *const ewm0::RegisterBlock = 0x400c_0000 as *const _;
5722 #[doc = r"Return the pointer to the register block"]
5723 #[inline(always)]
5724 pub const fn ptr() -> *const ewm0::RegisterBlock {
5725 Self::PTR
5726 }
5727 #[doc = r" Steal an instance of this peripheral"]
5728 #[doc = r""]
5729 #[doc = r" # Safety"]
5730 #[doc = r""]
5731 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5732 #[doc = r" that may race with any existing instances, for example by only"]
5733 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5734 #[doc = r" original peripheral and using critical sections to coordinate"]
5735 #[doc = r" access between multiple new instances."]
5736 #[doc = r""]
5737 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5738 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5739 #[doc = r" no stolen instances are passed to such software."]
5740 pub unsafe fn steal() -> Self {
5741 Self {
5742 _marker: PhantomData,
5743 }
5744 }
5745}
5746impl Deref for EWM0 {
5747 type Target = ewm0::RegisterBlock;
5748 #[inline(always)]
5749 fn deref(&self) -> &Self::Target {
5750 unsafe { &*Self::PTR }
5751 }
5752}
5753impl core::fmt::Debug for EWM0 {
5754 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5755 f.debug_struct("EWM0").finish()
5756 }
5757}
5758#[doc = "EWM"]
5759pub mod ewm0;
5760#[doc = "CMX_PERFMON"]
5761pub struct CMX_PERFMON0 {
5762 _marker: PhantomData<*const ()>,
5763}
5764unsafe impl Send for CMX_PERFMON0 {}
5765impl CMX_PERFMON0 {
5766 #[doc = r"Pointer to the register block"]
5767 pub const PTR: *const cmx_perfmon0::RegisterBlock = 0x400c_1000 as *const _;
5768 #[doc = r"Return the pointer to the register block"]
5769 #[inline(always)]
5770 pub const fn ptr() -> *const cmx_perfmon0::RegisterBlock {
5771 Self::PTR
5772 }
5773 #[doc = r" Steal an instance of this peripheral"]
5774 #[doc = r""]
5775 #[doc = r" # Safety"]
5776 #[doc = r""]
5777 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5778 #[doc = r" that may race with any existing instances, for example by only"]
5779 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5780 #[doc = r" original peripheral and using critical sections to coordinate"]
5781 #[doc = r" access between multiple new instances."]
5782 #[doc = r""]
5783 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5784 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5785 #[doc = r" no stolen instances are passed to such software."]
5786 pub unsafe fn steal() -> Self {
5787 Self {
5788 _marker: PhantomData,
5789 }
5790 }
5791}
5792impl Deref for CMX_PERFMON0 {
5793 type Target = cmx_perfmon0::RegisterBlock;
5794 #[inline(always)]
5795 fn deref(&self) -> &Self::Target {
5796 unsafe { &*Self::PTR }
5797 }
5798}
5799impl core::fmt::Debug for CMX_PERFMON0 {
5800 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5801 f.debug_struct("CMX_PERFMON0").finish()
5802 }
5803}
5804#[doc = "CMX_PERFMON"]
5805pub mod cmx_perfmon0;
5806#[doc = "CMX_PERFMON"]
5807pub struct CMX_PERFMON1 {
5808 _marker: PhantomData<*const ()>,
5809}
5810unsafe impl Send for CMX_PERFMON1 {}
5811impl CMX_PERFMON1 {
5812 #[doc = r"Pointer to the register block"]
5813 pub const PTR: *const cmx_perfmon0::RegisterBlock = 0x400c_2000 as *const _;
5814 #[doc = r"Return the pointer to the register block"]
5815 #[inline(always)]
5816 pub const fn ptr() -> *const cmx_perfmon0::RegisterBlock {
5817 Self::PTR
5818 }
5819 #[doc = r" Steal an instance of this peripheral"]
5820 #[doc = r""]
5821 #[doc = r" # Safety"]
5822 #[doc = r""]
5823 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5824 #[doc = r" that may race with any existing instances, for example by only"]
5825 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5826 #[doc = r" original peripheral and using critical sections to coordinate"]
5827 #[doc = r" access between multiple new instances."]
5828 #[doc = r""]
5829 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5830 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5831 #[doc = r" no stolen instances are passed to such software."]
5832 pub unsafe fn steal() -> Self {
5833 Self {
5834 _marker: PhantomData,
5835 }
5836 }
5837}
5838impl Deref for CMX_PERFMON1 {
5839 type Target = cmx_perfmon0::RegisterBlock;
5840 #[inline(always)]
5841 fn deref(&self) -> &Self::Target {
5842 unsafe { &*Self::PTR }
5843 }
5844}
5845impl core::fmt::Debug for CMX_PERFMON1 {
5846 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5847 f.debug_struct("CMX_PERFMON1").finish()
5848 }
5849}
5850#[doc = "CMX_PERFMON"]
5851pub use self::cmx_perfmon0 as cmx_perfmon1;
5852#[doc = "TRDC"]
5853pub struct TRDC {
5854 _marker: PhantomData<*const ()>,
5855}
5856unsafe impl Send for TRDC {}
5857impl TRDC {
5858 #[doc = r"Pointer to the register block"]
5859 pub const PTR: *const trdc::RegisterBlock = 0x400c_6000 as *const _;
5860 #[doc = r"Return the pointer to the register block"]
5861 #[inline(always)]
5862 pub const fn ptr() -> *const trdc::RegisterBlock {
5863 Self::PTR
5864 }
5865 #[doc = r" Steal an instance of this peripheral"]
5866 #[doc = r""]
5867 #[doc = r" # Safety"]
5868 #[doc = r""]
5869 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5870 #[doc = r" that may race with any existing instances, for example by only"]
5871 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5872 #[doc = r" original peripheral and using critical sections to coordinate"]
5873 #[doc = r" access between multiple new instances."]
5874 #[doc = r""]
5875 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5876 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5877 #[doc = r" no stolen instances are passed to such software."]
5878 pub unsafe fn steal() -> Self {
5879 Self {
5880 _marker: PhantomData,
5881 }
5882 }
5883}
5884impl Deref for TRDC {
5885 type Target = trdc::RegisterBlock;
5886 #[inline(always)]
5887 fn deref(&self) -> &Self::Target {
5888 unsafe { &*Self::PTR }
5889 }
5890}
5891impl core::fmt::Debug for TRDC {
5892 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5893 f.debug_struct("TRDC").finish()
5894 }
5895}
5896#[doc = "TRDC"]
5897pub mod trdc;
5898#[doc = "FlexSPI"]
5899pub struct FLEXSPI0 {
5900 _marker: PhantomData<*const ()>,
5901}
5902unsafe impl Send for FLEXSPI0 {}
5903impl FLEXSPI0 {
5904 #[doc = r"Pointer to the register block"]
5905 pub const PTR: *const flexspi0::RegisterBlock = 0x400c_8000 as *const _;
5906 #[doc = r"Return the pointer to the register block"]
5907 #[inline(always)]
5908 pub const fn ptr() -> *const flexspi0::RegisterBlock {
5909 Self::PTR
5910 }
5911 #[doc = r" Steal an instance of this peripheral"]
5912 #[doc = r""]
5913 #[doc = r" # Safety"]
5914 #[doc = r""]
5915 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5916 #[doc = r" that may race with any existing instances, for example by only"]
5917 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5918 #[doc = r" original peripheral and using critical sections to coordinate"]
5919 #[doc = r" access between multiple new instances."]
5920 #[doc = r""]
5921 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5922 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5923 #[doc = r" no stolen instances are passed to such software."]
5924 pub unsafe fn steal() -> Self {
5925 Self {
5926 _marker: PhantomData,
5927 }
5928 }
5929}
5930impl Deref for FLEXSPI0 {
5931 type Target = flexspi0::RegisterBlock;
5932 #[inline(always)]
5933 fn deref(&self) -> &Self::Target {
5934 unsafe { &*Self::PTR }
5935 }
5936}
5937impl core::fmt::Debug for FLEXSPI0 {
5938 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5939 f.debug_struct("FLEXSPI0").finish()
5940 }
5941}
5942#[doc = "FlexSPI"]
5943pub mod flexspi0;
5944#[doc = "OTPC"]
5945pub struct OTPC0 {
5946 _marker: PhantomData<*const ()>,
5947}
5948unsafe impl Send for OTPC0 {}
5949impl OTPC0 {
5950 #[doc = r"Pointer to the register block"]
5951 pub const PTR: *const otpc0::RegisterBlock = 0x400c_9000 as *const _;
5952 #[doc = r"Return the pointer to the register block"]
5953 #[inline(always)]
5954 pub const fn ptr() -> *const otpc0::RegisterBlock {
5955 Self::PTR
5956 }
5957 #[doc = r" Steal an instance of this peripheral"]
5958 #[doc = r""]
5959 #[doc = r" # Safety"]
5960 #[doc = r""]
5961 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5962 #[doc = r" that may race with any existing instances, for example by only"]
5963 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5964 #[doc = r" original peripheral and using critical sections to coordinate"]
5965 #[doc = r" access between multiple new instances."]
5966 #[doc = r""]
5967 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5968 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5969 #[doc = r" no stolen instances are passed to such software."]
5970 pub unsafe fn steal() -> Self {
5971 Self {
5972 _marker: PhantomData,
5973 }
5974 }
5975}
5976impl Deref for OTPC0 {
5977 type Target = otpc0::RegisterBlock;
5978 #[inline(always)]
5979 fn deref(&self) -> &Self::Target {
5980 unsafe { &*Self::PTR }
5981 }
5982}
5983impl core::fmt::Debug for OTPC0 {
5984 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5985 f.debug_struct("OTPC0").finish()
5986 }
5987}
5988#[doc = "OTPC"]
5989pub mod otpc0;
5990#[doc = "CRC"]
5991pub struct CRC0 {
5992 _marker: PhantomData<*const ()>,
5993}
5994unsafe impl Send for CRC0 {}
5995impl CRC0 {
5996 #[doc = r"Pointer to the register block"]
5997 pub const PTR: *const crc0::RegisterBlock = 0x400c_b000 as *const _;
5998 #[doc = r"Return the pointer to the register block"]
5999 #[inline(always)]
6000 pub const fn ptr() -> *const crc0::RegisterBlock {
6001 Self::PTR
6002 }
6003 #[doc = r" Steal an instance of this peripheral"]
6004 #[doc = r""]
6005 #[doc = r" # Safety"]
6006 #[doc = r""]
6007 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6008 #[doc = r" that may race with any existing instances, for example by only"]
6009 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6010 #[doc = r" original peripheral and using critical sections to coordinate"]
6011 #[doc = r" access between multiple new instances."]
6012 #[doc = r""]
6013 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6014 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6015 #[doc = r" no stolen instances are passed to such software."]
6016 pub unsafe fn steal() -> Self {
6017 Self {
6018 _marker: PhantomData,
6019 }
6020 }
6021}
6022impl Deref for CRC0 {
6023 type Target = crc0::RegisterBlock;
6024 #[inline(always)]
6025 fn deref(&self) -> &Self::Target {
6026 unsafe { &*Self::PTR }
6027 }
6028}
6029impl core::fmt::Debug for CRC0 {
6030 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6031 f.debug_struct("CRC0").finish()
6032 }
6033}
6034#[doc = "CRC"]
6035pub mod crc0;
6036#[doc = "FMC"]
6037pub struct NPX0 {
6038 _marker: PhantomData<*const ()>,
6039}
6040unsafe impl Send for NPX0 {}
6041impl NPX0 {
6042 #[doc = r"Pointer to the register block"]
6043 pub const PTR: *const npx0::RegisterBlock = 0x400c_c000 as *const _;
6044 #[doc = r"Return the pointer to the register block"]
6045 #[inline(always)]
6046 pub const fn ptr() -> *const npx0::RegisterBlock {
6047 Self::PTR
6048 }
6049 #[doc = r" Steal an instance of this peripheral"]
6050 #[doc = r""]
6051 #[doc = r" # Safety"]
6052 #[doc = r""]
6053 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6054 #[doc = r" that may race with any existing instances, for example by only"]
6055 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6056 #[doc = r" original peripheral and using critical sections to coordinate"]
6057 #[doc = r" access between multiple new instances."]
6058 #[doc = r""]
6059 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6060 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6061 #[doc = r" no stolen instances are passed to such software."]
6062 pub unsafe fn steal() -> Self {
6063 Self {
6064 _marker: PhantomData,
6065 }
6066 }
6067}
6068impl Deref for NPX0 {
6069 type Target = npx0::RegisterBlock;
6070 #[inline(always)]
6071 fn deref(&self) -> &Self::Target {
6072 unsafe { &*Self::PTR }
6073 }
6074}
6075impl core::fmt::Debug for NPX0 {
6076 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6077 f.debug_struct("NPX0").finish()
6078 }
6079}
6080#[doc = "FMC"]
6081pub mod npx0;
6082#[doc = "PWM"]
6083pub struct PWM0 {
6084 _marker: PhantomData<*const ()>,
6085}
6086unsafe impl Send for PWM0 {}
6087impl PWM0 {
6088 #[doc = r"Pointer to the register block"]
6089 pub const PTR: *const pwm0::RegisterBlock = 0x400c_e000 as *const _;
6090 #[doc = r"Return the pointer to the register block"]
6091 #[inline(always)]
6092 pub const fn ptr() -> *const pwm0::RegisterBlock {
6093 Self::PTR
6094 }
6095 #[doc = r" Steal an instance of this peripheral"]
6096 #[doc = r""]
6097 #[doc = r" # Safety"]
6098 #[doc = r""]
6099 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6100 #[doc = r" that may race with any existing instances, for example by only"]
6101 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6102 #[doc = r" original peripheral and using critical sections to coordinate"]
6103 #[doc = r" access between multiple new instances."]
6104 #[doc = r""]
6105 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6106 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6107 #[doc = r" no stolen instances are passed to such software."]
6108 pub unsafe fn steal() -> Self {
6109 Self {
6110 _marker: PhantomData,
6111 }
6112 }
6113}
6114impl Deref for PWM0 {
6115 type Target = pwm0::RegisterBlock;
6116 #[inline(always)]
6117 fn deref(&self) -> &Self::Target {
6118 unsafe { &*Self::PTR }
6119 }
6120}
6121impl core::fmt::Debug for PWM0 {
6122 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6123 f.debug_struct("PWM0").finish()
6124 }
6125}
6126#[doc = "PWM"]
6127pub mod pwm0;
6128#[doc = "PWM"]
6129pub struct PWM1 {
6130 _marker: PhantomData<*const ()>,
6131}
6132unsafe impl Send for PWM1 {}
6133impl PWM1 {
6134 #[doc = r"Pointer to the register block"]
6135 pub const PTR: *const pwm0::RegisterBlock = 0x400d_0000 as *const _;
6136 #[doc = r"Return the pointer to the register block"]
6137 #[inline(always)]
6138 pub const fn ptr() -> *const pwm0::RegisterBlock {
6139 Self::PTR
6140 }
6141 #[doc = r" Steal an instance of this peripheral"]
6142 #[doc = r""]
6143 #[doc = r" # Safety"]
6144 #[doc = r""]
6145 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6146 #[doc = r" that may race with any existing instances, for example by only"]
6147 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6148 #[doc = r" original peripheral and using critical sections to coordinate"]
6149 #[doc = r" access between multiple new instances."]
6150 #[doc = r""]
6151 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6152 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6153 #[doc = r" no stolen instances are passed to such software."]
6154 pub unsafe fn steal() -> Self {
6155 Self {
6156 _marker: PhantomData,
6157 }
6158 }
6159}
6160impl Deref for PWM1 {
6161 type Target = pwm0::RegisterBlock;
6162 #[inline(always)]
6163 fn deref(&self) -> &Self::Target {
6164 unsafe { &*Self::PTR }
6165 }
6166}
6167impl core::fmt::Debug for PWM1 {
6168 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6169 f.debug_struct("PWM1").finish()
6170 }
6171}
6172#[doc = "PWM"]
6173pub use self::pwm0 as pwm1;
6174#[doc = "ENC"]
6175pub struct ENC0 {
6176 _marker: PhantomData<*const ()>,
6177}
6178unsafe impl Send for ENC0 {}
6179impl ENC0 {
6180 #[doc = r"Pointer to the register block"]
6181 pub const PTR: *const enc0::RegisterBlock = 0x400c_f000 as *const _;
6182 #[doc = r"Return the pointer to the register block"]
6183 #[inline(always)]
6184 pub const fn ptr() -> *const enc0::RegisterBlock {
6185 Self::PTR
6186 }
6187 #[doc = r" Steal an instance of this peripheral"]
6188 #[doc = r""]
6189 #[doc = r" # Safety"]
6190 #[doc = r""]
6191 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6192 #[doc = r" that may race with any existing instances, for example by only"]
6193 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6194 #[doc = r" original peripheral and using critical sections to coordinate"]
6195 #[doc = r" access between multiple new instances."]
6196 #[doc = r""]
6197 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6198 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6199 #[doc = r" no stolen instances are passed to such software."]
6200 pub unsafe fn steal() -> Self {
6201 Self {
6202 _marker: PhantomData,
6203 }
6204 }
6205}
6206impl Deref for ENC0 {
6207 type Target = enc0::RegisterBlock;
6208 #[inline(always)]
6209 fn deref(&self) -> &Self::Target {
6210 unsafe { &*Self::PTR }
6211 }
6212}
6213impl core::fmt::Debug for ENC0 {
6214 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6215 f.debug_struct("ENC0").finish()
6216 }
6217}
6218#[doc = "ENC"]
6219pub mod enc0;
6220#[doc = "ENC"]
6221pub struct ENC1 {
6222 _marker: PhantomData<*const ()>,
6223}
6224unsafe impl Send for ENC1 {}
6225impl ENC1 {
6226 #[doc = r"Pointer to the register block"]
6227 pub const PTR: *const enc0::RegisterBlock = 0x400d_1000 as *const _;
6228 #[doc = r"Return the pointer to the register block"]
6229 #[inline(always)]
6230 pub const fn ptr() -> *const enc0::RegisterBlock {
6231 Self::PTR
6232 }
6233 #[doc = r" Steal an instance of this peripheral"]
6234 #[doc = r""]
6235 #[doc = r" # Safety"]
6236 #[doc = r""]
6237 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6238 #[doc = r" that may race with any existing instances, for example by only"]
6239 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6240 #[doc = r" original peripheral and using critical sections to coordinate"]
6241 #[doc = r" access between multiple new instances."]
6242 #[doc = r""]
6243 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6244 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6245 #[doc = r" no stolen instances are passed to such software."]
6246 pub unsafe fn steal() -> Self {
6247 Self {
6248 _marker: PhantomData,
6249 }
6250 }
6251}
6252impl Deref for ENC1 {
6253 type Target = enc0::RegisterBlock;
6254 #[inline(always)]
6255 fn deref(&self) -> &Self::Target {
6256 unsafe { &*Self::PTR }
6257 }
6258}
6259impl core::fmt::Debug for ENC1 {
6260 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6261 f.debug_struct("ENC1").finish()
6262 }
6263}
6264#[doc = "ENC"]
6265pub use self::enc0 as enc1;
6266#[doc = "EVTG"]
6267pub struct EVTG0 {
6268 _marker: PhantomData<*const ()>,
6269}
6270unsafe impl Send for EVTG0 {}
6271impl EVTG0 {
6272 #[doc = r"Pointer to the register block"]
6273 pub const PTR: *const evtg0::RegisterBlock = 0x400d_2000 as *const _;
6274 #[doc = r"Return the pointer to the register block"]
6275 #[inline(always)]
6276 pub const fn ptr() -> *const evtg0::RegisterBlock {
6277 Self::PTR
6278 }
6279 #[doc = r" Steal an instance of this peripheral"]
6280 #[doc = r""]
6281 #[doc = r" # Safety"]
6282 #[doc = r""]
6283 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6284 #[doc = r" that may race with any existing instances, for example by only"]
6285 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6286 #[doc = r" original peripheral and using critical sections to coordinate"]
6287 #[doc = r" access between multiple new instances."]
6288 #[doc = r""]
6289 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6290 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6291 #[doc = r" no stolen instances are passed to such software."]
6292 pub unsafe fn steal() -> Self {
6293 Self {
6294 _marker: PhantomData,
6295 }
6296 }
6297}
6298impl Deref for EVTG0 {
6299 type Target = evtg0::RegisterBlock;
6300 #[inline(always)]
6301 fn deref(&self) -> &Self::Target {
6302 unsafe { &*Self::PTR }
6303 }
6304}
6305impl core::fmt::Debug for EVTG0 {
6306 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6307 f.debug_struct("EVTG0").finish()
6308 }
6309}
6310#[doc = "EVTG"]
6311pub mod evtg0;
6312#[doc = "CAN"]
6313pub struct CAN0 {
6314 _marker: PhantomData<*const ()>,
6315}
6316unsafe impl Send for CAN0 {}
6317impl CAN0 {
6318 #[doc = r"Pointer to the register block"]
6319 pub const PTR: *const can0::RegisterBlock = 0x400d_4000 as *const _;
6320 #[doc = r"Return the pointer to the register block"]
6321 #[inline(always)]
6322 pub const fn ptr() -> *const can0::RegisterBlock {
6323 Self::PTR
6324 }
6325 #[doc = r" Steal an instance of this peripheral"]
6326 #[doc = r""]
6327 #[doc = r" # Safety"]
6328 #[doc = r""]
6329 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6330 #[doc = r" that may race with any existing instances, for example by only"]
6331 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6332 #[doc = r" original peripheral and using critical sections to coordinate"]
6333 #[doc = r" access between multiple new instances."]
6334 #[doc = r""]
6335 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6336 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6337 #[doc = r" no stolen instances are passed to such software."]
6338 pub unsafe fn steal() -> Self {
6339 Self {
6340 _marker: PhantomData,
6341 }
6342 }
6343}
6344impl Deref for CAN0 {
6345 type Target = can0::RegisterBlock;
6346 #[inline(always)]
6347 fn deref(&self) -> &Self::Target {
6348 unsafe { &*Self::PTR }
6349 }
6350}
6351impl core::fmt::Debug for CAN0 {
6352 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6353 f.debug_struct("CAN0").finish()
6354 }
6355}
6356#[doc = "CAN"]
6357pub mod can0;
6358#[doc = "CAN"]
6359pub struct CAN1 {
6360 _marker: PhantomData<*const ()>,
6361}
6362unsafe impl Send for CAN1 {}
6363impl CAN1 {
6364 #[doc = r"Pointer to the register block"]
6365 pub const PTR: *const can0::RegisterBlock = 0x400d_8000 as *const _;
6366 #[doc = r"Return the pointer to the register block"]
6367 #[inline(always)]
6368 pub const fn ptr() -> *const can0::RegisterBlock {
6369 Self::PTR
6370 }
6371 #[doc = r" Steal an instance of this peripheral"]
6372 #[doc = r""]
6373 #[doc = r" # Safety"]
6374 #[doc = r""]
6375 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6376 #[doc = r" that may race with any existing instances, for example by only"]
6377 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6378 #[doc = r" original peripheral and using critical sections to coordinate"]
6379 #[doc = r" access between multiple new instances."]
6380 #[doc = r""]
6381 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6382 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6383 #[doc = r" no stolen instances are passed to such software."]
6384 pub unsafe fn steal() -> Self {
6385 Self {
6386 _marker: PhantomData,
6387 }
6388 }
6389}
6390impl Deref for CAN1 {
6391 type Target = can0::RegisterBlock;
6392 #[inline(always)]
6393 fn deref(&self) -> &Self::Target {
6394 unsafe { &*Self::PTR }
6395 }
6396}
6397impl core::fmt::Debug for CAN1 {
6398 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6399 f.debug_struct("CAN1").finish()
6400 }
6401}
6402#[doc = "CAN"]
6403pub use self::can0 as can1;
6404#[doc = "USBDCD"]
6405pub struct USBDCD0 {
6406 _marker: PhantomData<*const ()>,
6407}
6408unsafe impl Send for USBDCD0 {}
6409impl USBDCD0 {
6410 #[doc = r"Pointer to the register block"]
6411 pub const PTR: *const usbdcd0::RegisterBlock = 0x400d_c000 as *const _;
6412 #[doc = r"Return the pointer to the register block"]
6413 #[inline(always)]
6414 pub const fn ptr() -> *const usbdcd0::RegisterBlock {
6415 Self::PTR
6416 }
6417 #[doc = r" Steal an instance of this peripheral"]
6418 #[doc = r""]
6419 #[doc = r" # Safety"]
6420 #[doc = r""]
6421 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6422 #[doc = r" that may race with any existing instances, for example by only"]
6423 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6424 #[doc = r" original peripheral and using critical sections to coordinate"]
6425 #[doc = r" access between multiple new instances."]
6426 #[doc = r""]
6427 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6428 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6429 #[doc = r" no stolen instances are passed to such software."]
6430 pub unsafe fn steal() -> Self {
6431 Self {
6432 _marker: PhantomData,
6433 }
6434 }
6435}
6436impl Deref for USBDCD0 {
6437 type Target = usbdcd0::RegisterBlock;
6438 #[inline(always)]
6439 fn deref(&self) -> &Self::Target {
6440 unsafe { &*Self::PTR }
6441 }
6442}
6443impl core::fmt::Debug for USBDCD0 {
6444 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6445 f.debug_struct("USBDCD0").finish()
6446 }
6447}
6448#[doc = "USBDCD"]
6449pub mod usbdcd0;
6450#[doc = "USBFS"]
6451pub struct USBFS0 {
6452 _marker: PhantomData<*const ()>,
6453}
6454unsafe impl Send for USBFS0 {}
6455impl USBFS0 {
6456 #[doc = r"Pointer to the register block"]
6457 pub const PTR: *const usbfs0::RegisterBlock = 0x400d_d000 as *const _;
6458 #[doc = r"Return the pointer to the register block"]
6459 #[inline(always)]
6460 pub const fn ptr() -> *const usbfs0::RegisterBlock {
6461 Self::PTR
6462 }
6463 #[doc = r" Steal an instance of this peripheral"]
6464 #[doc = r""]
6465 #[doc = r" # Safety"]
6466 #[doc = r""]
6467 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6468 #[doc = r" that may race with any existing instances, for example by only"]
6469 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6470 #[doc = r" original peripheral and using critical sections to coordinate"]
6471 #[doc = r" access between multiple new instances."]
6472 #[doc = r""]
6473 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6474 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6475 #[doc = r" no stolen instances are passed to such software."]
6476 pub unsafe fn steal() -> Self {
6477 Self {
6478 _marker: PhantomData,
6479 }
6480 }
6481}
6482impl Deref for USBFS0 {
6483 type Target = usbfs0::RegisterBlock;
6484 #[inline(always)]
6485 fn deref(&self) -> &Self::Target {
6486 unsafe { &*Self::PTR }
6487 }
6488}
6489impl core::fmt::Debug for USBFS0 {
6490 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6491 f.debug_struct("USBFS0").finish()
6492 }
6493}
6494#[doc = "USBFS"]
6495pub mod usbfs0;
6496#[doc = "ENET"]
6497pub struct ENET0 {
6498 _marker: PhantomData<*const ()>,
6499}
6500unsafe impl Send for ENET0 {}
6501impl ENET0 {
6502 #[doc = r"Pointer to the register block"]
6503 pub const PTR: *const enet0::RegisterBlock = 0x4010_0000 as *const _;
6504 #[doc = r"Return the pointer to the register block"]
6505 #[inline(always)]
6506 pub const fn ptr() -> *const enet0::RegisterBlock {
6507 Self::PTR
6508 }
6509 #[doc = r" Steal an instance of this peripheral"]
6510 #[doc = r""]
6511 #[doc = r" # Safety"]
6512 #[doc = r""]
6513 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6514 #[doc = r" that may race with any existing instances, for example by only"]
6515 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6516 #[doc = r" original peripheral and using critical sections to coordinate"]
6517 #[doc = r" access between multiple new instances."]
6518 #[doc = r""]
6519 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6520 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6521 #[doc = r" no stolen instances are passed to such software."]
6522 pub unsafe fn steal() -> Self {
6523 Self {
6524 _marker: PhantomData,
6525 }
6526 }
6527}
6528impl Deref for ENET0 {
6529 type Target = enet0::RegisterBlock;
6530 #[inline(always)]
6531 fn deref(&self) -> &Self::Target {
6532 unsafe { &*Self::PTR }
6533 }
6534}
6535impl core::fmt::Debug for ENET0 {
6536 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6537 f.debug_struct("ENET0").finish()
6538 }
6539}
6540#[doc = "ENET"]
6541pub mod enet0;
6542#[doc = "EMVSIM"]
6543pub struct EMVSIM0 {
6544 _marker: PhantomData<*const ()>,
6545}
6546unsafe impl Send for EMVSIM0 {}
6547impl EMVSIM0 {
6548 #[doc = r"Pointer to the register block"]
6549 pub const PTR: *const emvsim0::RegisterBlock = 0x4010_3000 as *const _;
6550 #[doc = r"Return the pointer to the register block"]
6551 #[inline(always)]
6552 pub const fn ptr() -> *const emvsim0::RegisterBlock {
6553 Self::PTR
6554 }
6555 #[doc = r" Steal an instance of this peripheral"]
6556 #[doc = r""]
6557 #[doc = r" # Safety"]
6558 #[doc = r""]
6559 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6560 #[doc = r" that may race with any existing instances, for example by only"]
6561 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6562 #[doc = r" original peripheral and using critical sections to coordinate"]
6563 #[doc = r" access between multiple new instances."]
6564 #[doc = r""]
6565 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6566 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6567 #[doc = r" no stolen instances are passed to such software."]
6568 pub unsafe fn steal() -> Self {
6569 Self {
6570 _marker: PhantomData,
6571 }
6572 }
6573}
6574impl Deref for EMVSIM0 {
6575 type Target = emvsim0::RegisterBlock;
6576 #[inline(always)]
6577 fn deref(&self) -> &Self::Target {
6578 unsafe { &*Self::PTR }
6579 }
6580}
6581impl core::fmt::Debug for EMVSIM0 {
6582 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6583 f.debug_struct("EMVSIM0").finish()
6584 }
6585}
6586#[doc = "EMVSIM"]
6587pub mod emvsim0;
6588#[doc = "EMVSIM"]
6589pub struct EMVSIM1 {
6590 _marker: PhantomData<*const ()>,
6591}
6592unsafe impl Send for EMVSIM1 {}
6593impl EMVSIM1 {
6594 #[doc = r"Pointer to the register block"]
6595 pub const PTR: *const emvsim0::RegisterBlock = 0x4010_4000 as *const _;
6596 #[doc = r"Return the pointer to the register block"]
6597 #[inline(always)]
6598 pub const fn ptr() -> *const emvsim0::RegisterBlock {
6599 Self::PTR
6600 }
6601 #[doc = r" Steal an instance of this peripheral"]
6602 #[doc = r""]
6603 #[doc = r" # Safety"]
6604 #[doc = r""]
6605 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6606 #[doc = r" that may race with any existing instances, for example by only"]
6607 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6608 #[doc = r" original peripheral and using critical sections to coordinate"]
6609 #[doc = r" access between multiple new instances."]
6610 #[doc = r""]
6611 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6612 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6613 #[doc = r" no stolen instances are passed to such software."]
6614 pub unsafe fn steal() -> Self {
6615 Self {
6616 _marker: PhantomData,
6617 }
6618 }
6619}
6620impl Deref for EMVSIM1 {
6621 type Target = emvsim0::RegisterBlock;
6622 #[inline(always)]
6623 fn deref(&self) -> &Self::Target {
6624 unsafe { &*Self::PTR }
6625 }
6626}
6627impl core::fmt::Debug for EMVSIM1 {
6628 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6629 f.debug_struct("EMVSIM1").finish()
6630 }
6631}
6632#[doc = "EMVSIM"]
6633pub use self::emvsim0 as emvsim1;
6634#[doc = "FLEXIO"]
6635pub struct FLEXIO0 {
6636 _marker: PhantomData<*const ()>,
6637}
6638unsafe impl Send for FLEXIO0 {}
6639impl FLEXIO0 {
6640 #[doc = r"Pointer to the register block"]
6641 pub const PTR: *const flexio0::RegisterBlock = 0x4010_5000 as *const _;
6642 #[doc = r"Return the pointer to the register block"]
6643 #[inline(always)]
6644 pub const fn ptr() -> *const flexio0::RegisterBlock {
6645 Self::PTR
6646 }
6647 #[doc = r" Steal an instance of this peripheral"]
6648 #[doc = r""]
6649 #[doc = r" # Safety"]
6650 #[doc = r""]
6651 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6652 #[doc = r" that may race with any existing instances, for example by only"]
6653 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6654 #[doc = r" original peripheral and using critical sections to coordinate"]
6655 #[doc = r" access between multiple new instances."]
6656 #[doc = r""]
6657 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6658 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6659 #[doc = r" no stolen instances are passed to such software."]
6660 pub unsafe fn steal() -> Self {
6661 Self {
6662 _marker: PhantomData,
6663 }
6664 }
6665}
6666impl Deref for FLEXIO0 {
6667 type Target = flexio0::RegisterBlock;
6668 #[inline(always)]
6669 fn deref(&self) -> &Self::Target {
6670 unsafe { &*Self::PTR }
6671 }
6672}
6673impl core::fmt::Debug for FLEXIO0 {
6674 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6675 f.debug_struct("FLEXIO0").finish()
6676 }
6677}
6678#[doc = "FLEXIO"]
6679pub mod flexio0;
6680#[doc = "SAI"]
6681pub struct SAI0 {
6682 _marker: PhantomData<*const ()>,
6683}
6684unsafe impl Send for SAI0 {}
6685impl SAI0 {
6686 #[doc = r"Pointer to the register block"]
6687 pub const PTR: *const sai0::RegisterBlock = 0x4010_6000 as *const _;
6688 #[doc = r"Return the pointer to the register block"]
6689 #[inline(always)]
6690 pub const fn ptr() -> *const sai0::RegisterBlock {
6691 Self::PTR
6692 }
6693 #[doc = r" Steal an instance of this peripheral"]
6694 #[doc = r""]
6695 #[doc = r" # Safety"]
6696 #[doc = r""]
6697 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6698 #[doc = r" that may race with any existing instances, for example by only"]
6699 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6700 #[doc = r" original peripheral and using critical sections to coordinate"]
6701 #[doc = r" access between multiple new instances."]
6702 #[doc = r""]
6703 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6704 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6705 #[doc = r" no stolen instances are passed to such software."]
6706 pub unsafe fn steal() -> Self {
6707 Self {
6708 _marker: PhantomData,
6709 }
6710 }
6711}
6712impl Deref for SAI0 {
6713 type Target = sai0::RegisterBlock;
6714 #[inline(always)]
6715 fn deref(&self) -> &Self::Target {
6716 unsafe { &*Self::PTR }
6717 }
6718}
6719impl core::fmt::Debug for SAI0 {
6720 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6721 f.debug_struct("SAI0").finish()
6722 }
6723}
6724#[doc = "SAI"]
6725pub mod sai0;
6726#[doc = "SAI"]
6727pub struct SAI1 {
6728 _marker: PhantomData<*const ()>,
6729}
6730unsafe impl Send for SAI1 {}
6731impl SAI1 {
6732 #[doc = r"Pointer to the register block"]
6733 pub const PTR: *const sai0::RegisterBlock = 0x4010_7000 as *const _;
6734 #[doc = r"Return the pointer to the register block"]
6735 #[inline(always)]
6736 pub const fn ptr() -> *const sai0::RegisterBlock {
6737 Self::PTR
6738 }
6739 #[doc = r" Steal an instance of this peripheral"]
6740 #[doc = r""]
6741 #[doc = r" # Safety"]
6742 #[doc = r""]
6743 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6744 #[doc = r" that may race with any existing instances, for example by only"]
6745 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6746 #[doc = r" original peripheral and using critical sections to coordinate"]
6747 #[doc = r" access between multiple new instances."]
6748 #[doc = r""]
6749 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6750 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6751 #[doc = r" no stolen instances are passed to such software."]
6752 pub unsafe fn steal() -> Self {
6753 Self {
6754 _marker: PhantomData,
6755 }
6756 }
6757}
6758impl Deref for SAI1 {
6759 type Target = sai0::RegisterBlock;
6760 #[inline(always)]
6761 fn deref(&self) -> &Self::Target {
6762 unsafe { &*Self::PTR }
6763 }
6764}
6765impl core::fmt::Debug for SAI1 {
6766 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6767 f.debug_struct("SAI1").finish()
6768 }
6769}
6770#[doc = "SAI"]
6771pub use self::sai0 as sai1;
6772#[doc = "SINC"]
6773pub struct SINC0 {
6774 _marker: PhantomData<*const ()>,
6775}
6776unsafe impl Send for SINC0 {}
6777impl SINC0 {
6778 #[doc = r"Pointer to the register block"]
6779 pub const PTR: *const sinc0::RegisterBlock = 0x4010_8000 as *const _;
6780 #[doc = r"Return the pointer to the register block"]
6781 #[inline(always)]
6782 pub const fn ptr() -> *const sinc0::RegisterBlock {
6783 Self::PTR
6784 }
6785 #[doc = r" Steal an instance of this peripheral"]
6786 #[doc = r""]
6787 #[doc = r" # Safety"]
6788 #[doc = r""]
6789 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6790 #[doc = r" that may race with any existing instances, for example by only"]
6791 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6792 #[doc = r" original peripheral and using critical sections to coordinate"]
6793 #[doc = r" access between multiple new instances."]
6794 #[doc = r""]
6795 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6796 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6797 #[doc = r" no stolen instances are passed to such software."]
6798 pub unsafe fn steal() -> Self {
6799 Self {
6800 _marker: PhantomData,
6801 }
6802 }
6803}
6804impl Deref for SINC0 {
6805 type Target = sinc0::RegisterBlock;
6806 #[inline(always)]
6807 fn deref(&self) -> &Self::Target {
6808 unsafe { &*Self::PTR }
6809 }
6810}
6811impl core::fmt::Debug for SINC0 {
6812 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6813 f.debug_struct("SINC0").finish()
6814 }
6815}
6816#[doc = "SINC"]
6817pub mod sinc0;
6818#[doc = "uSDHC"]
6819pub struct USDHC0 {
6820 _marker: PhantomData<*const ()>,
6821}
6822unsafe impl Send for USDHC0 {}
6823impl USDHC0 {
6824 #[doc = r"Pointer to the register block"]
6825 pub const PTR: *const usdhc0::RegisterBlock = 0x4010_9000 as *const _;
6826 #[doc = r"Return the pointer to the register block"]
6827 #[inline(always)]
6828 pub const fn ptr() -> *const usdhc0::RegisterBlock {
6829 Self::PTR
6830 }
6831 #[doc = r" Steal an instance of this peripheral"]
6832 #[doc = r""]
6833 #[doc = r" # Safety"]
6834 #[doc = r""]
6835 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6836 #[doc = r" that may race with any existing instances, for example by only"]
6837 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6838 #[doc = r" original peripheral and using critical sections to coordinate"]
6839 #[doc = r" access between multiple new instances."]
6840 #[doc = r""]
6841 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6842 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6843 #[doc = r" no stolen instances are passed to such software."]
6844 pub unsafe fn steal() -> Self {
6845 Self {
6846 _marker: PhantomData,
6847 }
6848 }
6849}
6850impl Deref for USDHC0 {
6851 type Target = usdhc0::RegisterBlock;
6852 #[inline(always)]
6853 fn deref(&self) -> &Self::Target {
6854 unsafe { &*Self::PTR }
6855 }
6856}
6857impl core::fmt::Debug for USDHC0 {
6858 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6859 f.debug_struct("USDHC0").finish()
6860 }
6861}
6862#[doc = "uSDHC"]
6863pub mod usdhc0;
6864#[doc = "USBPHY"]
6865pub struct USBPHY {
6866 _marker: PhantomData<*const ()>,
6867}
6868unsafe impl Send for USBPHY {}
6869impl USBPHY {
6870 #[doc = r"Pointer to the register block"]
6871 pub const PTR: *const usbphy::RegisterBlock = 0x4010_a000 as *const _;
6872 #[doc = r"Return the pointer to the register block"]
6873 #[inline(always)]
6874 pub const fn ptr() -> *const usbphy::RegisterBlock {
6875 Self::PTR
6876 }
6877 #[doc = r" Steal an instance of this peripheral"]
6878 #[doc = r""]
6879 #[doc = r" # Safety"]
6880 #[doc = r""]
6881 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6882 #[doc = r" that may race with any existing instances, for example by only"]
6883 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6884 #[doc = r" original peripheral and using critical sections to coordinate"]
6885 #[doc = r" access between multiple new instances."]
6886 #[doc = r""]
6887 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6888 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6889 #[doc = r" no stolen instances are passed to such software."]
6890 pub unsafe fn steal() -> Self {
6891 Self {
6892 _marker: PhantomData,
6893 }
6894 }
6895}
6896impl Deref for USBPHY {
6897 type Target = usbphy::RegisterBlock;
6898 #[inline(always)]
6899 fn deref(&self) -> &Self::Target {
6900 unsafe { &*Self::PTR }
6901 }
6902}
6903impl core::fmt::Debug for USBPHY {
6904 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6905 f.debug_struct("USBPHY").finish()
6906 }
6907}
6908#[doc = "USBPHY"]
6909pub mod usbphy;
6910#[doc = "USBDCD"]
6911pub struct USBHS1_PHY_DCD {
6912 _marker: PhantomData<*const ()>,
6913}
6914unsafe impl Send for USBHS1_PHY_DCD {}
6915impl USBHS1_PHY_DCD {
6916 #[doc = r"Pointer to the register block"]
6917 pub const PTR: *const usbhs1_phy_dcd::RegisterBlock = 0x4010_a800 as *const _;
6918 #[doc = r"Return the pointer to the register block"]
6919 #[inline(always)]
6920 pub const fn ptr() -> *const usbhs1_phy_dcd::RegisterBlock {
6921 Self::PTR
6922 }
6923 #[doc = r" Steal an instance of this peripheral"]
6924 #[doc = r""]
6925 #[doc = r" # Safety"]
6926 #[doc = r""]
6927 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6928 #[doc = r" that may race with any existing instances, for example by only"]
6929 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6930 #[doc = r" original peripheral and using critical sections to coordinate"]
6931 #[doc = r" access between multiple new instances."]
6932 #[doc = r""]
6933 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6934 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6935 #[doc = r" no stolen instances are passed to such software."]
6936 pub unsafe fn steal() -> Self {
6937 Self {
6938 _marker: PhantomData,
6939 }
6940 }
6941}
6942impl Deref for USBHS1_PHY_DCD {
6943 type Target = usbhs1_phy_dcd::RegisterBlock;
6944 #[inline(always)]
6945 fn deref(&self) -> &Self::Target {
6946 unsafe { &*Self::PTR }
6947 }
6948}
6949impl core::fmt::Debug for USBHS1_PHY_DCD {
6950 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6951 f.debug_struct("USBHS1_PHY_DCD").finish()
6952 }
6953}
6954#[doc = "USBDCD"]
6955pub mod usbhs1_phy_dcd;
6956#[doc = "USB"]
6957pub struct USBHS1__USBC {
6958 _marker: PhantomData<*const ()>,
6959}
6960unsafe impl Send for USBHS1__USBC {}
6961impl USBHS1__USBC {
6962 #[doc = r"Pointer to the register block"]
6963 pub const PTR: *const usbhs1__usbc::RegisterBlock = 0x4010_b000 as *const _;
6964 #[doc = r"Return the pointer to the register block"]
6965 #[inline(always)]
6966 pub const fn ptr() -> *const usbhs1__usbc::RegisterBlock {
6967 Self::PTR
6968 }
6969 #[doc = r" Steal an instance of this peripheral"]
6970 #[doc = r""]
6971 #[doc = r" # Safety"]
6972 #[doc = r""]
6973 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6974 #[doc = r" that may race with any existing instances, for example by only"]
6975 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6976 #[doc = r" original peripheral and using critical sections to coordinate"]
6977 #[doc = r" access between multiple new instances."]
6978 #[doc = r""]
6979 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6980 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6981 #[doc = r" no stolen instances are passed to such software."]
6982 pub unsafe fn steal() -> Self {
6983 Self {
6984 _marker: PhantomData,
6985 }
6986 }
6987}
6988impl Deref for USBHS1__USBC {
6989 type Target = usbhs1__usbc::RegisterBlock;
6990 #[inline(always)]
6991 fn deref(&self) -> &Self::Target {
6992 unsafe { &*Self::PTR }
6993 }
6994}
6995impl core::fmt::Debug for USBHS1__USBC {
6996 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6997 f.debug_struct("USBHS1__USBC").finish()
6998 }
6999}
7000#[doc = "USB"]
7001pub mod usbhs1__usbc;
7002#[doc = "USBNC"]
7003pub struct USBHS1__USBNC {
7004 _marker: PhantomData<*const ()>,
7005}
7006unsafe impl Send for USBHS1__USBNC {}
7007impl USBHS1__USBNC {
7008 #[doc = r"Pointer to the register block"]
7009 pub const PTR: *const usbhs1__usbnc::RegisterBlock = 0x4010_b200 as *const _;
7010 #[doc = r"Return the pointer to the register block"]
7011 #[inline(always)]
7012 pub const fn ptr() -> *const usbhs1__usbnc::RegisterBlock {
7013 Self::PTR
7014 }
7015 #[doc = r" Steal an instance of this peripheral"]
7016 #[doc = r""]
7017 #[doc = r" # Safety"]
7018 #[doc = r""]
7019 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7020 #[doc = r" that may race with any existing instances, for example by only"]
7021 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7022 #[doc = r" original peripheral and using critical sections to coordinate"]
7023 #[doc = r" access between multiple new instances."]
7024 #[doc = r""]
7025 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7026 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7027 #[doc = r" no stolen instances are passed to such software."]
7028 pub unsafe fn steal() -> Self {
7029 Self {
7030 _marker: PhantomData,
7031 }
7032 }
7033}
7034impl Deref for USBHS1__USBNC {
7035 type Target = usbhs1__usbnc::RegisterBlock;
7036 #[inline(always)]
7037 fn deref(&self) -> &Self::Target {
7038 unsafe { &*Self::PTR }
7039 }
7040}
7041impl core::fmt::Debug for USBHS1__USBNC {
7042 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7043 f.debug_struct("USBHS1__USBNC").finish()
7044 }
7045}
7046#[doc = "USBNC"]
7047pub mod usbhs1__usbnc;
7048#[doc = "MICFIL"]
7049pub struct PDM {
7050 _marker: PhantomData<*const ()>,
7051}
7052unsafe impl Send for PDM {}
7053impl PDM {
7054 #[doc = r"Pointer to the register block"]
7055 pub const PTR: *const pdm::RegisterBlock = 0x4010_c000 as *const _;
7056 #[doc = r"Return the pointer to the register block"]
7057 #[inline(always)]
7058 pub const fn ptr() -> *const pdm::RegisterBlock {
7059 Self::PTR
7060 }
7061 #[doc = r" Steal an instance of this peripheral"]
7062 #[doc = r""]
7063 #[doc = r" # Safety"]
7064 #[doc = r""]
7065 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7066 #[doc = r" that may race with any existing instances, for example by only"]
7067 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7068 #[doc = r" original peripheral and using critical sections to coordinate"]
7069 #[doc = r" access between multiple new instances."]
7070 #[doc = r""]
7071 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7072 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7073 #[doc = r" no stolen instances are passed to such software."]
7074 pub unsafe fn steal() -> Self {
7075 Self {
7076 _marker: PhantomData,
7077 }
7078 }
7079}
7080impl Deref for PDM {
7081 type Target = pdm::RegisterBlock;
7082 #[inline(always)]
7083 fn deref(&self) -> &Self::Target {
7084 unsafe { &*Self::PTR }
7085 }
7086}
7087impl core::fmt::Debug for PDM {
7088 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7089 f.debug_struct("PDM").finish()
7090 }
7091}
7092#[doc = "MICFIL"]
7093pub mod pdm;
7094#[doc = "ADC"]
7095pub struct ADC0 {
7096 _marker: PhantomData<*const ()>,
7097}
7098unsafe impl Send for ADC0 {}
7099impl ADC0 {
7100 #[doc = r"Pointer to the register block"]
7101 pub const PTR: *const adc0::RegisterBlock = 0x4010_d000 as *const _;
7102 #[doc = r"Return the pointer to the register block"]
7103 #[inline(always)]
7104 pub const fn ptr() -> *const adc0::RegisterBlock {
7105 Self::PTR
7106 }
7107 #[doc = r" Steal an instance of this peripheral"]
7108 #[doc = r""]
7109 #[doc = r" # Safety"]
7110 #[doc = r""]
7111 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7112 #[doc = r" that may race with any existing instances, for example by only"]
7113 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7114 #[doc = r" original peripheral and using critical sections to coordinate"]
7115 #[doc = r" access between multiple new instances."]
7116 #[doc = r""]
7117 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7118 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7119 #[doc = r" no stolen instances are passed to such software."]
7120 pub unsafe fn steal() -> Self {
7121 Self {
7122 _marker: PhantomData,
7123 }
7124 }
7125}
7126impl Deref for ADC0 {
7127 type Target = adc0::RegisterBlock;
7128 #[inline(always)]
7129 fn deref(&self) -> &Self::Target {
7130 unsafe { &*Self::PTR }
7131 }
7132}
7133impl core::fmt::Debug for ADC0 {
7134 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7135 f.debug_struct("ADC0").finish()
7136 }
7137}
7138#[doc = "ADC"]
7139pub mod adc0;
7140#[doc = "ADC"]
7141pub struct ADC1 {
7142 _marker: PhantomData<*const ()>,
7143}
7144unsafe impl Send for ADC1 {}
7145impl ADC1 {
7146 #[doc = r"Pointer to the register block"]
7147 pub const PTR: *const adc0::RegisterBlock = 0x4010_e000 as *const _;
7148 #[doc = r"Return the pointer to the register block"]
7149 #[inline(always)]
7150 pub const fn ptr() -> *const adc0::RegisterBlock {
7151 Self::PTR
7152 }
7153 #[doc = r" Steal an instance of this peripheral"]
7154 #[doc = r""]
7155 #[doc = r" # Safety"]
7156 #[doc = r""]
7157 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7158 #[doc = r" that may race with any existing instances, for example by only"]
7159 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7160 #[doc = r" original peripheral and using critical sections to coordinate"]
7161 #[doc = r" access between multiple new instances."]
7162 #[doc = r""]
7163 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7164 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7165 #[doc = r" no stolen instances are passed to such software."]
7166 pub unsafe fn steal() -> Self {
7167 Self {
7168 _marker: PhantomData,
7169 }
7170 }
7171}
7172impl Deref for ADC1 {
7173 type Target = adc0::RegisterBlock;
7174 #[inline(always)]
7175 fn deref(&self) -> &Self::Target {
7176 unsafe { &*Self::PTR }
7177 }
7178}
7179impl core::fmt::Debug for ADC1 {
7180 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7181 f.debug_struct("ADC1").finish()
7182 }
7183}
7184#[doc = "ADC"]
7185pub use self::adc0 as adc1;
7186#[doc = "12-bit DAC"]
7187pub struct DAC0 {
7188 _marker: PhantomData<*const ()>,
7189}
7190unsafe impl Send for DAC0 {}
7191impl DAC0 {
7192 #[doc = r"Pointer to the register block"]
7193 pub const PTR: *const dac0::RegisterBlock = 0x4010_f000 as *const _;
7194 #[doc = r"Return the pointer to the register block"]
7195 #[inline(always)]
7196 pub const fn ptr() -> *const dac0::RegisterBlock {
7197 Self::PTR
7198 }
7199 #[doc = r" Steal an instance of this peripheral"]
7200 #[doc = r""]
7201 #[doc = r" # Safety"]
7202 #[doc = r""]
7203 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7204 #[doc = r" that may race with any existing instances, for example by only"]
7205 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7206 #[doc = r" original peripheral and using critical sections to coordinate"]
7207 #[doc = r" access between multiple new instances."]
7208 #[doc = r""]
7209 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7210 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7211 #[doc = r" no stolen instances are passed to such software."]
7212 pub unsafe fn steal() -> Self {
7213 Self {
7214 _marker: PhantomData,
7215 }
7216 }
7217}
7218impl Deref for DAC0 {
7219 type Target = dac0::RegisterBlock;
7220 #[inline(always)]
7221 fn deref(&self) -> &Self::Target {
7222 unsafe { &*Self::PTR }
7223 }
7224}
7225impl core::fmt::Debug for DAC0 {
7226 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7227 f.debug_struct("DAC0").finish()
7228 }
7229}
7230#[doc = "12-bit DAC"]
7231pub mod dac0;
7232#[doc = "12-bit DAC"]
7233pub struct DAC1 {
7234 _marker: PhantomData<*const ()>,
7235}
7236unsafe impl Send for DAC1 {}
7237impl DAC1 {
7238 #[doc = r"Pointer to the register block"]
7239 pub const PTR: *const dac0::RegisterBlock = 0x4011_2000 as *const _;
7240 #[doc = r"Return the pointer to the register block"]
7241 #[inline(always)]
7242 pub const fn ptr() -> *const dac0::RegisterBlock {
7243 Self::PTR
7244 }
7245 #[doc = r" Steal an instance of this peripheral"]
7246 #[doc = r""]
7247 #[doc = r" # Safety"]
7248 #[doc = r""]
7249 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7250 #[doc = r" that may race with any existing instances, for example by only"]
7251 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7252 #[doc = r" original peripheral and using critical sections to coordinate"]
7253 #[doc = r" access between multiple new instances."]
7254 #[doc = r""]
7255 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7256 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7257 #[doc = r" no stolen instances are passed to such software."]
7258 pub unsafe fn steal() -> Self {
7259 Self {
7260 _marker: PhantomData,
7261 }
7262 }
7263}
7264impl Deref for DAC1 {
7265 type Target = dac0::RegisterBlock;
7266 #[inline(always)]
7267 fn deref(&self) -> &Self::Target {
7268 unsafe { &*Self::PTR }
7269 }
7270}
7271impl core::fmt::Debug for DAC1 {
7272 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7273 f.debug_struct("DAC1").finish()
7274 }
7275}
7276#[doc = "12-bit DAC"]
7277pub use self::dac0 as dac1;
7278#[doc = "OPAMP"]
7279pub struct OPAMP0 {
7280 _marker: PhantomData<*const ()>,
7281}
7282unsafe impl Send for OPAMP0 {}
7283impl OPAMP0 {
7284 #[doc = r"Pointer to the register block"]
7285 pub const PTR: *const opamp0::RegisterBlock = 0x4011_0000 as *const _;
7286 #[doc = r"Return the pointer to the register block"]
7287 #[inline(always)]
7288 pub const fn ptr() -> *const opamp0::RegisterBlock {
7289 Self::PTR
7290 }
7291 #[doc = r" Steal an instance of this peripheral"]
7292 #[doc = r""]
7293 #[doc = r" # Safety"]
7294 #[doc = r""]
7295 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7296 #[doc = r" that may race with any existing instances, for example by only"]
7297 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7298 #[doc = r" original peripheral and using critical sections to coordinate"]
7299 #[doc = r" access between multiple new instances."]
7300 #[doc = r""]
7301 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7302 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7303 #[doc = r" no stolen instances are passed to such software."]
7304 pub unsafe fn steal() -> Self {
7305 Self {
7306 _marker: PhantomData,
7307 }
7308 }
7309}
7310impl Deref for OPAMP0 {
7311 type Target = opamp0::RegisterBlock;
7312 #[inline(always)]
7313 fn deref(&self) -> &Self::Target {
7314 unsafe { &*Self::PTR }
7315 }
7316}
7317impl core::fmt::Debug for OPAMP0 {
7318 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7319 f.debug_struct("OPAMP0").finish()
7320 }
7321}
7322#[doc = "OPAMP"]
7323pub mod opamp0;
7324#[doc = "OPAMP"]
7325pub struct OPAMP1 {
7326 _marker: PhantomData<*const ()>,
7327}
7328unsafe impl Send for OPAMP1 {}
7329impl OPAMP1 {
7330 #[doc = r"Pointer to the register block"]
7331 pub const PTR: *const opamp0::RegisterBlock = 0x4011_3000 as *const _;
7332 #[doc = r"Return the pointer to the register block"]
7333 #[inline(always)]
7334 pub const fn ptr() -> *const opamp0::RegisterBlock {
7335 Self::PTR
7336 }
7337 #[doc = r" Steal an instance of this peripheral"]
7338 #[doc = r""]
7339 #[doc = r" # Safety"]
7340 #[doc = r""]
7341 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7342 #[doc = r" that may race with any existing instances, for example by only"]
7343 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7344 #[doc = r" original peripheral and using critical sections to coordinate"]
7345 #[doc = r" access between multiple new instances."]
7346 #[doc = r""]
7347 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7348 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7349 #[doc = r" no stolen instances are passed to such software."]
7350 pub unsafe fn steal() -> Self {
7351 Self {
7352 _marker: PhantomData,
7353 }
7354 }
7355}
7356impl Deref for OPAMP1 {
7357 type Target = opamp0::RegisterBlock;
7358 #[inline(always)]
7359 fn deref(&self) -> &Self::Target {
7360 unsafe { &*Self::PTR }
7361 }
7362}
7363impl core::fmt::Debug for OPAMP1 {
7364 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7365 f.debug_struct("OPAMP1").finish()
7366 }
7367}
7368#[doc = "OPAMP"]
7369pub use self::opamp0 as opamp1;
7370#[doc = "OPAMP"]
7371pub struct OPAMP2 {
7372 _marker: PhantomData<*const ()>,
7373}
7374unsafe impl Send for OPAMP2 {}
7375impl OPAMP2 {
7376 #[doc = r"Pointer to the register block"]
7377 pub const PTR: *const opamp0::RegisterBlock = 0x4011_5000 as *const _;
7378 #[doc = r"Return the pointer to the register block"]
7379 #[inline(always)]
7380 pub const fn ptr() -> *const opamp0::RegisterBlock {
7381 Self::PTR
7382 }
7383 #[doc = r" Steal an instance of this peripheral"]
7384 #[doc = r""]
7385 #[doc = r" # Safety"]
7386 #[doc = r""]
7387 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7388 #[doc = r" that may race with any existing instances, for example by only"]
7389 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7390 #[doc = r" original peripheral and using critical sections to coordinate"]
7391 #[doc = r" access between multiple new instances."]
7392 #[doc = r""]
7393 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7394 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7395 #[doc = r" no stolen instances are passed to such software."]
7396 pub unsafe fn steal() -> Self {
7397 Self {
7398 _marker: PhantomData,
7399 }
7400 }
7401}
7402impl Deref for OPAMP2 {
7403 type Target = opamp0::RegisterBlock;
7404 #[inline(always)]
7405 fn deref(&self) -> &Self::Target {
7406 unsafe { &*Self::PTR }
7407 }
7408}
7409impl core::fmt::Debug for OPAMP2 {
7410 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7411 f.debug_struct("OPAMP2").finish()
7412 }
7413}
7414#[doc = "OPAMP"]
7415pub use self::opamp0 as opamp2;
7416#[doc = "VREF"]
7417pub struct VREF0 {
7418 _marker: PhantomData<*const ()>,
7419}
7420unsafe impl Send for VREF0 {}
7421impl VREF0 {
7422 #[doc = r"Pointer to the register block"]
7423 pub const PTR: *const vref0::RegisterBlock = 0x4011_1000 as *const _;
7424 #[doc = r"Return the pointer to the register block"]
7425 #[inline(always)]
7426 pub const fn ptr() -> *const vref0::RegisterBlock {
7427 Self::PTR
7428 }
7429 #[doc = r" Steal an instance of this peripheral"]
7430 #[doc = r""]
7431 #[doc = r" # Safety"]
7432 #[doc = r""]
7433 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7434 #[doc = r" that may race with any existing instances, for example by only"]
7435 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7436 #[doc = r" original peripheral and using critical sections to coordinate"]
7437 #[doc = r" access between multiple new instances."]
7438 #[doc = r""]
7439 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7440 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7441 #[doc = r" no stolen instances are passed to such software."]
7442 pub unsafe fn steal() -> Self {
7443 Self {
7444 _marker: PhantomData,
7445 }
7446 }
7447}
7448impl Deref for VREF0 {
7449 type Target = vref0::RegisterBlock;
7450 #[inline(always)]
7451 fn deref(&self) -> &Self::Target {
7452 unsafe { &*Self::PTR }
7453 }
7454}
7455impl core::fmt::Debug for VREF0 {
7456 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7457 f.debug_struct("VREF0").finish()
7458 }
7459}
7460#[doc = "VREF"]
7461pub mod vref0;
7462#[doc = "14-bit DAC"]
7463pub struct DAC2 {
7464 _marker: PhantomData<*const ()>,
7465}
7466unsafe impl Send for DAC2 {}
7467impl DAC2 {
7468 #[doc = r"Pointer to the register block"]
7469 pub const PTR: *const dac2::RegisterBlock = 0x4011_4000 as *const _;
7470 #[doc = r"Return the pointer to the register block"]
7471 #[inline(always)]
7472 pub const fn ptr() -> *const dac2::RegisterBlock {
7473 Self::PTR
7474 }
7475 #[doc = r" Steal an instance of this peripheral"]
7476 #[doc = r""]
7477 #[doc = r" # Safety"]
7478 #[doc = r""]
7479 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7480 #[doc = r" that may race with any existing instances, for example by only"]
7481 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7482 #[doc = r" original peripheral and using critical sections to coordinate"]
7483 #[doc = r" access between multiple new instances."]
7484 #[doc = r""]
7485 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7486 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7487 #[doc = r" no stolen instances are passed to such software."]
7488 pub unsafe fn steal() -> Self {
7489 Self {
7490 _marker: PhantomData,
7491 }
7492 }
7493}
7494impl Deref for DAC2 {
7495 type Target = dac2::RegisterBlock;
7496 #[inline(always)]
7497 fn deref(&self) -> &Self::Target {
7498 unsafe { &*Self::PTR }
7499 }
7500}
7501impl core::fmt::Debug for DAC2 {
7502 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7503 f.debug_struct("DAC2").finish()
7504 }
7505}
7506#[doc = "14-bit DAC"]
7507pub mod dac2;
7508#[doc = "PORT"]
7509pub struct PORT1 {
7510 _marker: PhantomData<*const ()>,
7511}
7512unsafe impl Send for PORT1 {}
7513impl PORT1 {
7514 #[doc = r"Pointer to the register block"]
7515 pub const PTR: *const port0::RegisterBlock = 0x4011_7000 as *const _;
7516 #[doc = r"Return the pointer to the register block"]
7517 #[inline(always)]
7518 pub const fn ptr() -> *const port0::RegisterBlock {
7519 Self::PTR
7520 }
7521 #[doc = r" Steal an instance of this peripheral"]
7522 #[doc = r""]
7523 #[doc = r" # Safety"]
7524 #[doc = r""]
7525 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7526 #[doc = r" that may race with any existing instances, for example by only"]
7527 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7528 #[doc = r" original peripheral and using critical sections to coordinate"]
7529 #[doc = r" access between multiple new instances."]
7530 #[doc = r""]
7531 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7532 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7533 #[doc = r" no stolen instances are passed to such software."]
7534 pub unsafe fn steal() -> Self {
7535 Self {
7536 _marker: PhantomData,
7537 }
7538 }
7539}
7540impl Deref for PORT1 {
7541 type Target = port0::RegisterBlock;
7542 #[inline(always)]
7543 fn deref(&self) -> &Self::Target {
7544 unsafe { &*Self::PTR }
7545 }
7546}
7547impl core::fmt::Debug for PORT1 {
7548 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7549 f.debug_struct("PORT1").finish()
7550 }
7551}
7552#[doc = "PORT"]
7553pub use self::port0 as port1;
7554#[doc = "PORT"]
7555pub struct PORT2 {
7556 _marker: PhantomData<*const ()>,
7557}
7558unsafe impl Send for PORT2 {}
7559impl PORT2 {
7560 #[doc = r"Pointer to the register block"]
7561 pub const PTR: *const port0::RegisterBlock = 0x4011_8000 as *const _;
7562 #[doc = r"Return the pointer to the register block"]
7563 #[inline(always)]
7564 pub const fn ptr() -> *const port0::RegisterBlock {
7565 Self::PTR
7566 }
7567 #[doc = r" Steal an instance of this peripheral"]
7568 #[doc = r""]
7569 #[doc = r" # Safety"]
7570 #[doc = r""]
7571 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7572 #[doc = r" that may race with any existing instances, for example by only"]
7573 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7574 #[doc = r" original peripheral and using critical sections to coordinate"]
7575 #[doc = r" access between multiple new instances."]
7576 #[doc = r""]
7577 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7578 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7579 #[doc = r" no stolen instances are passed to such software."]
7580 pub unsafe fn steal() -> Self {
7581 Self {
7582 _marker: PhantomData,
7583 }
7584 }
7585}
7586impl Deref for PORT2 {
7587 type Target = port0::RegisterBlock;
7588 #[inline(always)]
7589 fn deref(&self) -> &Self::Target {
7590 unsafe { &*Self::PTR }
7591 }
7592}
7593impl core::fmt::Debug for PORT2 {
7594 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7595 f.debug_struct("PORT2").finish()
7596 }
7597}
7598#[doc = "PORT"]
7599pub use self::port0 as port2;
7600#[doc = "PORT"]
7601pub struct PORT3 {
7602 _marker: PhantomData<*const ()>,
7603}
7604unsafe impl Send for PORT3 {}
7605impl PORT3 {
7606 #[doc = r"Pointer to the register block"]
7607 pub const PTR: *const port0::RegisterBlock = 0x4011_9000 as *const _;
7608 #[doc = r"Return the pointer to the register block"]
7609 #[inline(always)]
7610 pub const fn ptr() -> *const port0::RegisterBlock {
7611 Self::PTR
7612 }
7613 #[doc = r" Steal an instance of this peripheral"]
7614 #[doc = r""]
7615 #[doc = r" # Safety"]
7616 #[doc = r""]
7617 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7618 #[doc = r" that may race with any existing instances, for example by only"]
7619 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7620 #[doc = r" original peripheral and using critical sections to coordinate"]
7621 #[doc = r" access between multiple new instances."]
7622 #[doc = r""]
7623 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7624 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7625 #[doc = r" no stolen instances are passed to such software."]
7626 pub unsafe fn steal() -> Self {
7627 Self {
7628 _marker: PhantomData,
7629 }
7630 }
7631}
7632impl Deref for PORT3 {
7633 type Target = port0::RegisterBlock;
7634 #[inline(always)]
7635 fn deref(&self) -> &Self::Target {
7636 unsafe { &*Self::PTR }
7637 }
7638}
7639impl core::fmt::Debug for PORT3 {
7640 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7641 f.debug_struct("PORT3").finish()
7642 }
7643}
7644#[doc = "PORT"]
7645pub use self::port0 as port3;
7646#[doc = "PORT"]
7647pub struct PORT4 {
7648 _marker: PhantomData<*const ()>,
7649}
7650unsafe impl Send for PORT4 {}
7651impl PORT4 {
7652 #[doc = r"Pointer to the register block"]
7653 pub const PTR: *const port0::RegisterBlock = 0x4011_a000 as *const _;
7654 #[doc = r"Return the pointer to the register block"]
7655 #[inline(always)]
7656 pub const fn ptr() -> *const port0::RegisterBlock {
7657 Self::PTR
7658 }
7659 #[doc = r" Steal an instance of this peripheral"]
7660 #[doc = r""]
7661 #[doc = r" # Safety"]
7662 #[doc = r""]
7663 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7664 #[doc = r" that may race with any existing instances, for example by only"]
7665 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7666 #[doc = r" original peripheral and using critical sections to coordinate"]
7667 #[doc = r" access between multiple new instances."]
7668 #[doc = r""]
7669 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7670 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7671 #[doc = r" no stolen instances are passed to such software."]
7672 pub unsafe fn steal() -> Self {
7673 Self {
7674 _marker: PhantomData,
7675 }
7676 }
7677}
7678impl Deref for PORT4 {
7679 type Target = port0::RegisterBlock;
7680 #[inline(always)]
7681 fn deref(&self) -> &Self::Target {
7682 unsafe { &*Self::PTR }
7683 }
7684}
7685impl core::fmt::Debug for PORT4 {
7686 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7687 f.debug_struct("PORT4").finish()
7688 }
7689}
7690#[doc = "PORT"]
7691pub use self::port0 as port4;
7692#[doc = "AHBSC"]
7693pub struct AHBSC {
7694 _marker: PhantomData<*const ()>,
7695}
7696unsafe impl Send for AHBSC {}
7697impl AHBSC {
7698 #[doc = r"Pointer to the register block"]
7699 pub const PTR: *const ahbsc::RegisterBlock = 0x4012_0000 as *const _;
7700 #[doc = r"Return the pointer to the register block"]
7701 #[inline(always)]
7702 pub const fn ptr() -> *const ahbsc::RegisterBlock {
7703 Self::PTR
7704 }
7705 #[doc = r" Steal an instance of this peripheral"]
7706 #[doc = r""]
7707 #[doc = r" # Safety"]
7708 #[doc = r""]
7709 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7710 #[doc = r" that may race with any existing instances, for example by only"]
7711 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7712 #[doc = r" original peripheral and using critical sections to coordinate"]
7713 #[doc = r" access between multiple new instances."]
7714 #[doc = r""]
7715 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7716 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7717 #[doc = r" no stolen instances are passed to such software."]
7718 pub unsafe fn steal() -> Self {
7719 Self {
7720 _marker: PhantomData,
7721 }
7722 }
7723}
7724impl Deref for AHBSC {
7725 type Target = ahbsc::RegisterBlock;
7726 #[inline(always)]
7727 fn deref(&self) -> &Self::Target {
7728 unsafe { &*Self::PTR }
7729 }
7730}
7731impl core::fmt::Debug for AHBSC {
7732 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7733 f.debug_struct("AHBSC").finish()
7734 }
7735}
7736#[doc = "AHBSC"]
7737pub mod ahbsc;
7738#[doc = "no description available"]
7739pub struct SCN_SCB {
7740 _marker: PhantomData<*const ()>,
7741}
7742unsafe impl Send for SCN_SCB {}
7743impl SCN_SCB {
7744 #[doc = r"Pointer to the register block"]
7745 pub const PTR: *const scn_scb::RegisterBlock = 0xe000_e000 as *const _;
7746 #[doc = r"Return the pointer to the register block"]
7747 #[inline(always)]
7748 pub const fn ptr() -> *const scn_scb::RegisterBlock {
7749 Self::PTR
7750 }
7751 #[doc = r" Steal an instance of this peripheral"]
7752 #[doc = r""]
7753 #[doc = r" # Safety"]
7754 #[doc = r""]
7755 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7756 #[doc = r" that may race with any existing instances, for example by only"]
7757 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7758 #[doc = r" original peripheral and using critical sections to coordinate"]
7759 #[doc = r" access between multiple new instances."]
7760 #[doc = r""]
7761 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7762 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7763 #[doc = r" no stolen instances are passed to such software."]
7764 pub unsafe fn steal() -> Self {
7765 Self {
7766 _marker: PhantomData,
7767 }
7768 }
7769}
7770impl Deref for SCN_SCB {
7771 type Target = scn_scb::RegisterBlock;
7772 #[inline(always)]
7773 fn deref(&self) -> &Self::Target {
7774 unsafe { &*Self::PTR }
7775 }
7776}
7777impl core::fmt::Debug for SCN_SCB {
7778 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7779 f.debug_struct("SCN_SCB").finish()
7780 }
7781}
7782#[doc = "no description available"]
7783pub mod scn_scb;
7784#[doc = "M33 Systick module"]
7785pub struct SYS_TICK0 {
7786 _marker: PhantomData<*const ()>,
7787}
7788unsafe impl Send for SYS_TICK0 {}
7789impl SYS_TICK0 {
7790 #[doc = r"Pointer to the register block"]
7791 pub const PTR: *const sys_tick0::RegisterBlock = 0xe000_e010 as *const _;
7792 #[doc = r"Return the pointer to the register block"]
7793 #[inline(always)]
7794 pub const fn ptr() -> *const sys_tick0::RegisterBlock {
7795 Self::PTR
7796 }
7797 #[doc = r" Steal an instance of this peripheral"]
7798 #[doc = r""]
7799 #[doc = r" # Safety"]
7800 #[doc = r""]
7801 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7802 #[doc = r" that may race with any existing instances, for example by only"]
7803 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7804 #[doc = r" original peripheral and using critical sections to coordinate"]
7805 #[doc = r" access between multiple new instances."]
7806 #[doc = r""]
7807 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7808 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7809 #[doc = r" no stolen instances are passed to such software."]
7810 pub unsafe fn steal() -> Self {
7811 Self {
7812 _marker: PhantomData,
7813 }
7814 }
7815}
7816impl Deref for SYS_TICK0 {
7817 type Target = sys_tick0::RegisterBlock;
7818 #[inline(always)]
7819 fn deref(&self) -> &Self::Target {
7820 unsafe { &*Self::PTR }
7821 }
7822}
7823impl core::fmt::Debug for SYS_TICK0 {
7824 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7825 f.debug_struct("SYS_TICK0").finish()
7826 }
7827}
7828#[doc = "M33 Systick module"]
7829pub mod sys_tick0;
7830#[doc = "no description available"]
7831pub struct SAU {
7832 _marker: PhantomData<*const ()>,
7833}
7834unsafe impl Send for SAU {}
7835impl SAU {
7836 #[doc = r"Pointer to the register block"]
7837 pub const PTR: *const sau::RegisterBlock = 0xe000_edd0 as *const _;
7838 #[doc = r"Return the pointer to the register block"]
7839 #[inline(always)]
7840 pub const fn ptr() -> *const sau::RegisterBlock {
7841 Self::PTR
7842 }
7843 #[doc = r" Steal an instance of this peripheral"]
7844 #[doc = r""]
7845 #[doc = r" # Safety"]
7846 #[doc = r""]
7847 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7848 #[doc = r" that may race with any existing instances, for example by only"]
7849 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7850 #[doc = r" original peripheral and using critical sections to coordinate"]
7851 #[doc = r" access between multiple new instances."]
7852 #[doc = r""]
7853 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7854 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7855 #[doc = r" no stolen instances are passed to such software."]
7856 pub unsafe fn steal() -> Self {
7857 Self {
7858 _marker: PhantomData,
7859 }
7860 }
7861}
7862impl Deref for SAU {
7863 type Target = sau::RegisterBlock;
7864 #[inline(always)]
7865 fn deref(&self) -> &Self::Target {
7866 unsafe { &*Self::PTR }
7867 }
7868}
7869impl core::fmt::Debug for SAU {
7870 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7871 f.debug_struct("SAU").finish()
7872 }
7873}
7874#[doc = "no description available"]
7875pub mod sau;
7876#[no_mangle]
7877static mut DEVICE_PERIPHERALS: bool = false;
7878#[doc = r" All the peripherals."]
7879#[allow(non_snake_case)]
7880pub struct Peripherals {
7881 #[doc = "SYSCON0"]
7882 pub SYSCON0: SYSCON0,
7883 #[doc = "PINT0"]
7884 pub PINT0: PINT0,
7885 #[doc = "INPUTMUX0"]
7886 pub INPUTMUX0: INPUTMUX0,
7887 #[doc = "CTIMER0"]
7888 pub CTIMER0: CTIMER0,
7889 #[doc = "CTIMER1"]
7890 pub CTIMER1: CTIMER1,
7891 #[doc = "CTIMER2"]
7892 pub CTIMER2: CTIMER2,
7893 #[doc = "CTIMER3"]
7894 pub CTIMER3: CTIMER3,
7895 #[doc = "CTIMER4"]
7896 pub CTIMER4: CTIMER4,
7897 #[doc = "FREQME0"]
7898 pub FREQME0: FREQME0,
7899 #[doc = "UTICK0"]
7900 pub UTICK0: UTICK0,
7901 #[doc = "MRT0"]
7902 pub MRT0: MRT0,
7903 #[doc = "WWDT0"]
7904 pub WWDT0: WWDT0,
7905 #[doc = "WWDT1"]
7906 pub WWDT1: WWDT1,
7907 #[doc = "CACHE64_CTRL0"]
7908 pub CACHE64_CTRL0: CACHE64_CTRL0,
7909 #[doc = "CACHE64_POLSEL0"]
7910 pub CACHE64_POLSEL0: CACHE64_POLSEL0,
7911 #[doc = "I3C0"]
7912 pub I3C0: I3C0,
7913 #[doc = "I3C1"]
7914 pub I3C1: I3C1,
7915 #[doc = "GDET0"]
7916 pub GDET0: GDET0,
7917 #[doc = "GDET1"]
7918 pub GDET1: GDET1,
7919 #[doc = "ITRC0"]
7920 pub ITRC0: ITRC0,
7921 #[doc = "PKC0"]
7922 pub PKC0: PKC0,
7923 #[doc = "PUF"]
7924 pub PUF: PUF,
7925 #[doc = "PUF_CTRL"]
7926 pub PUF_CTRL: PUF_CTRL,
7927 #[doc = "SM3_0"]
7928 pub SM3_0: SM3_0,
7929 #[doc = "BSP32_0"]
7930 pub BSP32_0: BSP32_0,
7931 #[doc = "SMARTDMA0"]
7932 pub SMARTDMA0: SMARTDMA0,
7933 #[doc = "PLU0"]
7934 pub PLU0: PLU0,
7935 #[doc = "PORT0"]
7936 pub PORT0: PORT0,
7937 #[doc = "PORT5"]
7938 pub PORT5: PORT5,
7939 #[doc = "FMU0"]
7940 pub FMU0: FMU0,
7941 #[doc = "SCG0"]
7942 pub SCG0: SCG0,
7943 #[doc = "SPC0"]
7944 pub SPC0: SPC0,
7945 #[doc = "WUU0"]
7946 pub WUU0: WUU0,
7947 #[doc = "CMC0"]
7948 pub CMC0: CMC0,
7949 #[doc = "OSTIMER0"]
7950 pub OSTIMER0: OSTIMER0,
7951 #[doc = "LPTMR0"]
7952 pub LPTMR0: LPTMR0,
7953 #[doc = "LPTMR1"]
7954 pub LPTMR1: LPTMR1,
7955 #[doc = "RTC0"]
7956 pub RTC0: RTC0,
7957 #[doc = "RTC_SUBSYSTEM0"]
7958 pub RTC_SUBSYSTEM0: RTC_SUBSYSTEM0,
7959 #[doc = "TSI0"]
7960 pub TSI0: TSI0,
7961 #[doc = "CMP0"]
7962 pub CMP0: CMP0,
7963 #[doc = "CMP1"]
7964 pub CMP1: CMP1,
7965 #[doc = "CMP2"]
7966 pub CMP2: CMP2,
7967 #[doc = "ELS"]
7968 pub ELS: ELS,
7969 #[doc = "TDET0"]
7970 pub TDET0: TDET0,
7971 #[doc = "VBAT0"]
7972 pub VBAT0: VBAT0,
7973 #[doc = "TRNG0"]
7974 pub TRNG0: TRNG0,
7975 #[doc = "EIM0"]
7976 pub EIM0: EIM0,
7977 #[doc = "ERM0"]
7978 pub ERM0: ERM0,
7979 #[doc = "INTM0"]
7980 pub INTM0: INTM0,
7981 #[doc = "DMA0"]
7982 pub DMA0: DMA0,
7983 #[doc = "DMA1"]
7984 pub DMA1: DMA1,
7985 #[doc = "EDMA_0_TCD"]
7986 pub EDMA_0_TCD: EDMA_0_TCD,
7987 #[doc = "SCT0"]
7988 pub SCT0: SCT0,
7989 #[doc = "LPSPI0"]
7990 pub LPSPI0: LPSPI0,
7991 #[doc = "LPSPI1"]
7992 pub LPSPI1: LPSPI1,
7993 #[doc = "LPSPI2"]
7994 pub LPSPI2: LPSPI2,
7995 #[doc = "LPSPI3"]
7996 pub LPSPI3: LPSPI3,
7997 #[doc = "LPSPI4"]
7998 pub LPSPI4: LPSPI4,
7999 #[doc = "LPSPI5"]
8000 pub LPSPI5: LPSPI5,
8001 #[doc = "LPSPI6"]
8002 pub LPSPI6: LPSPI6,
8003 #[doc = "LPSPI7"]
8004 pub LPSPI7: LPSPI7,
8005 #[doc = "LPSPI8"]
8006 pub LPSPI8: LPSPI8,
8007 #[doc = "LPSPI9"]
8008 pub LPSPI9: LPSPI9,
8009 #[doc = "LPUART0"]
8010 pub LPUART0: LPUART0,
8011 #[doc = "LPUART1"]
8012 pub LPUART1: LPUART1,
8013 #[doc = "LPUART2"]
8014 pub LPUART2: LPUART2,
8015 #[doc = "LPUART3"]
8016 pub LPUART3: LPUART3,
8017 #[doc = "LPUART4"]
8018 pub LPUART4: LPUART4,
8019 #[doc = "LPUART5"]
8020 pub LPUART5: LPUART5,
8021 #[doc = "LPUART6"]
8022 pub LPUART6: LPUART6,
8023 #[doc = "LPUART7"]
8024 pub LPUART7: LPUART7,
8025 #[doc = "LPUART8"]
8026 pub LPUART8: LPUART8,
8027 #[doc = "LPUART9"]
8028 pub LPUART9: LPUART9,
8029 #[doc = "LP_FLEXCOMM0"]
8030 pub LP_FLEXCOMM0: LP_FLEXCOMM0,
8031 #[doc = "LP_FLEXCOMM1"]
8032 pub LP_FLEXCOMM1: LP_FLEXCOMM1,
8033 #[doc = "LP_FLEXCOMM2"]
8034 pub LP_FLEXCOMM2: LP_FLEXCOMM2,
8035 #[doc = "LP_FLEXCOMM3"]
8036 pub LP_FLEXCOMM3: LP_FLEXCOMM3,
8037 #[doc = "LP_FLEXCOMM4"]
8038 pub LP_FLEXCOMM4: LP_FLEXCOMM4,
8039 #[doc = "LP_FLEXCOMM5"]
8040 pub LP_FLEXCOMM5: LP_FLEXCOMM5,
8041 #[doc = "LP_FLEXCOMM6"]
8042 pub LP_FLEXCOMM6: LP_FLEXCOMM6,
8043 #[doc = "LP_FLEXCOMM7"]
8044 pub LP_FLEXCOMM7: LP_FLEXCOMM7,
8045 #[doc = "LP_FLEXCOMM8"]
8046 pub LP_FLEXCOMM8: LP_FLEXCOMM8,
8047 #[doc = "LP_FLEXCOMM9"]
8048 pub LP_FLEXCOMM9: LP_FLEXCOMM9,
8049 #[doc = "LPI2C0"]
8050 pub LPI2C0: LPI2C0,
8051 #[doc = "LPI2C1"]
8052 pub LPI2C1: LPI2C1,
8053 #[doc = "LPI2C2"]
8054 pub LPI2C2: LPI2C2,
8055 #[doc = "LPI2C3"]
8056 pub LPI2C3: LPI2C3,
8057 #[doc = "LPI2C4"]
8058 pub LPI2C4: LPI2C4,
8059 #[doc = "LPI2C5"]
8060 pub LPI2C5: LPI2C5,
8061 #[doc = "LPI2C6"]
8062 pub LPI2C6: LPI2C6,
8063 #[doc = "LPI2C7"]
8064 pub LPI2C7: LPI2C7,
8065 #[doc = "LPI2C8"]
8066 pub LPI2C8: LPI2C8,
8067 #[doc = "LPI2C9"]
8068 pub LPI2C9: LPI2C9,
8069 #[doc = "GPIO0"]
8070 pub GPIO0: GPIO0,
8071 #[doc = "GPIO5"]
8072 pub GPIO5: GPIO5,
8073 #[doc = "GPIO1"]
8074 pub GPIO1: GPIO1,
8075 #[doc = "GPIO2"]
8076 pub GPIO2: GPIO2,
8077 #[doc = "GPIO3"]
8078 pub GPIO3: GPIO3,
8079 #[doc = "GPIO4"]
8080 pub GPIO4: GPIO4,
8081 #[doc = "EDMA_1_TCD"]
8082 pub EDMA_1_TCD: EDMA_1_TCD,
8083 #[doc = "SEMA42_0"]
8084 pub SEMA42_0: SEMA42_0,
8085 #[doc = "MAILBOX"]
8086 pub MAILBOX: MAILBOX,
8087 #[doc = "CDOG0"]
8088 pub CDOG0: CDOG0,
8089 #[doc = "CDOG1"]
8090 pub CDOG1: CDOG1,
8091 #[doc = "DM0"]
8092 pub DM0: DM0,
8093 #[doc = "POWERQUAD"]
8094 pub POWERQUAD: POWERQUAD,
8095 #[doc = "EWM0"]
8096 pub EWM0: EWM0,
8097 #[doc = "CMX_PERFMON0"]
8098 pub CMX_PERFMON0: CMX_PERFMON0,
8099 #[doc = "CMX_PERFMON1"]
8100 pub CMX_PERFMON1: CMX_PERFMON1,
8101 #[doc = "TRDC"]
8102 pub TRDC: TRDC,
8103 #[doc = "FLEXSPI0"]
8104 pub FLEXSPI0: FLEXSPI0,
8105 #[doc = "OTPC0"]
8106 pub OTPC0: OTPC0,
8107 #[doc = "CRC0"]
8108 pub CRC0: CRC0,
8109 #[doc = "NPX0"]
8110 pub NPX0: NPX0,
8111 #[doc = "PWM0"]
8112 pub PWM0: PWM0,
8113 #[doc = "PWM1"]
8114 pub PWM1: PWM1,
8115 #[doc = "ENC0"]
8116 pub ENC0: ENC0,
8117 #[doc = "ENC1"]
8118 pub ENC1: ENC1,
8119 #[doc = "EVTG0"]
8120 pub EVTG0: EVTG0,
8121 #[doc = "CAN0"]
8122 pub CAN0: CAN0,
8123 #[doc = "CAN1"]
8124 pub CAN1: CAN1,
8125 #[doc = "USBDCD0"]
8126 pub USBDCD0: USBDCD0,
8127 #[doc = "USBFS0"]
8128 pub USBFS0: USBFS0,
8129 #[doc = "ENET0"]
8130 pub ENET0: ENET0,
8131 #[doc = "EMVSIM0"]
8132 pub EMVSIM0: EMVSIM0,
8133 #[doc = "EMVSIM1"]
8134 pub EMVSIM1: EMVSIM1,
8135 #[doc = "FLEXIO0"]
8136 pub FLEXIO0: FLEXIO0,
8137 #[doc = "SAI0"]
8138 pub SAI0: SAI0,
8139 #[doc = "SAI1"]
8140 pub SAI1: SAI1,
8141 #[doc = "SINC0"]
8142 pub SINC0: SINC0,
8143 #[doc = "USDHC0"]
8144 pub USDHC0: USDHC0,
8145 #[doc = "USBPHY"]
8146 pub USBPHY: USBPHY,
8147 #[doc = "USBHS1_PHY_DCD"]
8148 pub USBHS1_PHY_DCD: USBHS1_PHY_DCD,
8149 #[doc = "USBHS1__USBC"]
8150 pub USBHS1__USBC: USBHS1__USBC,
8151 #[doc = "USBHS1__USBNC"]
8152 pub USBHS1__USBNC: USBHS1__USBNC,
8153 #[doc = "PDM"]
8154 pub PDM: PDM,
8155 #[doc = "ADC0"]
8156 pub ADC0: ADC0,
8157 #[doc = "ADC1"]
8158 pub ADC1: ADC1,
8159 #[doc = "DAC0"]
8160 pub DAC0: DAC0,
8161 #[doc = "DAC1"]
8162 pub DAC1: DAC1,
8163 #[doc = "OPAMP0"]
8164 pub OPAMP0: OPAMP0,
8165 #[doc = "OPAMP1"]
8166 pub OPAMP1: OPAMP1,
8167 #[doc = "OPAMP2"]
8168 pub OPAMP2: OPAMP2,
8169 #[doc = "VREF0"]
8170 pub VREF0: VREF0,
8171 #[doc = "DAC2"]
8172 pub DAC2: DAC2,
8173 #[doc = "PORT1"]
8174 pub PORT1: PORT1,
8175 #[doc = "PORT2"]
8176 pub PORT2: PORT2,
8177 #[doc = "PORT3"]
8178 pub PORT3: PORT3,
8179 #[doc = "PORT4"]
8180 pub PORT4: PORT4,
8181 #[doc = "AHBSC"]
8182 pub AHBSC: AHBSC,
8183 #[doc = "SCnSCB"]
8184 pub SCN_SCB: SCN_SCB,
8185 #[doc = "SysTick0"]
8186 pub SYS_TICK0: SYS_TICK0,
8187 #[doc = "SAU"]
8188 pub SAU: SAU,
8189}
8190impl Peripherals {
8191 #[doc = r" Returns all the peripherals *once*."]
8192 #[cfg(feature = "critical-section")]
8193 #[inline]
8194 pub fn take() -> Option<Self> {
8195 critical_section::with(|_| {
8196 if unsafe { DEVICE_PERIPHERALS } {
8197 return None;
8198 }
8199 Some(unsafe { Peripherals::steal() })
8200 })
8201 }
8202 #[doc = r" Unchecked version of `Peripherals::take`."]
8203 #[doc = r""]
8204 #[doc = r" # Safety"]
8205 #[doc = r""]
8206 #[doc = r" Each of the returned peripherals must be used at most once."]
8207 #[inline]
8208 pub unsafe fn steal() -> Self {
8209 DEVICE_PERIPHERALS = true;
8210 Peripherals {
8211 SYSCON0: SYSCON0 {
8212 _marker: PhantomData,
8213 },
8214 PINT0: PINT0 {
8215 _marker: PhantomData,
8216 },
8217 INPUTMUX0: INPUTMUX0 {
8218 _marker: PhantomData,
8219 },
8220 CTIMER0: CTIMER0 {
8221 _marker: PhantomData,
8222 },
8223 CTIMER1: CTIMER1 {
8224 _marker: PhantomData,
8225 },
8226 CTIMER2: CTIMER2 {
8227 _marker: PhantomData,
8228 },
8229 CTIMER3: CTIMER3 {
8230 _marker: PhantomData,
8231 },
8232 CTIMER4: CTIMER4 {
8233 _marker: PhantomData,
8234 },
8235 FREQME0: FREQME0 {
8236 _marker: PhantomData,
8237 },
8238 UTICK0: UTICK0 {
8239 _marker: PhantomData,
8240 },
8241 MRT0: MRT0 {
8242 _marker: PhantomData,
8243 },
8244 WWDT0: WWDT0 {
8245 _marker: PhantomData,
8246 },
8247 WWDT1: WWDT1 {
8248 _marker: PhantomData,
8249 },
8250 CACHE64_CTRL0: CACHE64_CTRL0 {
8251 _marker: PhantomData,
8252 },
8253 CACHE64_POLSEL0: CACHE64_POLSEL0 {
8254 _marker: PhantomData,
8255 },
8256 I3C0: I3C0 {
8257 _marker: PhantomData,
8258 },
8259 I3C1: I3C1 {
8260 _marker: PhantomData,
8261 },
8262 GDET0: GDET0 {
8263 _marker: PhantomData,
8264 },
8265 GDET1: GDET1 {
8266 _marker: PhantomData,
8267 },
8268 ITRC0: ITRC0 {
8269 _marker: PhantomData,
8270 },
8271 PKC0: PKC0 {
8272 _marker: PhantomData,
8273 },
8274 PUF: PUF {
8275 _marker: PhantomData,
8276 },
8277 PUF_CTRL: PUF_CTRL {
8278 _marker: PhantomData,
8279 },
8280 SM3_0: SM3_0 {
8281 _marker: PhantomData,
8282 },
8283 BSP32_0: BSP32_0 {
8284 _marker: PhantomData,
8285 },
8286 SMARTDMA0: SMARTDMA0 {
8287 _marker: PhantomData,
8288 },
8289 PLU0: PLU0 {
8290 _marker: PhantomData,
8291 },
8292 PORT0: PORT0 {
8293 _marker: PhantomData,
8294 },
8295 PORT5: PORT5 {
8296 _marker: PhantomData,
8297 },
8298 FMU0: FMU0 {
8299 _marker: PhantomData,
8300 },
8301 SCG0: SCG0 {
8302 _marker: PhantomData,
8303 },
8304 SPC0: SPC0 {
8305 _marker: PhantomData,
8306 },
8307 WUU0: WUU0 {
8308 _marker: PhantomData,
8309 },
8310 CMC0: CMC0 {
8311 _marker: PhantomData,
8312 },
8313 OSTIMER0: OSTIMER0 {
8314 _marker: PhantomData,
8315 },
8316 LPTMR0: LPTMR0 {
8317 _marker: PhantomData,
8318 },
8319 LPTMR1: LPTMR1 {
8320 _marker: PhantomData,
8321 },
8322 RTC0: RTC0 {
8323 _marker: PhantomData,
8324 },
8325 RTC_SUBSYSTEM0: RTC_SUBSYSTEM0 {
8326 _marker: PhantomData,
8327 },
8328 TSI0: TSI0 {
8329 _marker: PhantomData,
8330 },
8331 CMP0: CMP0 {
8332 _marker: PhantomData,
8333 },
8334 CMP1: CMP1 {
8335 _marker: PhantomData,
8336 },
8337 CMP2: CMP2 {
8338 _marker: PhantomData,
8339 },
8340 ELS: ELS {
8341 _marker: PhantomData,
8342 },
8343 TDET0: TDET0 {
8344 _marker: PhantomData,
8345 },
8346 VBAT0: VBAT0 {
8347 _marker: PhantomData,
8348 },
8349 TRNG0: TRNG0 {
8350 _marker: PhantomData,
8351 },
8352 EIM0: EIM0 {
8353 _marker: PhantomData,
8354 },
8355 ERM0: ERM0 {
8356 _marker: PhantomData,
8357 },
8358 INTM0: INTM0 {
8359 _marker: PhantomData,
8360 },
8361 DMA0: DMA0 {
8362 _marker: PhantomData,
8363 },
8364 DMA1: DMA1 {
8365 _marker: PhantomData,
8366 },
8367 EDMA_0_TCD: EDMA_0_TCD {
8368 _marker: PhantomData,
8369 },
8370 SCT0: SCT0 {
8371 _marker: PhantomData,
8372 },
8373 LPSPI0: LPSPI0 {
8374 _marker: PhantomData,
8375 },
8376 LPSPI1: LPSPI1 {
8377 _marker: PhantomData,
8378 },
8379 LPSPI2: LPSPI2 {
8380 _marker: PhantomData,
8381 },
8382 LPSPI3: LPSPI3 {
8383 _marker: PhantomData,
8384 },
8385 LPSPI4: LPSPI4 {
8386 _marker: PhantomData,
8387 },
8388 LPSPI5: LPSPI5 {
8389 _marker: PhantomData,
8390 },
8391 LPSPI6: LPSPI6 {
8392 _marker: PhantomData,
8393 },
8394 LPSPI7: LPSPI7 {
8395 _marker: PhantomData,
8396 },
8397 LPSPI8: LPSPI8 {
8398 _marker: PhantomData,
8399 },
8400 LPSPI9: LPSPI9 {
8401 _marker: PhantomData,
8402 },
8403 LPUART0: LPUART0 {
8404 _marker: PhantomData,
8405 },
8406 LPUART1: LPUART1 {
8407 _marker: PhantomData,
8408 },
8409 LPUART2: LPUART2 {
8410 _marker: PhantomData,
8411 },
8412 LPUART3: LPUART3 {
8413 _marker: PhantomData,
8414 },
8415 LPUART4: LPUART4 {
8416 _marker: PhantomData,
8417 },
8418 LPUART5: LPUART5 {
8419 _marker: PhantomData,
8420 },
8421 LPUART6: LPUART6 {
8422 _marker: PhantomData,
8423 },
8424 LPUART7: LPUART7 {
8425 _marker: PhantomData,
8426 },
8427 LPUART8: LPUART8 {
8428 _marker: PhantomData,
8429 },
8430 LPUART9: LPUART9 {
8431 _marker: PhantomData,
8432 },
8433 LP_FLEXCOMM0: LP_FLEXCOMM0 {
8434 _marker: PhantomData,
8435 },
8436 LP_FLEXCOMM1: LP_FLEXCOMM1 {
8437 _marker: PhantomData,
8438 },
8439 LP_FLEXCOMM2: LP_FLEXCOMM2 {
8440 _marker: PhantomData,
8441 },
8442 LP_FLEXCOMM3: LP_FLEXCOMM3 {
8443 _marker: PhantomData,
8444 },
8445 LP_FLEXCOMM4: LP_FLEXCOMM4 {
8446 _marker: PhantomData,
8447 },
8448 LP_FLEXCOMM5: LP_FLEXCOMM5 {
8449 _marker: PhantomData,
8450 },
8451 LP_FLEXCOMM6: LP_FLEXCOMM6 {
8452 _marker: PhantomData,
8453 },
8454 LP_FLEXCOMM7: LP_FLEXCOMM7 {
8455 _marker: PhantomData,
8456 },
8457 LP_FLEXCOMM8: LP_FLEXCOMM8 {
8458 _marker: PhantomData,
8459 },
8460 LP_FLEXCOMM9: LP_FLEXCOMM9 {
8461 _marker: PhantomData,
8462 },
8463 LPI2C0: LPI2C0 {
8464 _marker: PhantomData,
8465 },
8466 LPI2C1: LPI2C1 {
8467 _marker: PhantomData,
8468 },
8469 LPI2C2: LPI2C2 {
8470 _marker: PhantomData,
8471 },
8472 LPI2C3: LPI2C3 {
8473 _marker: PhantomData,
8474 },
8475 LPI2C4: LPI2C4 {
8476 _marker: PhantomData,
8477 },
8478 LPI2C5: LPI2C5 {
8479 _marker: PhantomData,
8480 },
8481 LPI2C6: LPI2C6 {
8482 _marker: PhantomData,
8483 },
8484 LPI2C7: LPI2C7 {
8485 _marker: PhantomData,
8486 },
8487 LPI2C8: LPI2C8 {
8488 _marker: PhantomData,
8489 },
8490 LPI2C9: LPI2C9 {
8491 _marker: PhantomData,
8492 },
8493 GPIO0: GPIO0 {
8494 _marker: PhantomData,
8495 },
8496 GPIO5: GPIO5 {
8497 _marker: PhantomData,
8498 },
8499 GPIO1: GPIO1 {
8500 _marker: PhantomData,
8501 },
8502 GPIO2: GPIO2 {
8503 _marker: PhantomData,
8504 },
8505 GPIO3: GPIO3 {
8506 _marker: PhantomData,
8507 },
8508 GPIO4: GPIO4 {
8509 _marker: PhantomData,
8510 },
8511 EDMA_1_TCD: EDMA_1_TCD {
8512 _marker: PhantomData,
8513 },
8514 SEMA42_0: SEMA42_0 {
8515 _marker: PhantomData,
8516 },
8517 MAILBOX: MAILBOX {
8518 _marker: PhantomData,
8519 },
8520 CDOG0: CDOG0 {
8521 _marker: PhantomData,
8522 },
8523 CDOG1: CDOG1 {
8524 _marker: PhantomData,
8525 },
8526 DM0: DM0 {
8527 _marker: PhantomData,
8528 },
8529 POWERQUAD: POWERQUAD {
8530 _marker: PhantomData,
8531 },
8532 EWM0: EWM0 {
8533 _marker: PhantomData,
8534 },
8535 CMX_PERFMON0: CMX_PERFMON0 {
8536 _marker: PhantomData,
8537 },
8538 CMX_PERFMON1: CMX_PERFMON1 {
8539 _marker: PhantomData,
8540 },
8541 TRDC: TRDC {
8542 _marker: PhantomData,
8543 },
8544 FLEXSPI0: FLEXSPI0 {
8545 _marker: PhantomData,
8546 },
8547 OTPC0: OTPC0 {
8548 _marker: PhantomData,
8549 },
8550 CRC0: CRC0 {
8551 _marker: PhantomData,
8552 },
8553 NPX0: NPX0 {
8554 _marker: PhantomData,
8555 },
8556 PWM0: PWM0 {
8557 _marker: PhantomData,
8558 },
8559 PWM1: PWM1 {
8560 _marker: PhantomData,
8561 },
8562 ENC0: ENC0 {
8563 _marker: PhantomData,
8564 },
8565 ENC1: ENC1 {
8566 _marker: PhantomData,
8567 },
8568 EVTG0: EVTG0 {
8569 _marker: PhantomData,
8570 },
8571 CAN0: CAN0 {
8572 _marker: PhantomData,
8573 },
8574 CAN1: CAN1 {
8575 _marker: PhantomData,
8576 },
8577 USBDCD0: USBDCD0 {
8578 _marker: PhantomData,
8579 },
8580 USBFS0: USBFS0 {
8581 _marker: PhantomData,
8582 },
8583 ENET0: ENET0 {
8584 _marker: PhantomData,
8585 },
8586 EMVSIM0: EMVSIM0 {
8587 _marker: PhantomData,
8588 },
8589 EMVSIM1: EMVSIM1 {
8590 _marker: PhantomData,
8591 },
8592 FLEXIO0: FLEXIO0 {
8593 _marker: PhantomData,
8594 },
8595 SAI0: SAI0 {
8596 _marker: PhantomData,
8597 },
8598 SAI1: SAI1 {
8599 _marker: PhantomData,
8600 },
8601 SINC0: SINC0 {
8602 _marker: PhantomData,
8603 },
8604 USDHC0: USDHC0 {
8605 _marker: PhantomData,
8606 },
8607 USBPHY: USBPHY {
8608 _marker: PhantomData,
8609 },
8610 USBHS1_PHY_DCD: USBHS1_PHY_DCD {
8611 _marker: PhantomData,
8612 },
8613 USBHS1__USBC: USBHS1__USBC {
8614 _marker: PhantomData,
8615 },
8616 USBHS1__USBNC: USBHS1__USBNC {
8617 _marker: PhantomData,
8618 },
8619 PDM: PDM {
8620 _marker: PhantomData,
8621 },
8622 ADC0: ADC0 {
8623 _marker: PhantomData,
8624 },
8625 ADC1: ADC1 {
8626 _marker: PhantomData,
8627 },
8628 DAC0: DAC0 {
8629 _marker: PhantomData,
8630 },
8631 DAC1: DAC1 {
8632 _marker: PhantomData,
8633 },
8634 OPAMP0: OPAMP0 {
8635 _marker: PhantomData,
8636 },
8637 OPAMP1: OPAMP1 {
8638 _marker: PhantomData,
8639 },
8640 OPAMP2: OPAMP2 {
8641 _marker: PhantomData,
8642 },
8643 VREF0: VREF0 {
8644 _marker: PhantomData,
8645 },
8646 DAC2: DAC2 {
8647 _marker: PhantomData,
8648 },
8649 PORT1: PORT1 {
8650 _marker: PhantomData,
8651 },
8652 PORT2: PORT2 {
8653 _marker: PhantomData,
8654 },
8655 PORT3: PORT3 {
8656 _marker: PhantomData,
8657 },
8658 PORT4: PORT4 {
8659 _marker: PhantomData,
8660 },
8661 AHBSC: AHBSC {
8662 _marker: PhantomData,
8663 },
8664 SCN_SCB: SCN_SCB {
8665 _marker: PhantomData,
8666 },
8667 SYS_TICK0: SYS_TICK0 {
8668 _marker: PhantomData,
8669 },
8670 SAU: SAU {
8671 _marker: PhantomData,
8672 },
8673 }
8674 }
8675}