1#![doc = "Peripheral access API for ATSAME53J microcontrollers (generated using svd2rust v0.33.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.33.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#![allow(clippy::all)]
6#![allow(unknown_lints)]
7#![allow(mismatched_lifetime_syntaxes)]
8#![no_std]
9use core::marker::PhantomData;
10use core::ops::Deref;
11#[doc = r"Number available in the NVIC for configuring priority"]
12pub const NVIC_PRIO_BITS: u8 = 3;
13#[cfg(feature = "rt")]
14pub use self::Interrupt as interrupt;
15pub use cortex_m::peripheral::Peripherals as CorePeripherals;
16pub use cortex_m::peripheral::{CBP, CPUID, DCB, DWT, FPB, FPU, ITM, MPU, NVIC, SCB, SYST, TPIU};
17#[cfg(feature = "rt")]
18pub use cortex_m_rt::interrupt;
19#[allow(unused_imports)]
20use generic::*;
21#[doc = r"Common register and bit access and modify traits"]
22pub mod generic;
23#[cfg(feature = "rt")]
24extern "C" {
25 fn PM();
26 fn MCLK();
27 fn OSCCTRL_XOSC0();
28 fn OSCCTRL_XOSC1();
29 fn OSCCTRL_DFLL();
30 fn OSCCTRL_DPLL0();
31 fn OSCCTRL_DPLL1();
32 fn OSC32KCTRL();
33 fn SUPC_OTHER();
34 fn SUPC_BODDET();
35 fn WDT();
36 fn RTC();
37 fn EIC_EXTINT_0();
38 fn EIC_EXTINT_1();
39 fn EIC_EXTINT_2();
40 fn EIC_EXTINT_3();
41 fn EIC_EXTINT_4();
42 fn EIC_EXTINT_5();
43 fn EIC_EXTINT_6();
44 fn EIC_EXTINT_7();
45 fn EIC_EXTINT_8();
46 fn EIC_EXTINT_9();
47 fn EIC_EXTINT_10();
48 fn EIC_EXTINT_11();
49 fn EIC_EXTINT_12();
50 fn EIC_EXTINT_13();
51 fn EIC_EXTINT_14();
52 fn EIC_EXTINT_15();
53 fn FREQM();
54 fn NVMCTRL_0();
55 fn NVMCTRL_1();
56 fn DMAC_0();
57 fn DMAC_1();
58 fn DMAC_2();
59 fn DMAC_3();
60 fn DMAC_OTHER();
61 fn EVSYS_0();
62 fn EVSYS_1();
63 fn EVSYS_2();
64 fn EVSYS_3();
65 fn EVSYS_OTHER();
66 fn PAC();
67 fn RAMECC();
68 fn SERCOM0_0();
69 fn SERCOM0_1();
70 fn SERCOM0_2();
71 fn SERCOM0_OTHER();
72 fn SERCOM1_0();
73 fn SERCOM1_1();
74 fn SERCOM1_2();
75 fn SERCOM1_OTHER();
76 fn SERCOM2_0();
77 fn SERCOM2_1();
78 fn SERCOM2_2();
79 fn SERCOM2_OTHER();
80 fn SERCOM3_0();
81 fn SERCOM3_1();
82 fn SERCOM3_2();
83 fn SERCOM3_OTHER();
84 fn SERCOM4_0();
85 fn SERCOM4_1();
86 fn SERCOM4_2();
87 fn SERCOM4_OTHER();
88 fn SERCOM5_0();
89 fn SERCOM5_1();
90 fn SERCOM5_2();
91 fn SERCOM5_OTHER();
92 fn USB_OTHER();
93 fn USB_SOF_HSOF();
94 fn USB_TRCPT0();
95 fn USB_TRCPT1();
96 fn GMAC();
97 fn TCC0_OTHER();
98 fn TCC0_MC0();
99 fn TCC0_MC1();
100 fn TCC0_MC2();
101 fn TCC0_MC3();
102 fn TCC0_MC4();
103 fn TCC0_MC5();
104 fn TCC1_OTHER();
105 fn TCC1_MC0();
106 fn TCC1_MC1();
107 fn TCC1_MC2();
108 fn TCC1_MC3();
109 fn TCC2_OTHER();
110 fn TCC2_MC0();
111 fn TCC2_MC1();
112 fn TCC2_MC2();
113 fn TCC3_OTHER();
114 fn TCC3_MC0();
115 fn TCC3_MC1();
116 fn TCC4_OTHER();
117 fn TCC4_MC0();
118 fn TCC4_MC1();
119 fn TC0();
120 fn TC1();
121 fn TC2();
122 fn TC3();
123 fn TC4();
124 fn TC5();
125 fn PDEC_OTHER();
126 fn PDEC_MC0();
127 fn PDEC_MC1();
128 fn ADC0_OTHER();
129 fn ADC0_RESRDY();
130 fn ADC1_OTHER();
131 fn ADC1_RESRDY();
132 fn AC();
133 fn DAC_OTHER();
134 fn DAC_EMPTY_0();
135 fn DAC_EMPTY_1();
136 fn DAC_RESRDY_0();
137 fn DAC_RESRDY_1();
138 fn I2S();
139 fn PCC();
140 fn AES();
141 fn TRNG();
142 fn ICM();
143 fn QSPI();
144 fn SDHC0();
145}
146#[doc(hidden)]
147#[repr(C)]
148pub union Vector {
149 _handler: unsafe extern "C" fn(),
150 _reserved: u32,
151}
152#[cfg(feature = "rt")]
153#[doc(hidden)]
154#[link_section = ".vector_table.interrupts"]
155#[no_mangle]
156pub static __INTERRUPTS: [Vector; 136] = [
157 Vector { _handler: PM },
158 Vector { _handler: MCLK },
159 Vector {
160 _handler: OSCCTRL_XOSC0,
161 },
162 Vector {
163 _handler: OSCCTRL_XOSC1,
164 },
165 Vector {
166 _handler: OSCCTRL_DFLL,
167 },
168 Vector {
169 _handler: OSCCTRL_DPLL0,
170 },
171 Vector {
172 _handler: OSCCTRL_DPLL1,
173 },
174 Vector {
175 _handler: OSC32KCTRL,
176 },
177 Vector {
178 _handler: SUPC_OTHER,
179 },
180 Vector {
181 _handler: SUPC_BODDET,
182 },
183 Vector { _handler: WDT },
184 Vector { _handler: RTC },
185 Vector {
186 _handler: EIC_EXTINT_0,
187 },
188 Vector {
189 _handler: EIC_EXTINT_1,
190 },
191 Vector {
192 _handler: EIC_EXTINT_2,
193 },
194 Vector {
195 _handler: EIC_EXTINT_3,
196 },
197 Vector {
198 _handler: EIC_EXTINT_4,
199 },
200 Vector {
201 _handler: EIC_EXTINT_5,
202 },
203 Vector {
204 _handler: EIC_EXTINT_6,
205 },
206 Vector {
207 _handler: EIC_EXTINT_7,
208 },
209 Vector {
210 _handler: EIC_EXTINT_8,
211 },
212 Vector {
213 _handler: EIC_EXTINT_9,
214 },
215 Vector {
216 _handler: EIC_EXTINT_10,
217 },
218 Vector {
219 _handler: EIC_EXTINT_11,
220 },
221 Vector {
222 _handler: EIC_EXTINT_12,
223 },
224 Vector {
225 _handler: EIC_EXTINT_13,
226 },
227 Vector {
228 _handler: EIC_EXTINT_14,
229 },
230 Vector {
231 _handler: EIC_EXTINT_15,
232 },
233 Vector { _handler: FREQM },
234 Vector {
235 _handler: NVMCTRL_0,
236 },
237 Vector {
238 _handler: NVMCTRL_1,
239 },
240 Vector { _handler: DMAC_0 },
241 Vector { _handler: DMAC_1 },
242 Vector { _handler: DMAC_2 },
243 Vector { _handler: DMAC_3 },
244 Vector {
245 _handler: DMAC_OTHER,
246 },
247 Vector { _handler: EVSYS_0 },
248 Vector { _handler: EVSYS_1 },
249 Vector { _handler: EVSYS_2 },
250 Vector { _handler: EVSYS_3 },
251 Vector {
252 _handler: EVSYS_OTHER,
253 },
254 Vector { _handler: PAC },
255 Vector { _reserved: 0 },
256 Vector { _reserved: 0 },
257 Vector { _reserved: 0 },
258 Vector { _handler: RAMECC },
259 Vector {
260 _handler: SERCOM0_0,
261 },
262 Vector {
263 _handler: SERCOM0_1,
264 },
265 Vector {
266 _handler: SERCOM0_2,
267 },
268 Vector {
269 _handler: SERCOM0_OTHER,
270 },
271 Vector {
272 _handler: SERCOM1_0,
273 },
274 Vector {
275 _handler: SERCOM1_1,
276 },
277 Vector {
278 _handler: SERCOM1_2,
279 },
280 Vector {
281 _handler: SERCOM1_OTHER,
282 },
283 Vector {
284 _handler: SERCOM2_0,
285 },
286 Vector {
287 _handler: SERCOM2_1,
288 },
289 Vector {
290 _handler: SERCOM2_2,
291 },
292 Vector {
293 _handler: SERCOM2_OTHER,
294 },
295 Vector {
296 _handler: SERCOM3_0,
297 },
298 Vector {
299 _handler: SERCOM3_1,
300 },
301 Vector {
302 _handler: SERCOM3_2,
303 },
304 Vector {
305 _handler: SERCOM3_OTHER,
306 },
307 Vector {
308 _handler: SERCOM4_0,
309 },
310 Vector {
311 _handler: SERCOM4_1,
312 },
313 Vector {
314 _handler: SERCOM4_2,
315 },
316 Vector {
317 _handler: SERCOM4_OTHER,
318 },
319 Vector {
320 _handler: SERCOM5_0,
321 },
322 Vector {
323 _handler: SERCOM5_1,
324 },
325 Vector {
326 _handler: SERCOM5_2,
327 },
328 Vector {
329 _handler: SERCOM5_OTHER,
330 },
331 Vector { _reserved: 0 },
332 Vector { _reserved: 0 },
333 Vector { _reserved: 0 },
334 Vector { _reserved: 0 },
335 Vector { _reserved: 0 },
336 Vector { _reserved: 0 },
337 Vector { _reserved: 0 },
338 Vector { _reserved: 0 },
339 Vector { _reserved: 0 },
340 Vector { _reserved: 0 },
341 Vector {
342 _handler: USB_OTHER,
343 },
344 Vector {
345 _handler: USB_SOF_HSOF,
346 },
347 Vector {
348 _handler: USB_TRCPT0,
349 },
350 Vector {
351 _handler: USB_TRCPT1,
352 },
353 Vector { _handler: GMAC },
354 Vector {
355 _handler: TCC0_OTHER,
356 },
357 Vector { _handler: TCC0_MC0 },
358 Vector { _handler: TCC0_MC1 },
359 Vector { _handler: TCC0_MC2 },
360 Vector { _handler: TCC0_MC3 },
361 Vector { _handler: TCC0_MC4 },
362 Vector { _handler: TCC0_MC5 },
363 Vector {
364 _handler: TCC1_OTHER,
365 },
366 Vector { _handler: TCC1_MC0 },
367 Vector { _handler: TCC1_MC1 },
368 Vector { _handler: TCC1_MC2 },
369 Vector { _handler: TCC1_MC3 },
370 Vector {
371 _handler: TCC2_OTHER,
372 },
373 Vector { _handler: TCC2_MC0 },
374 Vector { _handler: TCC2_MC1 },
375 Vector { _handler: TCC2_MC2 },
376 Vector {
377 _handler: TCC3_OTHER,
378 },
379 Vector { _handler: TCC3_MC0 },
380 Vector { _handler: TCC3_MC1 },
381 Vector {
382 _handler: TCC4_OTHER,
383 },
384 Vector { _handler: TCC4_MC0 },
385 Vector { _handler: TCC4_MC1 },
386 Vector { _handler: TC0 },
387 Vector { _handler: TC1 },
388 Vector { _handler: TC2 },
389 Vector { _handler: TC3 },
390 Vector { _handler: TC4 },
391 Vector { _handler: TC5 },
392 Vector { _reserved: 0 },
393 Vector { _reserved: 0 },
394 Vector {
395 _handler: PDEC_OTHER,
396 },
397 Vector { _handler: PDEC_MC0 },
398 Vector { _handler: PDEC_MC1 },
399 Vector {
400 _handler: ADC0_OTHER,
401 },
402 Vector {
403 _handler: ADC0_RESRDY,
404 },
405 Vector {
406 _handler: ADC1_OTHER,
407 },
408 Vector {
409 _handler: ADC1_RESRDY,
410 },
411 Vector { _handler: AC },
412 Vector {
413 _handler: DAC_OTHER,
414 },
415 Vector {
416 _handler: DAC_EMPTY_0,
417 },
418 Vector {
419 _handler: DAC_EMPTY_1,
420 },
421 Vector {
422 _handler: DAC_RESRDY_0,
423 },
424 Vector {
425 _handler: DAC_RESRDY_1,
426 },
427 Vector { _handler: I2S },
428 Vector { _handler: PCC },
429 Vector { _handler: AES },
430 Vector { _handler: TRNG },
431 Vector { _handler: ICM },
432 Vector { _reserved: 0 },
433 Vector { _handler: QSPI },
434 Vector { _handler: SDHC0 },
435];
436#[doc = r"Enumeration of all the interrupts."]
437#[derive(Copy, Clone, Debug, PartialEq, Eq)]
438#[repr(u16)]
439pub enum Interrupt {
440 #[doc = "0 - Power Manager"]
441 PM = 0,
442 #[doc = "1 - Main Clock"]
443 MCLK = 1,
444 #[doc = "2 - External Oscillator 0"]
445 OSCCTRL_XOSC0 = 2,
446 #[doc = "3 - External Oscillator 1"]
447 OSCCTRL_XOSC1 = 3,
448 #[doc = "4 - Digital Frequency Locked Loop"]
449 OSCCTRL_DFLL = 4,
450 #[doc = "5 - Digital Phase Locked Loop 0"]
451 OSCCTRL_DPLL0 = 5,
452 #[doc = "6 - Digital Phase Locked Loop 1"]
453 OSCCTRL_DPLL1 = 6,
454 #[doc = "7 - 32Khz Oscillator Controller"]
455 OSC32KCTRL = 7,
456 #[doc = "8 - Suppyly controller"]
457 SUPC_OTHER = 8,
458 #[doc = "9 - Brown Out Detection"]
459 SUPC_BODDET = 9,
460 #[doc = "10 - Watch Dog Timer"]
461 WDT = 10,
462 #[doc = "11 - Real Time Counter"]
463 RTC = 11,
464 #[doc = "12 - EIC Channel 0"]
465 EIC_EXTINT_0 = 12,
466 #[doc = "13 - EIC Channel 1"]
467 EIC_EXTINT_1 = 13,
468 #[doc = "14 - EIC Channel 2"]
469 EIC_EXTINT_2 = 14,
470 #[doc = "15 - EIC Channel 3"]
471 EIC_EXTINT_3 = 15,
472 #[doc = "16 - EIC Channel 4"]
473 EIC_EXTINT_4 = 16,
474 #[doc = "17 - EIC Channel 5"]
475 EIC_EXTINT_5 = 17,
476 #[doc = "18 - EIC Channel 6"]
477 EIC_EXTINT_6 = 18,
478 #[doc = "19 - EIC Channel 7"]
479 EIC_EXTINT_7 = 19,
480 #[doc = "20 - EIC Channel 8"]
481 EIC_EXTINT_8 = 20,
482 #[doc = "21 - EIC Channel 9"]
483 EIC_EXTINT_9 = 21,
484 #[doc = "22 - EIC Channel 10"]
485 EIC_EXTINT_10 = 22,
486 #[doc = "23 - EIC Channel 11"]
487 EIC_EXTINT_11 = 23,
488 #[doc = "24 - EIC Channel 12"]
489 EIC_EXTINT_12 = 24,
490 #[doc = "25 - EIC Channel 13"]
491 EIC_EXTINT_13 = 25,
492 #[doc = "26 - EIC Channel 14"]
493 EIC_EXTINT_14 = 26,
494 #[doc = "27 - EIC Channel 15"]
495 EIC_EXTINT_15 = 27,
496 #[doc = "28 - Frequency Meter"]
497 FREQM = 28,
498 #[doc = "29 - Non-Volatile Memory Controller"]
499 NVMCTRL_0 = 29,
500 #[doc = "30 - NVMCTRL SmartEEPROM Interrupts"]
501 NVMCTRL_1 = 30,
502 #[doc = "31 - DMA Channel 0"]
503 DMAC_0 = 31,
504 #[doc = "32 - DMA Channel 1"]
505 DMAC_1 = 32,
506 #[doc = "33 - DMA Channel 2"]
507 DMAC_2 = 33,
508 #[doc = "34 - DMA Channel 3"]
509 DMAC_3 = 34,
510 #[doc = "35 - DMA Channel 4..X"]
511 DMAC_OTHER = 35,
512 #[doc = "36 - Event System Channel 0"]
513 EVSYS_0 = 36,
514 #[doc = "37 - Event System Channel 1"]
515 EVSYS_1 = 37,
516 #[doc = "38 - Event System Channel 2"]
517 EVSYS_2 = 38,
518 #[doc = "39 - Event System Channel 3"]
519 EVSYS_3 = 39,
520 #[doc = "40 - Event System Channel 4..X"]
521 EVSYS_OTHER = 40,
522 #[doc = "41 - Peripheral Access Controller"]
523 PAC = 41,
524 #[doc = "45 - RAM Error Correction Code"]
525 RAMECC = 45,
526 #[doc = "46 - Serial Communication Interface 0"]
527 SERCOM0_0 = 46,
528 #[doc = "47 - Serial Communication Interface 0"]
529 SERCOM0_1 = 47,
530 #[doc = "48 - Serial Communication Interface 0"]
531 SERCOM0_2 = 48,
532 #[doc = "49 - Serial Communication Interface 0"]
533 SERCOM0_OTHER = 49,
534 #[doc = "50 - Serial Communication Interface 1"]
535 SERCOM1_0 = 50,
536 #[doc = "51 - Serial Communication Interface 1"]
537 SERCOM1_1 = 51,
538 #[doc = "52 - Serial Communication Interface 1"]
539 SERCOM1_2 = 52,
540 #[doc = "53 - Serial Communication Interface 1"]
541 SERCOM1_OTHER = 53,
542 #[doc = "54 - Serial Communication Interface 2"]
543 SERCOM2_0 = 54,
544 #[doc = "55 - Serial Communication Interface 2"]
545 SERCOM2_1 = 55,
546 #[doc = "56 - Serial Communication Interface 2"]
547 SERCOM2_2 = 56,
548 #[doc = "57 - Serial Communication Interface 2"]
549 SERCOM2_OTHER = 57,
550 #[doc = "58 - Serial Communication Interface 3"]
551 SERCOM3_0 = 58,
552 #[doc = "59 - Serial Communication Interface 3"]
553 SERCOM3_1 = 59,
554 #[doc = "60 - Serial Communication Interface 3"]
555 SERCOM3_2 = 60,
556 #[doc = "61 - Serial Communication Interface 3"]
557 SERCOM3_OTHER = 61,
558 #[doc = "62 - Serial Communication Interface 4"]
559 SERCOM4_0 = 62,
560 #[doc = "63 - Serial Communication Interface 4"]
561 SERCOM4_1 = 63,
562 #[doc = "64 - Serial Communication Interface 4"]
563 SERCOM4_2 = 64,
564 #[doc = "65 - Serial Communication Interface 4"]
565 SERCOM4_OTHER = 65,
566 #[doc = "66 - Serial Communication Interface 5"]
567 SERCOM5_0 = 66,
568 #[doc = "67 - Serial Communication Interface 5"]
569 SERCOM5_1 = 67,
570 #[doc = "68 - Serial Communication Interface 5"]
571 SERCOM5_2 = 68,
572 #[doc = "69 - Serial Communication Interface 5"]
573 SERCOM5_OTHER = 69,
574 #[doc = "80 - Universal Serial Bus"]
575 USB_OTHER = 80,
576 #[doc = "81 - USB Start of Frame"]
577 USB_SOF_HSOF = 81,
578 #[doc = "82 - USB Transfer Complete 0"]
579 USB_TRCPT0 = 82,
580 #[doc = "83 - USB Transfer Complete 1"]
581 USB_TRCPT1 = 83,
582 #[doc = "84 - Ethernet MAC"]
583 GMAC = 84,
584 #[doc = "85 - Timer Counter Control 0"]
585 TCC0_OTHER = 85,
586 #[doc = "86 - TCC Match/Compare 0"]
587 TCC0_MC0 = 86,
588 #[doc = "87 - TCC Match/Compare 1"]
589 TCC0_MC1 = 87,
590 #[doc = "88 - TCC Match/Compare 2"]
591 TCC0_MC2 = 88,
592 #[doc = "89 - TCC Match/Compare 3"]
593 TCC0_MC3 = 89,
594 #[doc = "90 - TCC Match/Compare 4"]
595 TCC0_MC4 = 90,
596 #[doc = "91 - TCC Match/Compare 5"]
597 TCC0_MC5 = 91,
598 #[doc = "92 - Timer Counter Control 1"]
599 TCC1_OTHER = 92,
600 #[doc = "93 - TCC Match/Compare 0"]
601 TCC1_MC0 = 93,
602 #[doc = "94 - TCC Match/Compare 1"]
603 TCC1_MC1 = 94,
604 #[doc = "95 - TCC Match/Compare 2"]
605 TCC1_MC2 = 95,
606 #[doc = "96 - TCC Match/Compare 3"]
607 TCC1_MC3 = 96,
608 #[doc = "97 - Timer Counter Control 2"]
609 TCC2_OTHER = 97,
610 #[doc = "98 - TCC Match/Compare 0"]
611 TCC2_MC0 = 98,
612 #[doc = "99 - TCC Match/Compare 1"]
613 TCC2_MC1 = 99,
614 #[doc = "100 - TCC Match/Compare 2"]
615 TCC2_MC2 = 100,
616 #[doc = "101 - Timer Counter Control 3"]
617 TCC3_OTHER = 101,
618 #[doc = "102 - TCC Match/Compare 0"]
619 TCC3_MC0 = 102,
620 #[doc = "103 - TCC Match/Compare 1"]
621 TCC3_MC1 = 103,
622 #[doc = "104 - Timer Counter Control 4"]
623 TCC4_OTHER = 104,
624 #[doc = "105 - TCC Match/Compare 0"]
625 TCC4_MC0 = 105,
626 #[doc = "106 - TCC Match/Compare 1"]
627 TCC4_MC1 = 106,
628 #[doc = "107 - Timer Counter 0"]
629 TC0 = 107,
630 #[doc = "108 - Timer Counter 1"]
631 TC1 = 108,
632 #[doc = "109 - Timer Counter 2"]
633 TC2 = 109,
634 #[doc = "110 - Timer Counter 3"]
635 TC3 = 110,
636 #[doc = "111 - Timer Counter 4"]
637 TC4 = 111,
638 #[doc = "112 - Timer Counter 5"]
639 TC5 = 112,
640 #[doc = "115 - Position Decoder"]
641 PDEC_OTHER = 115,
642 #[doc = "116 - PDEC Match/Compare 0"]
643 PDEC_MC0 = 116,
644 #[doc = "117 - PDEC Match Compare 1"]
645 PDEC_MC1 = 117,
646 #[doc = "118 - Analog To Digital Converter 0"]
647 ADC0_OTHER = 118,
648 #[doc = "119 - ADC0 Result Ready"]
649 ADC0_RESRDY = 119,
650 #[doc = "120 - Analog To Digital Converter 1"]
651 ADC1_OTHER = 120,
652 #[doc = "121 - ADC1 Result Ready"]
653 ADC1_RESRDY = 121,
654 #[doc = "122 - Analog Comparator"]
655 AC = 122,
656 #[doc = "123 - Digital to Analog Converter"]
657 DAC_OTHER = 123,
658 #[doc = "124 - DAC Buffer 0 Empty"]
659 DAC_EMPTY_0 = 124,
660 #[doc = "125 - DAC Buffer 1 Empty"]
661 DAC_EMPTY_1 = 125,
662 #[doc = "126 - DAC Filter 0 Result Ready"]
663 DAC_RESRDY_0 = 126,
664 #[doc = "127 - DAC Filter 1 Result Ready"]
665 DAC_RESRDY_1 = 127,
666 #[doc = "128 - Inter-IC Sound Interface"]
667 I2S = 128,
668 #[doc = "129 - Parallel Capture Controller"]
669 PCC = 129,
670 #[doc = "130 - Advanced Encryption Standard"]
671 AES = 130,
672 #[doc = "131 - True Random Generator"]
673 TRNG = 131,
674 #[doc = "132 - Integrity Check Monitor"]
675 ICM = 132,
676 #[doc = "134 - Quad SPI interface"]
677 QSPI = 134,
678 #[doc = "135 - SD/MMC Host Controller 0"]
679 SDHC0 = 135,
680}
681unsafe impl cortex_m::interrupt::InterruptNumber for Interrupt {
682 #[inline(always)]
683 fn number(self) -> u16 {
684 self as u16
685 }
686}
687#[doc = "Analog Comparators"]
688pub struct Ac {
689 _marker: PhantomData<*const ()>,
690}
691unsafe impl Send for Ac {}
692impl Ac {
693 #[doc = r"Pointer to the register block"]
694 pub const PTR: *const ac::RegisterBlock = 0x4200_2000 as *const _;
695 #[doc = r"Return the pointer to the register block"]
696 #[inline(always)]
697 pub const fn ptr() -> *const ac::RegisterBlock {
698 Self::PTR
699 }
700 #[doc = r" Steal an instance of this peripheral"]
701 #[doc = r""]
702 #[doc = r" # Safety"]
703 #[doc = r""]
704 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
705 #[doc = r" that may race with any existing instances, for example by only"]
706 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
707 #[doc = r" original peripheral and using critical sections to coordinate"]
708 #[doc = r" access between multiple new instances."]
709 #[doc = r""]
710 #[doc = r" Additionally, other software such as HALs may rely on only one"]
711 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
712 #[doc = r" no stolen instances are passed to such software."]
713 pub unsafe fn steal() -> Self {
714 Self {
715 _marker: PhantomData,
716 }
717 }
718}
719impl Deref for Ac {
720 type Target = ac::RegisterBlock;
721 #[inline(always)]
722 fn deref(&self) -> &Self::Target {
723 unsafe { &*Self::PTR }
724 }
725}
726impl core::fmt::Debug for Ac {
727 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
728 f.debug_struct("Ac").finish()
729 }
730}
731#[doc = "Analog Comparators"]
732pub mod ac;
733#[doc = "Analog Digital Converter"]
734pub struct Adc0 {
735 _marker: PhantomData<*const ()>,
736}
737unsafe impl Send for Adc0 {}
738impl Adc0 {
739 #[doc = r"Pointer to the register block"]
740 pub const PTR: *const adc0::RegisterBlock = 0x4300_1c00 as *const _;
741 #[doc = r"Return the pointer to the register block"]
742 #[inline(always)]
743 pub const fn ptr() -> *const adc0::RegisterBlock {
744 Self::PTR
745 }
746 #[doc = r" Steal an instance of this peripheral"]
747 #[doc = r""]
748 #[doc = r" # Safety"]
749 #[doc = r""]
750 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
751 #[doc = r" that may race with any existing instances, for example by only"]
752 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
753 #[doc = r" original peripheral and using critical sections to coordinate"]
754 #[doc = r" access between multiple new instances."]
755 #[doc = r""]
756 #[doc = r" Additionally, other software such as HALs may rely on only one"]
757 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
758 #[doc = r" no stolen instances are passed to such software."]
759 pub unsafe fn steal() -> Self {
760 Self {
761 _marker: PhantomData,
762 }
763 }
764}
765impl Deref for Adc0 {
766 type Target = adc0::RegisterBlock;
767 #[inline(always)]
768 fn deref(&self) -> &Self::Target {
769 unsafe { &*Self::PTR }
770 }
771}
772impl core::fmt::Debug for Adc0 {
773 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
774 f.debug_struct("Adc0").finish()
775 }
776}
777#[doc = "Analog Digital Converter"]
778pub mod adc0;
779#[doc = "Analog Digital Converter"]
780pub struct Adc1 {
781 _marker: PhantomData<*const ()>,
782}
783unsafe impl Send for Adc1 {}
784impl Adc1 {
785 #[doc = r"Pointer to the register block"]
786 pub const PTR: *const adc0::RegisterBlock = 0x4300_2000 as *const _;
787 #[doc = r"Return the pointer to the register block"]
788 #[inline(always)]
789 pub const fn ptr() -> *const adc0::RegisterBlock {
790 Self::PTR
791 }
792 #[doc = r" Steal an instance of this peripheral"]
793 #[doc = r""]
794 #[doc = r" # Safety"]
795 #[doc = r""]
796 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
797 #[doc = r" that may race with any existing instances, for example by only"]
798 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
799 #[doc = r" original peripheral and using critical sections to coordinate"]
800 #[doc = r" access between multiple new instances."]
801 #[doc = r""]
802 #[doc = r" Additionally, other software such as HALs may rely on only one"]
803 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
804 #[doc = r" no stolen instances are passed to such software."]
805 pub unsafe fn steal() -> Self {
806 Self {
807 _marker: PhantomData,
808 }
809 }
810}
811impl Deref for Adc1 {
812 type Target = adc0::RegisterBlock;
813 #[inline(always)]
814 fn deref(&self) -> &Self::Target {
815 unsafe { &*Self::PTR }
816 }
817}
818impl core::fmt::Debug for Adc1 {
819 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
820 f.debug_struct("Adc1").finish()
821 }
822}
823#[doc = "Analog Digital Converter"]
824pub use self::adc0 as adc1;
825#[doc = "Advanced Encryption Standard"]
826pub struct Aes {
827 _marker: PhantomData<*const ()>,
828}
829unsafe impl Send for Aes {}
830impl Aes {
831 #[doc = r"Pointer to the register block"]
832 pub const PTR: *const aes::RegisterBlock = 0x4200_2400 as *const _;
833 #[doc = r"Return the pointer to the register block"]
834 #[inline(always)]
835 pub const fn ptr() -> *const aes::RegisterBlock {
836 Self::PTR
837 }
838 #[doc = r" Steal an instance of this peripheral"]
839 #[doc = r""]
840 #[doc = r" # Safety"]
841 #[doc = r""]
842 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
843 #[doc = r" that may race with any existing instances, for example by only"]
844 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
845 #[doc = r" original peripheral and using critical sections to coordinate"]
846 #[doc = r" access between multiple new instances."]
847 #[doc = r""]
848 #[doc = r" Additionally, other software such as HALs may rely on only one"]
849 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
850 #[doc = r" no stolen instances are passed to such software."]
851 pub unsafe fn steal() -> Self {
852 Self {
853 _marker: PhantomData,
854 }
855 }
856}
857impl Deref for Aes {
858 type Target = aes::RegisterBlock;
859 #[inline(always)]
860 fn deref(&self) -> &Self::Target {
861 unsafe { &*Self::PTR }
862 }
863}
864impl core::fmt::Debug for Aes {
865 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
866 f.debug_struct("Aes").finish()
867 }
868}
869#[doc = "Advanced Encryption Standard"]
870pub mod aes;
871#[doc = "Configurable Custom Logic"]
872pub struct Ccl {
873 _marker: PhantomData<*const ()>,
874}
875unsafe impl Send for Ccl {}
876impl Ccl {
877 #[doc = r"Pointer to the register block"]
878 pub const PTR: *const ccl::RegisterBlock = 0x4200_3800 as *const _;
879 #[doc = r"Return the pointer to the register block"]
880 #[inline(always)]
881 pub const fn ptr() -> *const ccl::RegisterBlock {
882 Self::PTR
883 }
884 #[doc = r" Steal an instance of this peripheral"]
885 #[doc = r""]
886 #[doc = r" # Safety"]
887 #[doc = r""]
888 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
889 #[doc = r" that may race with any existing instances, for example by only"]
890 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
891 #[doc = r" original peripheral and using critical sections to coordinate"]
892 #[doc = r" access between multiple new instances."]
893 #[doc = r""]
894 #[doc = r" Additionally, other software such as HALs may rely on only one"]
895 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
896 #[doc = r" no stolen instances are passed to such software."]
897 pub unsafe fn steal() -> Self {
898 Self {
899 _marker: PhantomData,
900 }
901 }
902}
903impl Deref for Ccl {
904 type Target = ccl::RegisterBlock;
905 #[inline(always)]
906 fn deref(&self) -> &Self::Target {
907 unsafe { &*Self::PTR }
908 }
909}
910impl core::fmt::Debug for Ccl {
911 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
912 f.debug_struct("Ccl").finish()
913 }
914}
915#[doc = "Configurable Custom Logic"]
916pub mod ccl;
917#[doc = "Cortex M Cache Controller"]
918pub struct Cmcc {
919 _marker: PhantomData<*const ()>,
920}
921unsafe impl Send for Cmcc {}
922impl Cmcc {
923 #[doc = r"Pointer to the register block"]
924 pub const PTR: *const cmcc::RegisterBlock = 0x4100_6000 as *const _;
925 #[doc = r"Return the pointer to the register block"]
926 #[inline(always)]
927 pub const fn ptr() -> *const cmcc::RegisterBlock {
928 Self::PTR
929 }
930 #[doc = r" Steal an instance of this peripheral"]
931 #[doc = r""]
932 #[doc = r" # Safety"]
933 #[doc = r""]
934 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
935 #[doc = r" that may race with any existing instances, for example by only"]
936 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
937 #[doc = r" original peripheral and using critical sections to coordinate"]
938 #[doc = r" access between multiple new instances."]
939 #[doc = r""]
940 #[doc = r" Additionally, other software such as HALs may rely on only one"]
941 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
942 #[doc = r" no stolen instances are passed to such software."]
943 pub unsafe fn steal() -> Self {
944 Self {
945 _marker: PhantomData,
946 }
947 }
948}
949impl Deref for Cmcc {
950 type Target = cmcc::RegisterBlock;
951 #[inline(always)]
952 fn deref(&self) -> &Self::Target {
953 unsafe { &*Self::PTR }
954 }
955}
956impl core::fmt::Debug for Cmcc {
957 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
958 f.debug_struct("Cmcc").finish()
959 }
960}
961#[doc = "Cortex M Cache Controller"]
962pub mod cmcc;
963#[doc = "Digital-to-Analog Converter"]
964pub struct Dac {
965 _marker: PhantomData<*const ()>,
966}
967unsafe impl Send for Dac {}
968impl Dac {
969 #[doc = r"Pointer to the register block"]
970 pub const PTR: *const dac::RegisterBlock = 0x4300_2400 as *const _;
971 #[doc = r"Return the pointer to the register block"]
972 #[inline(always)]
973 pub const fn ptr() -> *const dac::RegisterBlock {
974 Self::PTR
975 }
976 #[doc = r" Steal an instance of this peripheral"]
977 #[doc = r""]
978 #[doc = r" # Safety"]
979 #[doc = r""]
980 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
981 #[doc = r" that may race with any existing instances, for example by only"]
982 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
983 #[doc = r" original peripheral and using critical sections to coordinate"]
984 #[doc = r" access between multiple new instances."]
985 #[doc = r""]
986 #[doc = r" Additionally, other software such as HALs may rely on only one"]
987 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
988 #[doc = r" no stolen instances are passed to such software."]
989 pub unsafe fn steal() -> Self {
990 Self {
991 _marker: PhantomData,
992 }
993 }
994}
995impl Deref for Dac {
996 type Target = dac::RegisterBlock;
997 #[inline(always)]
998 fn deref(&self) -> &Self::Target {
999 unsafe { &*Self::PTR }
1000 }
1001}
1002impl core::fmt::Debug for Dac {
1003 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1004 f.debug_struct("Dac").finish()
1005 }
1006}
1007#[doc = "Digital-to-Analog Converter"]
1008pub mod dac;
1009#[doc = "Direct Memory Access Controller"]
1010pub struct Dmac {
1011 _marker: PhantomData<*const ()>,
1012}
1013unsafe impl Send for Dmac {}
1014impl Dmac {
1015 #[doc = r"Pointer to the register block"]
1016 pub const PTR: *const dmac::RegisterBlock = 0x4100_a000 as *const _;
1017 #[doc = r"Return the pointer to the register block"]
1018 #[inline(always)]
1019 pub const fn ptr() -> *const dmac::RegisterBlock {
1020 Self::PTR
1021 }
1022 #[doc = r" Steal an instance of this peripheral"]
1023 #[doc = r""]
1024 #[doc = r" # Safety"]
1025 #[doc = r""]
1026 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1027 #[doc = r" that may race with any existing instances, for example by only"]
1028 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1029 #[doc = r" original peripheral and using critical sections to coordinate"]
1030 #[doc = r" access between multiple new instances."]
1031 #[doc = r""]
1032 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1033 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1034 #[doc = r" no stolen instances are passed to such software."]
1035 pub unsafe fn steal() -> Self {
1036 Self {
1037 _marker: PhantomData,
1038 }
1039 }
1040}
1041impl Deref for Dmac {
1042 type Target = dmac::RegisterBlock;
1043 #[inline(always)]
1044 fn deref(&self) -> &Self::Target {
1045 unsafe { &*Self::PTR }
1046 }
1047}
1048impl core::fmt::Debug for Dmac {
1049 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1050 f.debug_struct("Dmac").finish()
1051 }
1052}
1053#[doc = "Direct Memory Access Controller"]
1054pub mod dmac;
1055#[doc = "Device Service Unit"]
1056pub struct Dsu {
1057 _marker: PhantomData<*const ()>,
1058}
1059unsafe impl Send for Dsu {}
1060impl Dsu {
1061 #[doc = r"Pointer to the register block"]
1062 pub const PTR: *const dsu::RegisterBlock = 0x4100_2000 as *const _;
1063 #[doc = r"Return the pointer to the register block"]
1064 #[inline(always)]
1065 pub const fn ptr() -> *const dsu::RegisterBlock {
1066 Self::PTR
1067 }
1068 #[doc = r" Steal an instance of this peripheral"]
1069 #[doc = r""]
1070 #[doc = r" # Safety"]
1071 #[doc = r""]
1072 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1073 #[doc = r" that may race with any existing instances, for example by only"]
1074 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1075 #[doc = r" original peripheral and using critical sections to coordinate"]
1076 #[doc = r" access between multiple new instances."]
1077 #[doc = r""]
1078 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1079 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1080 #[doc = r" no stolen instances are passed to such software."]
1081 pub unsafe fn steal() -> Self {
1082 Self {
1083 _marker: PhantomData,
1084 }
1085 }
1086}
1087impl Deref for Dsu {
1088 type Target = dsu::RegisterBlock;
1089 #[inline(always)]
1090 fn deref(&self) -> &Self::Target {
1091 unsafe { &*Self::PTR }
1092 }
1093}
1094impl core::fmt::Debug for Dsu {
1095 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1096 f.debug_struct("Dsu").finish()
1097 }
1098}
1099#[doc = "Device Service Unit"]
1100pub mod dsu;
1101#[doc = "External Interrupt Controller"]
1102pub struct Eic {
1103 _marker: PhantomData<*const ()>,
1104}
1105unsafe impl Send for Eic {}
1106impl Eic {
1107 #[doc = r"Pointer to the register block"]
1108 pub const PTR: *const eic::RegisterBlock = 0x4000_2800 as *const _;
1109 #[doc = r"Return the pointer to the register block"]
1110 #[inline(always)]
1111 pub const fn ptr() -> *const eic::RegisterBlock {
1112 Self::PTR
1113 }
1114 #[doc = r" Steal an instance of this peripheral"]
1115 #[doc = r""]
1116 #[doc = r" # Safety"]
1117 #[doc = r""]
1118 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1119 #[doc = r" that may race with any existing instances, for example by only"]
1120 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1121 #[doc = r" original peripheral and using critical sections to coordinate"]
1122 #[doc = r" access between multiple new instances."]
1123 #[doc = r""]
1124 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1125 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1126 #[doc = r" no stolen instances are passed to such software."]
1127 pub unsafe fn steal() -> Self {
1128 Self {
1129 _marker: PhantomData,
1130 }
1131 }
1132}
1133impl Deref for Eic {
1134 type Target = eic::RegisterBlock;
1135 #[inline(always)]
1136 fn deref(&self) -> &Self::Target {
1137 unsafe { &*Self::PTR }
1138 }
1139}
1140impl core::fmt::Debug for Eic {
1141 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1142 f.debug_struct("Eic").finish()
1143 }
1144}
1145#[doc = "External Interrupt Controller"]
1146pub mod eic;
1147#[doc = "Event System Interface"]
1148pub struct Evsys {
1149 _marker: PhantomData<*const ()>,
1150}
1151unsafe impl Send for Evsys {}
1152impl Evsys {
1153 #[doc = r"Pointer to the register block"]
1154 pub const PTR: *const evsys::RegisterBlock = 0x4100_e000 as *const _;
1155 #[doc = r"Return the pointer to the register block"]
1156 #[inline(always)]
1157 pub const fn ptr() -> *const evsys::RegisterBlock {
1158 Self::PTR
1159 }
1160 #[doc = r" Steal an instance of this peripheral"]
1161 #[doc = r""]
1162 #[doc = r" # Safety"]
1163 #[doc = r""]
1164 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1165 #[doc = r" that may race with any existing instances, for example by only"]
1166 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1167 #[doc = r" original peripheral and using critical sections to coordinate"]
1168 #[doc = r" access between multiple new instances."]
1169 #[doc = r""]
1170 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1171 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1172 #[doc = r" no stolen instances are passed to such software."]
1173 pub unsafe fn steal() -> Self {
1174 Self {
1175 _marker: PhantomData,
1176 }
1177 }
1178}
1179impl Deref for Evsys {
1180 type Target = evsys::RegisterBlock;
1181 #[inline(always)]
1182 fn deref(&self) -> &Self::Target {
1183 unsafe { &*Self::PTR }
1184 }
1185}
1186impl core::fmt::Debug for Evsys {
1187 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1188 f.debug_struct("Evsys").finish()
1189 }
1190}
1191#[doc = "Event System Interface"]
1192pub mod evsys;
1193#[doc = "Frequency Meter"]
1194pub struct Freqm {
1195 _marker: PhantomData<*const ()>,
1196}
1197unsafe impl Send for Freqm {}
1198impl Freqm {
1199 #[doc = r"Pointer to the register block"]
1200 pub const PTR: *const freqm::RegisterBlock = 0x4000_2c00 as *const _;
1201 #[doc = r"Return the pointer to the register block"]
1202 #[inline(always)]
1203 pub const fn ptr() -> *const freqm::RegisterBlock {
1204 Self::PTR
1205 }
1206 #[doc = r" Steal an instance of this peripheral"]
1207 #[doc = r""]
1208 #[doc = r" # Safety"]
1209 #[doc = r""]
1210 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1211 #[doc = r" that may race with any existing instances, for example by only"]
1212 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1213 #[doc = r" original peripheral and using critical sections to coordinate"]
1214 #[doc = r" access between multiple new instances."]
1215 #[doc = r""]
1216 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1217 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1218 #[doc = r" no stolen instances are passed to such software."]
1219 pub unsafe fn steal() -> Self {
1220 Self {
1221 _marker: PhantomData,
1222 }
1223 }
1224}
1225impl Deref for Freqm {
1226 type Target = freqm::RegisterBlock;
1227 #[inline(always)]
1228 fn deref(&self) -> &Self::Target {
1229 unsafe { &*Self::PTR }
1230 }
1231}
1232impl core::fmt::Debug for Freqm {
1233 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1234 f.debug_struct("Freqm").finish()
1235 }
1236}
1237#[doc = "Frequency Meter"]
1238pub mod freqm;
1239#[doc = "Generic Clock Generator"]
1240pub struct Gclk {
1241 _marker: PhantomData<*const ()>,
1242}
1243unsafe impl Send for Gclk {}
1244impl Gclk {
1245 #[doc = r"Pointer to the register block"]
1246 pub const PTR: *const gclk::RegisterBlock = 0x4000_1c00 as *const _;
1247 #[doc = r"Return the pointer to the register block"]
1248 #[inline(always)]
1249 pub const fn ptr() -> *const gclk::RegisterBlock {
1250 Self::PTR
1251 }
1252 #[doc = r" Steal an instance of this peripheral"]
1253 #[doc = r""]
1254 #[doc = r" # Safety"]
1255 #[doc = r""]
1256 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1257 #[doc = r" that may race with any existing instances, for example by only"]
1258 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1259 #[doc = r" original peripheral and using critical sections to coordinate"]
1260 #[doc = r" access between multiple new instances."]
1261 #[doc = r""]
1262 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1263 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1264 #[doc = r" no stolen instances are passed to such software."]
1265 pub unsafe fn steal() -> Self {
1266 Self {
1267 _marker: PhantomData,
1268 }
1269 }
1270}
1271impl Deref for Gclk {
1272 type Target = gclk::RegisterBlock;
1273 #[inline(always)]
1274 fn deref(&self) -> &Self::Target {
1275 unsafe { &*Self::PTR }
1276 }
1277}
1278impl core::fmt::Debug for Gclk {
1279 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1280 f.debug_struct("Gclk").finish()
1281 }
1282}
1283#[doc = "Generic Clock Generator"]
1284pub mod gclk;
1285#[doc = "Ethernet MAC"]
1286pub struct Gmac {
1287 _marker: PhantomData<*const ()>,
1288}
1289unsafe impl Send for Gmac {}
1290impl Gmac {
1291 #[doc = r"Pointer to the register block"]
1292 pub const PTR: *const gmac::RegisterBlock = 0x4200_0800 as *const _;
1293 #[doc = r"Return the pointer to the register block"]
1294 #[inline(always)]
1295 pub const fn ptr() -> *const gmac::RegisterBlock {
1296 Self::PTR
1297 }
1298 #[doc = r" Steal an instance of this peripheral"]
1299 #[doc = r""]
1300 #[doc = r" # Safety"]
1301 #[doc = r""]
1302 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1303 #[doc = r" that may race with any existing instances, for example by only"]
1304 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1305 #[doc = r" original peripheral and using critical sections to coordinate"]
1306 #[doc = r" access between multiple new instances."]
1307 #[doc = r""]
1308 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1309 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1310 #[doc = r" no stolen instances are passed to such software."]
1311 pub unsafe fn steal() -> Self {
1312 Self {
1313 _marker: PhantomData,
1314 }
1315 }
1316}
1317impl Deref for Gmac {
1318 type Target = gmac::RegisterBlock;
1319 #[inline(always)]
1320 fn deref(&self) -> &Self::Target {
1321 unsafe { &*Self::PTR }
1322 }
1323}
1324impl core::fmt::Debug for Gmac {
1325 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1326 f.debug_struct("Gmac").finish()
1327 }
1328}
1329#[doc = "Ethernet MAC"]
1330pub mod gmac;
1331#[doc = "HSB Matrix"]
1332pub struct Hmatrix {
1333 _marker: PhantomData<*const ()>,
1334}
1335unsafe impl Send for Hmatrix {}
1336impl Hmatrix {
1337 #[doc = r"Pointer to the register block"]
1338 pub const PTR: *const hmatrix::RegisterBlock = 0x4100_c000 as *const _;
1339 #[doc = r"Return the pointer to the register block"]
1340 #[inline(always)]
1341 pub const fn ptr() -> *const hmatrix::RegisterBlock {
1342 Self::PTR
1343 }
1344 #[doc = r" Steal an instance of this peripheral"]
1345 #[doc = r""]
1346 #[doc = r" # Safety"]
1347 #[doc = r""]
1348 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1349 #[doc = r" that may race with any existing instances, for example by only"]
1350 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1351 #[doc = r" original peripheral and using critical sections to coordinate"]
1352 #[doc = r" access between multiple new instances."]
1353 #[doc = r""]
1354 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1355 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1356 #[doc = r" no stolen instances are passed to such software."]
1357 pub unsafe fn steal() -> Self {
1358 Self {
1359 _marker: PhantomData,
1360 }
1361 }
1362}
1363impl Deref for Hmatrix {
1364 type Target = hmatrix::RegisterBlock;
1365 #[inline(always)]
1366 fn deref(&self) -> &Self::Target {
1367 unsafe { &*Self::PTR }
1368 }
1369}
1370impl core::fmt::Debug for Hmatrix {
1371 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1372 f.debug_struct("Hmatrix").finish()
1373 }
1374}
1375#[doc = "HSB Matrix"]
1376pub mod hmatrix;
1377#[doc = "Integrity Check Monitor"]
1378pub struct Icm {
1379 _marker: PhantomData<*const ()>,
1380}
1381unsafe impl Send for Icm {}
1382impl Icm {
1383 #[doc = r"Pointer to the register block"]
1384 pub const PTR: *const icm::RegisterBlock = 0x4200_2c00 as *const _;
1385 #[doc = r"Return the pointer to the register block"]
1386 #[inline(always)]
1387 pub const fn ptr() -> *const icm::RegisterBlock {
1388 Self::PTR
1389 }
1390 #[doc = r" Steal an instance of this peripheral"]
1391 #[doc = r""]
1392 #[doc = r" # Safety"]
1393 #[doc = r""]
1394 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1395 #[doc = r" that may race with any existing instances, for example by only"]
1396 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1397 #[doc = r" original peripheral and using critical sections to coordinate"]
1398 #[doc = r" access between multiple new instances."]
1399 #[doc = r""]
1400 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1401 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1402 #[doc = r" no stolen instances are passed to such software."]
1403 pub unsafe fn steal() -> Self {
1404 Self {
1405 _marker: PhantomData,
1406 }
1407 }
1408}
1409impl Deref for Icm {
1410 type Target = icm::RegisterBlock;
1411 #[inline(always)]
1412 fn deref(&self) -> &Self::Target {
1413 unsafe { &*Self::PTR }
1414 }
1415}
1416impl core::fmt::Debug for Icm {
1417 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1418 f.debug_struct("Icm").finish()
1419 }
1420}
1421#[doc = "Integrity Check Monitor"]
1422pub mod icm;
1423#[doc = "Inter-IC Sound Interface"]
1424pub struct I2s {
1425 _marker: PhantomData<*const ()>,
1426}
1427unsafe impl Send for I2s {}
1428impl I2s {
1429 #[doc = r"Pointer to the register block"]
1430 pub const PTR: *const i2s::RegisterBlock = 0x4300_2800 as *const _;
1431 #[doc = r"Return the pointer to the register block"]
1432 #[inline(always)]
1433 pub const fn ptr() -> *const i2s::RegisterBlock {
1434 Self::PTR
1435 }
1436 #[doc = r" Steal an instance of this peripheral"]
1437 #[doc = r""]
1438 #[doc = r" # Safety"]
1439 #[doc = r""]
1440 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1441 #[doc = r" that may race with any existing instances, for example by only"]
1442 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1443 #[doc = r" original peripheral and using critical sections to coordinate"]
1444 #[doc = r" access between multiple new instances."]
1445 #[doc = r""]
1446 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1447 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1448 #[doc = r" no stolen instances are passed to such software."]
1449 pub unsafe fn steal() -> Self {
1450 Self {
1451 _marker: PhantomData,
1452 }
1453 }
1454}
1455impl Deref for I2s {
1456 type Target = i2s::RegisterBlock;
1457 #[inline(always)]
1458 fn deref(&self) -> &Self::Target {
1459 unsafe { &*Self::PTR }
1460 }
1461}
1462impl core::fmt::Debug for I2s {
1463 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1464 f.debug_struct("I2s").finish()
1465 }
1466}
1467#[doc = "Inter-IC Sound Interface"]
1468pub mod i2s;
1469#[doc = "Main Clock"]
1470pub struct Mclk {
1471 _marker: PhantomData<*const ()>,
1472}
1473unsafe impl Send for Mclk {}
1474impl Mclk {
1475 #[doc = r"Pointer to the register block"]
1476 pub const PTR: *const mclk::RegisterBlock = 0x4000_0800 as *const _;
1477 #[doc = r"Return the pointer to the register block"]
1478 #[inline(always)]
1479 pub const fn ptr() -> *const mclk::RegisterBlock {
1480 Self::PTR
1481 }
1482 #[doc = r" Steal an instance of this peripheral"]
1483 #[doc = r""]
1484 #[doc = r" # Safety"]
1485 #[doc = r""]
1486 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1487 #[doc = r" that may race with any existing instances, for example by only"]
1488 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1489 #[doc = r" original peripheral and using critical sections to coordinate"]
1490 #[doc = r" access between multiple new instances."]
1491 #[doc = r""]
1492 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1493 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1494 #[doc = r" no stolen instances are passed to such software."]
1495 pub unsafe fn steal() -> Self {
1496 Self {
1497 _marker: PhantomData,
1498 }
1499 }
1500}
1501impl Deref for Mclk {
1502 type Target = mclk::RegisterBlock;
1503 #[inline(always)]
1504 fn deref(&self) -> &Self::Target {
1505 unsafe { &*Self::PTR }
1506 }
1507}
1508impl core::fmt::Debug for Mclk {
1509 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1510 f.debug_struct("Mclk").finish()
1511 }
1512}
1513#[doc = "Main Clock"]
1514pub mod mclk;
1515#[doc = "Non-Volatile Memory Controller"]
1516pub struct Nvmctrl {
1517 _marker: PhantomData<*const ()>,
1518}
1519unsafe impl Send for Nvmctrl {}
1520impl Nvmctrl {
1521 #[doc = r"Pointer to the register block"]
1522 pub const PTR: *const nvmctrl::RegisterBlock = 0x4100_4000 as *const _;
1523 #[doc = r"Return the pointer to the register block"]
1524 #[inline(always)]
1525 pub const fn ptr() -> *const nvmctrl::RegisterBlock {
1526 Self::PTR
1527 }
1528 #[doc = r" Steal an instance of this peripheral"]
1529 #[doc = r""]
1530 #[doc = r" # Safety"]
1531 #[doc = r""]
1532 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1533 #[doc = r" that may race with any existing instances, for example by only"]
1534 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1535 #[doc = r" original peripheral and using critical sections to coordinate"]
1536 #[doc = r" access between multiple new instances."]
1537 #[doc = r""]
1538 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1539 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1540 #[doc = r" no stolen instances are passed to such software."]
1541 pub unsafe fn steal() -> Self {
1542 Self {
1543 _marker: PhantomData,
1544 }
1545 }
1546}
1547impl Deref for Nvmctrl {
1548 type Target = nvmctrl::RegisterBlock;
1549 #[inline(always)]
1550 fn deref(&self) -> &Self::Target {
1551 unsafe { &*Self::PTR }
1552 }
1553}
1554impl core::fmt::Debug for Nvmctrl {
1555 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1556 f.debug_struct("Nvmctrl").finish()
1557 }
1558}
1559#[doc = "Non-Volatile Memory Controller"]
1560pub mod nvmctrl;
1561#[doc = "Oscillators Control"]
1562pub struct Oscctrl {
1563 _marker: PhantomData<*const ()>,
1564}
1565unsafe impl Send for Oscctrl {}
1566impl Oscctrl {
1567 #[doc = r"Pointer to the register block"]
1568 pub const PTR: *const oscctrl::RegisterBlock = 0x4000_1000 as *const _;
1569 #[doc = r"Return the pointer to the register block"]
1570 #[inline(always)]
1571 pub const fn ptr() -> *const oscctrl::RegisterBlock {
1572 Self::PTR
1573 }
1574 #[doc = r" Steal an instance of this peripheral"]
1575 #[doc = r""]
1576 #[doc = r" # Safety"]
1577 #[doc = r""]
1578 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1579 #[doc = r" that may race with any existing instances, for example by only"]
1580 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1581 #[doc = r" original peripheral and using critical sections to coordinate"]
1582 #[doc = r" access between multiple new instances."]
1583 #[doc = r""]
1584 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1585 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1586 #[doc = r" no stolen instances are passed to such software."]
1587 pub unsafe fn steal() -> Self {
1588 Self {
1589 _marker: PhantomData,
1590 }
1591 }
1592}
1593impl Deref for Oscctrl {
1594 type Target = oscctrl::RegisterBlock;
1595 #[inline(always)]
1596 fn deref(&self) -> &Self::Target {
1597 unsafe { &*Self::PTR }
1598 }
1599}
1600impl core::fmt::Debug for Oscctrl {
1601 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1602 f.debug_struct("Oscctrl").finish()
1603 }
1604}
1605#[doc = "Oscillators Control"]
1606pub mod oscctrl;
1607#[doc = "32kHz Oscillators Control"]
1608pub struct Osc32kctrl {
1609 _marker: PhantomData<*const ()>,
1610}
1611unsafe impl Send for Osc32kctrl {}
1612impl Osc32kctrl {
1613 #[doc = r"Pointer to the register block"]
1614 pub const PTR: *const osc32kctrl::RegisterBlock = 0x4000_1400 as *const _;
1615 #[doc = r"Return the pointer to the register block"]
1616 #[inline(always)]
1617 pub const fn ptr() -> *const osc32kctrl::RegisterBlock {
1618 Self::PTR
1619 }
1620 #[doc = r" Steal an instance of this peripheral"]
1621 #[doc = r""]
1622 #[doc = r" # Safety"]
1623 #[doc = r""]
1624 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1625 #[doc = r" that may race with any existing instances, for example by only"]
1626 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1627 #[doc = r" original peripheral and using critical sections to coordinate"]
1628 #[doc = r" access between multiple new instances."]
1629 #[doc = r""]
1630 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1631 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1632 #[doc = r" no stolen instances are passed to such software."]
1633 pub unsafe fn steal() -> Self {
1634 Self {
1635 _marker: PhantomData,
1636 }
1637 }
1638}
1639impl Deref for Osc32kctrl {
1640 type Target = osc32kctrl::RegisterBlock;
1641 #[inline(always)]
1642 fn deref(&self) -> &Self::Target {
1643 unsafe { &*Self::PTR }
1644 }
1645}
1646impl core::fmt::Debug for Osc32kctrl {
1647 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1648 f.debug_struct("Osc32kctrl").finish()
1649 }
1650}
1651#[doc = "32kHz Oscillators Control"]
1652pub mod osc32kctrl;
1653#[doc = "Peripheral Access Controller"]
1654pub struct Pac {
1655 _marker: PhantomData<*const ()>,
1656}
1657unsafe impl Send for Pac {}
1658impl Pac {
1659 #[doc = r"Pointer to the register block"]
1660 pub const PTR: *const pac::RegisterBlock = 0x4000_0000 as *const _;
1661 #[doc = r"Return the pointer to the register block"]
1662 #[inline(always)]
1663 pub const fn ptr() -> *const pac::RegisterBlock {
1664 Self::PTR
1665 }
1666 #[doc = r" Steal an instance of this peripheral"]
1667 #[doc = r""]
1668 #[doc = r" # Safety"]
1669 #[doc = r""]
1670 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1671 #[doc = r" that may race with any existing instances, for example by only"]
1672 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1673 #[doc = r" original peripheral and using critical sections to coordinate"]
1674 #[doc = r" access between multiple new instances."]
1675 #[doc = r""]
1676 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1677 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1678 #[doc = r" no stolen instances are passed to such software."]
1679 pub unsafe fn steal() -> Self {
1680 Self {
1681 _marker: PhantomData,
1682 }
1683 }
1684}
1685impl Deref for Pac {
1686 type Target = pac::RegisterBlock;
1687 #[inline(always)]
1688 fn deref(&self) -> &Self::Target {
1689 unsafe { &*Self::PTR }
1690 }
1691}
1692impl core::fmt::Debug for Pac {
1693 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1694 f.debug_struct("Pac").finish()
1695 }
1696}
1697#[doc = "Peripheral Access Controller"]
1698pub mod pac;
1699#[doc = "Parallel Capture Controller"]
1700pub struct Pcc {
1701 _marker: PhantomData<*const ()>,
1702}
1703unsafe impl Send for Pcc {}
1704impl Pcc {
1705 #[doc = r"Pointer to the register block"]
1706 pub const PTR: *const pcc::RegisterBlock = 0x4300_2c00 as *const _;
1707 #[doc = r"Return the pointer to the register block"]
1708 #[inline(always)]
1709 pub const fn ptr() -> *const pcc::RegisterBlock {
1710 Self::PTR
1711 }
1712 #[doc = r" Steal an instance of this peripheral"]
1713 #[doc = r""]
1714 #[doc = r" # Safety"]
1715 #[doc = r""]
1716 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1717 #[doc = r" that may race with any existing instances, for example by only"]
1718 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1719 #[doc = r" original peripheral and using critical sections to coordinate"]
1720 #[doc = r" access between multiple new instances."]
1721 #[doc = r""]
1722 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1723 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1724 #[doc = r" no stolen instances are passed to such software."]
1725 pub unsafe fn steal() -> Self {
1726 Self {
1727 _marker: PhantomData,
1728 }
1729 }
1730}
1731impl Deref for Pcc {
1732 type Target = pcc::RegisterBlock;
1733 #[inline(always)]
1734 fn deref(&self) -> &Self::Target {
1735 unsafe { &*Self::PTR }
1736 }
1737}
1738impl core::fmt::Debug for Pcc {
1739 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1740 f.debug_struct("Pcc").finish()
1741 }
1742}
1743#[doc = "Parallel Capture Controller"]
1744pub mod pcc;
1745#[doc = "Quadrature Decodeur"]
1746pub struct Pdec {
1747 _marker: PhantomData<*const ()>,
1748}
1749unsafe impl Send for Pdec {}
1750impl Pdec {
1751 #[doc = r"Pointer to the register block"]
1752 pub const PTR: *const pdec::RegisterBlock = 0x4200_1c00 as *const _;
1753 #[doc = r"Return the pointer to the register block"]
1754 #[inline(always)]
1755 pub const fn ptr() -> *const pdec::RegisterBlock {
1756 Self::PTR
1757 }
1758 #[doc = r" Steal an instance of this peripheral"]
1759 #[doc = r""]
1760 #[doc = r" # Safety"]
1761 #[doc = r""]
1762 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1763 #[doc = r" that may race with any existing instances, for example by only"]
1764 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1765 #[doc = r" original peripheral and using critical sections to coordinate"]
1766 #[doc = r" access between multiple new instances."]
1767 #[doc = r""]
1768 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1769 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1770 #[doc = r" no stolen instances are passed to such software."]
1771 pub unsafe fn steal() -> Self {
1772 Self {
1773 _marker: PhantomData,
1774 }
1775 }
1776}
1777impl Deref for Pdec {
1778 type Target = pdec::RegisterBlock;
1779 #[inline(always)]
1780 fn deref(&self) -> &Self::Target {
1781 unsafe { &*Self::PTR }
1782 }
1783}
1784impl core::fmt::Debug for Pdec {
1785 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1786 f.debug_struct("Pdec").finish()
1787 }
1788}
1789#[doc = "Quadrature Decodeur"]
1790pub mod pdec;
1791#[doc = "Power Manager"]
1792pub struct Pm {
1793 _marker: PhantomData<*const ()>,
1794}
1795unsafe impl Send for Pm {}
1796impl Pm {
1797 #[doc = r"Pointer to the register block"]
1798 pub const PTR: *const pm::RegisterBlock = 0x4000_0400 as *const _;
1799 #[doc = r"Return the pointer to the register block"]
1800 #[inline(always)]
1801 pub const fn ptr() -> *const pm::RegisterBlock {
1802 Self::PTR
1803 }
1804 #[doc = r" Steal an instance of this peripheral"]
1805 #[doc = r""]
1806 #[doc = r" # Safety"]
1807 #[doc = r""]
1808 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1809 #[doc = r" that may race with any existing instances, for example by only"]
1810 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1811 #[doc = r" original peripheral and using critical sections to coordinate"]
1812 #[doc = r" access between multiple new instances."]
1813 #[doc = r""]
1814 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1815 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1816 #[doc = r" no stolen instances are passed to such software."]
1817 pub unsafe fn steal() -> Self {
1818 Self {
1819 _marker: PhantomData,
1820 }
1821 }
1822}
1823impl Deref for Pm {
1824 type Target = pm::RegisterBlock;
1825 #[inline(always)]
1826 fn deref(&self) -> &Self::Target {
1827 unsafe { &*Self::PTR }
1828 }
1829}
1830impl core::fmt::Debug for Pm {
1831 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1832 f.debug_struct("Pm").finish()
1833 }
1834}
1835#[doc = "Power Manager"]
1836pub mod pm;
1837#[doc = "Port Module"]
1838pub struct Port {
1839 _marker: PhantomData<*const ()>,
1840}
1841unsafe impl Send for Port {}
1842impl Port {
1843 #[doc = r"Pointer to the register block"]
1844 pub const PTR: *const port::RegisterBlock = 0x4100_8000 as *const _;
1845 #[doc = r"Return the pointer to the register block"]
1846 #[inline(always)]
1847 pub const fn ptr() -> *const port::RegisterBlock {
1848 Self::PTR
1849 }
1850 #[doc = r" Steal an instance of this peripheral"]
1851 #[doc = r""]
1852 #[doc = r" # Safety"]
1853 #[doc = r""]
1854 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1855 #[doc = r" that may race with any existing instances, for example by only"]
1856 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1857 #[doc = r" original peripheral and using critical sections to coordinate"]
1858 #[doc = r" access between multiple new instances."]
1859 #[doc = r""]
1860 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1861 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1862 #[doc = r" no stolen instances are passed to such software."]
1863 pub unsafe fn steal() -> Self {
1864 Self {
1865 _marker: PhantomData,
1866 }
1867 }
1868}
1869impl Deref for Port {
1870 type Target = port::RegisterBlock;
1871 #[inline(always)]
1872 fn deref(&self) -> &Self::Target {
1873 unsafe { &*Self::PTR }
1874 }
1875}
1876impl core::fmt::Debug for Port {
1877 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1878 f.debug_struct("Port").finish()
1879 }
1880}
1881#[doc = "Port Module"]
1882pub mod port;
1883#[doc = "Quad SPI interface"]
1884pub struct Qspi {
1885 _marker: PhantomData<*const ()>,
1886}
1887unsafe impl Send for Qspi {}
1888impl Qspi {
1889 #[doc = r"Pointer to the register block"]
1890 pub const PTR: *const qspi::RegisterBlock = 0x4200_3400 as *const _;
1891 #[doc = r"Return the pointer to the register block"]
1892 #[inline(always)]
1893 pub const fn ptr() -> *const qspi::RegisterBlock {
1894 Self::PTR
1895 }
1896 #[doc = r" Steal an instance of this peripheral"]
1897 #[doc = r""]
1898 #[doc = r" # Safety"]
1899 #[doc = r""]
1900 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1901 #[doc = r" that may race with any existing instances, for example by only"]
1902 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1903 #[doc = r" original peripheral and using critical sections to coordinate"]
1904 #[doc = r" access between multiple new instances."]
1905 #[doc = r""]
1906 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1907 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1908 #[doc = r" no stolen instances are passed to such software."]
1909 pub unsafe fn steal() -> Self {
1910 Self {
1911 _marker: PhantomData,
1912 }
1913 }
1914}
1915impl Deref for Qspi {
1916 type Target = qspi::RegisterBlock;
1917 #[inline(always)]
1918 fn deref(&self) -> &Self::Target {
1919 unsafe { &*Self::PTR }
1920 }
1921}
1922impl core::fmt::Debug for Qspi {
1923 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1924 f.debug_struct("Qspi").finish()
1925 }
1926}
1927#[doc = "Quad SPI interface"]
1928pub mod qspi;
1929#[doc = "RAM ECC"]
1930pub struct Ramecc {
1931 _marker: PhantomData<*const ()>,
1932}
1933unsafe impl Send for Ramecc {}
1934impl Ramecc {
1935 #[doc = r"Pointer to the register block"]
1936 pub const PTR: *const ramecc::RegisterBlock = 0x4102_0000 as *const _;
1937 #[doc = r"Return the pointer to the register block"]
1938 #[inline(always)]
1939 pub const fn ptr() -> *const ramecc::RegisterBlock {
1940 Self::PTR
1941 }
1942 #[doc = r" Steal an instance of this peripheral"]
1943 #[doc = r""]
1944 #[doc = r" # Safety"]
1945 #[doc = r""]
1946 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1947 #[doc = r" that may race with any existing instances, for example by only"]
1948 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1949 #[doc = r" original peripheral and using critical sections to coordinate"]
1950 #[doc = r" access between multiple new instances."]
1951 #[doc = r""]
1952 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1953 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1954 #[doc = r" no stolen instances are passed to such software."]
1955 pub unsafe fn steal() -> Self {
1956 Self {
1957 _marker: PhantomData,
1958 }
1959 }
1960}
1961impl Deref for Ramecc {
1962 type Target = ramecc::RegisterBlock;
1963 #[inline(always)]
1964 fn deref(&self) -> &Self::Target {
1965 unsafe { &*Self::PTR }
1966 }
1967}
1968impl core::fmt::Debug for Ramecc {
1969 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1970 f.debug_struct("Ramecc").finish()
1971 }
1972}
1973#[doc = "RAM ECC"]
1974pub mod ramecc;
1975#[doc = "Reset Controller"]
1976pub struct Rstc {
1977 _marker: PhantomData<*const ()>,
1978}
1979unsafe impl Send for Rstc {}
1980impl Rstc {
1981 #[doc = r"Pointer to the register block"]
1982 pub const PTR: *const rstc::RegisterBlock = 0x4000_0c00 as *const _;
1983 #[doc = r"Return the pointer to the register block"]
1984 #[inline(always)]
1985 pub const fn ptr() -> *const rstc::RegisterBlock {
1986 Self::PTR
1987 }
1988 #[doc = r" Steal an instance of this peripheral"]
1989 #[doc = r""]
1990 #[doc = r" # Safety"]
1991 #[doc = r""]
1992 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1993 #[doc = r" that may race with any existing instances, for example by only"]
1994 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1995 #[doc = r" original peripheral and using critical sections to coordinate"]
1996 #[doc = r" access between multiple new instances."]
1997 #[doc = r""]
1998 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1999 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2000 #[doc = r" no stolen instances are passed to such software."]
2001 pub unsafe fn steal() -> Self {
2002 Self {
2003 _marker: PhantomData,
2004 }
2005 }
2006}
2007impl Deref for Rstc {
2008 type Target = rstc::RegisterBlock;
2009 #[inline(always)]
2010 fn deref(&self) -> &Self::Target {
2011 unsafe { &*Self::PTR }
2012 }
2013}
2014impl core::fmt::Debug for Rstc {
2015 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2016 f.debug_struct("Rstc").finish()
2017 }
2018}
2019#[doc = "Reset Controller"]
2020pub mod rstc;
2021#[doc = "Real-Time Counter"]
2022pub struct Rtc {
2023 _marker: PhantomData<*const ()>,
2024}
2025unsafe impl Send for Rtc {}
2026impl Rtc {
2027 #[doc = r"Pointer to the register block"]
2028 pub const PTR: *const rtc::RegisterBlock = 0x4000_2400 as *const _;
2029 #[doc = r"Return the pointer to the register block"]
2030 #[inline(always)]
2031 pub const fn ptr() -> *const rtc::RegisterBlock {
2032 Self::PTR
2033 }
2034 #[doc = r" Steal an instance of this peripheral"]
2035 #[doc = r""]
2036 #[doc = r" # Safety"]
2037 #[doc = r""]
2038 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2039 #[doc = r" that may race with any existing instances, for example by only"]
2040 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2041 #[doc = r" original peripheral and using critical sections to coordinate"]
2042 #[doc = r" access between multiple new instances."]
2043 #[doc = r""]
2044 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2045 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2046 #[doc = r" no stolen instances are passed to such software."]
2047 pub unsafe fn steal() -> Self {
2048 Self {
2049 _marker: PhantomData,
2050 }
2051 }
2052}
2053impl Deref for Rtc {
2054 type Target = rtc::RegisterBlock;
2055 #[inline(always)]
2056 fn deref(&self) -> &Self::Target {
2057 unsafe { &*Self::PTR }
2058 }
2059}
2060impl core::fmt::Debug for Rtc {
2061 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2062 f.debug_struct("Rtc").finish()
2063 }
2064}
2065#[doc = "Real-Time Counter"]
2066pub mod rtc;
2067#[doc = "SD/MMC Host Controller"]
2068pub struct Sdhc0 {
2069 _marker: PhantomData<*const ()>,
2070}
2071unsafe impl Send for Sdhc0 {}
2072impl Sdhc0 {
2073 #[doc = r"Pointer to the register block"]
2074 pub const PTR: *const sdhc0::RegisterBlock = 0x4500_0000 as *const _;
2075 #[doc = r"Return the pointer to the register block"]
2076 #[inline(always)]
2077 pub const fn ptr() -> *const sdhc0::RegisterBlock {
2078 Self::PTR
2079 }
2080 #[doc = r" Steal an instance of this peripheral"]
2081 #[doc = r""]
2082 #[doc = r" # Safety"]
2083 #[doc = r""]
2084 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2085 #[doc = r" that may race with any existing instances, for example by only"]
2086 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2087 #[doc = r" original peripheral and using critical sections to coordinate"]
2088 #[doc = r" access between multiple new instances."]
2089 #[doc = r""]
2090 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2091 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2092 #[doc = r" no stolen instances are passed to such software."]
2093 pub unsafe fn steal() -> Self {
2094 Self {
2095 _marker: PhantomData,
2096 }
2097 }
2098}
2099impl Deref for Sdhc0 {
2100 type Target = sdhc0::RegisterBlock;
2101 #[inline(always)]
2102 fn deref(&self) -> &Self::Target {
2103 unsafe { &*Self::PTR }
2104 }
2105}
2106impl core::fmt::Debug for Sdhc0 {
2107 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2108 f.debug_struct("Sdhc0").finish()
2109 }
2110}
2111#[doc = "SD/MMC Host Controller"]
2112pub mod sdhc0;
2113#[doc = "Serial Communication Interface"]
2114pub struct Sercom0 {
2115 _marker: PhantomData<*const ()>,
2116}
2117unsafe impl Send for Sercom0 {}
2118impl Sercom0 {
2119 #[doc = r"Pointer to the register block"]
2120 pub const PTR: *const sercom0::RegisterBlock = 0x4000_3000 as *const _;
2121 #[doc = r"Return the pointer to the register block"]
2122 #[inline(always)]
2123 pub const fn ptr() -> *const sercom0::RegisterBlock {
2124 Self::PTR
2125 }
2126 #[doc = r" Steal an instance of this peripheral"]
2127 #[doc = r""]
2128 #[doc = r" # Safety"]
2129 #[doc = r""]
2130 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2131 #[doc = r" that may race with any existing instances, for example by only"]
2132 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2133 #[doc = r" original peripheral and using critical sections to coordinate"]
2134 #[doc = r" access between multiple new instances."]
2135 #[doc = r""]
2136 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2137 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2138 #[doc = r" no stolen instances are passed to such software."]
2139 pub unsafe fn steal() -> Self {
2140 Self {
2141 _marker: PhantomData,
2142 }
2143 }
2144}
2145impl Deref for Sercom0 {
2146 type Target = sercom0::RegisterBlock;
2147 #[inline(always)]
2148 fn deref(&self) -> &Self::Target {
2149 unsafe { &*Self::PTR }
2150 }
2151}
2152impl core::fmt::Debug for Sercom0 {
2153 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2154 f.debug_struct("Sercom0").finish()
2155 }
2156}
2157#[doc = "Serial Communication Interface"]
2158pub mod sercom0;
2159#[doc = "Serial Communication Interface"]
2160pub struct Sercom1 {
2161 _marker: PhantomData<*const ()>,
2162}
2163unsafe impl Send for Sercom1 {}
2164impl Sercom1 {
2165 #[doc = r"Pointer to the register block"]
2166 pub const PTR: *const sercom0::RegisterBlock = 0x4000_3400 as *const _;
2167 #[doc = r"Return the pointer to the register block"]
2168 #[inline(always)]
2169 pub const fn ptr() -> *const sercom0::RegisterBlock {
2170 Self::PTR
2171 }
2172 #[doc = r" Steal an instance of this peripheral"]
2173 #[doc = r""]
2174 #[doc = r" # Safety"]
2175 #[doc = r""]
2176 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2177 #[doc = r" that may race with any existing instances, for example by only"]
2178 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2179 #[doc = r" original peripheral and using critical sections to coordinate"]
2180 #[doc = r" access between multiple new instances."]
2181 #[doc = r""]
2182 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2183 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2184 #[doc = r" no stolen instances are passed to such software."]
2185 pub unsafe fn steal() -> Self {
2186 Self {
2187 _marker: PhantomData,
2188 }
2189 }
2190}
2191impl Deref for Sercom1 {
2192 type Target = sercom0::RegisterBlock;
2193 #[inline(always)]
2194 fn deref(&self) -> &Self::Target {
2195 unsafe { &*Self::PTR }
2196 }
2197}
2198impl core::fmt::Debug for Sercom1 {
2199 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2200 f.debug_struct("Sercom1").finish()
2201 }
2202}
2203#[doc = "Serial Communication Interface"]
2204pub use self::sercom0 as sercom1;
2205#[doc = "Serial Communication Interface"]
2206pub struct Sercom2 {
2207 _marker: PhantomData<*const ()>,
2208}
2209unsafe impl Send for Sercom2 {}
2210impl Sercom2 {
2211 #[doc = r"Pointer to the register block"]
2212 pub const PTR: *const sercom0::RegisterBlock = 0x4101_2000 as *const _;
2213 #[doc = r"Return the pointer to the register block"]
2214 #[inline(always)]
2215 pub const fn ptr() -> *const sercom0::RegisterBlock {
2216 Self::PTR
2217 }
2218 #[doc = r" Steal an instance of this peripheral"]
2219 #[doc = r""]
2220 #[doc = r" # Safety"]
2221 #[doc = r""]
2222 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2223 #[doc = r" that may race with any existing instances, for example by only"]
2224 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2225 #[doc = r" original peripheral and using critical sections to coordinate"]
2226 #[doc = r" access between multiple new instances."]
2227 #[doc = r""]
2228 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2229 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2230 #[doc = r" no stolen instances are passed to such software."]
2231 pub unsafe fn steal() -> Self {
2232 Self {
2233 _marker: PhantomData,
2234 }
2235 }
2236}
2237impl Deref for Sercom2 {
2238 type Target = sercom0::RegisterBlock;
2239 #[inline(always)]
2240 fn deref(&self) -> &Self::Target {
2241 unsafe { &*Self::PTR }
2242 }
2243}
2244impl core::fmt::Debug for Sercom2 {
2245 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2246 f.debug_struct("Sercom2").finish()
2247 }
2248}
2249#[doc = "Serial Communication Interface"]
2250pub use self::sercom0 as sercom2;
2251#[doc = "Serial Communication Interface"]
2252pub struct Sercom3 {
2253 _marker: PhantomData<*const ()>,
2254}
2255unsafe impl Send for Sercom3 {}
2256impl Sercom3 {
2257 #[doc = r"Pointer to the register block"]
2258 pub const PTR: *const sercom0::RegisterBlock = 0x4101_4000 as *const _;
2259 #[doc = r"Return the pointer to the register block"]
2260 #[inline(always)]
2261 pub const fn ptr() -> *const sercom0::RegisterBlock {
2262 Self::PTR
2263 }
2264 #[doc = r" Steal an instance of this peripheral"]
2265 #[doc = r""]
2266 #[doc = r" # Safety"]
2267 #[doc = r""]
2268 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2269 #[doc = r" that may race with any existing instances, for example by only"]
2270 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2271 #[doc = r" original peripheral and using critical sections to coordinate"]
2272 #[doc = r" access between multiple new instances."]
2273 #[doc = r""]
2274 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2275 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2276 #[doc = r" no stolen instances are passed to such software."]
2277 pub unsafe fn steal() -> Self {
2278 Self {
2279 _marker: PhantomData,
2280 }
2281 }
2282}
2283impl Deref for Sercom3 {
2284 type Target = sercom0::RegisterBlock;
2285 #[inline(always)]
2286 fn deref(&self) -> &Self::Target {
2287 unsafe { &*Self::PTR }
2288 }
2289}
2290impl core::fmt::Debug for Sercom3 {
2291 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2292 f.debug_struct("Sercom3").finish()
2293 }
2294}
2295#[doc = "Serial Communication Interface"]
2296pub use self::sercom0 as sercom3;
2297#[doc = "Serial Communication Interface"]
2298pub struct Sercom4 {
2299 _marker: PhantomData<*const ()>,
2300}
2301unsafe impl Send for Sercom4 {}
2302impl Sercom4 {
2303 #[doc = r"Pointer to the register block"]
2304 pub const PTR: *const sercom0::RegisterBlock = 0x4300_0000 as *const _;
2305 #[doc = r"Return the pointer to the register block"]
2306 #[inline(always)]
2307 pub const fn ptr() -> *const sercom0::RegisterBlock {
2308 Self::PTR
2309 }
2310 #[doc = r" Steal an instance of this peripheral"]
2311 #[doc = r""]
2312 #[doc = r" # Safety"]
2313 #[doc = r""]
2314 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2315 #[doc = r" that may race with any existing instances, for example by only"]
2316 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2317 #[doc = r" original peripheral and using critical sections to coordinate"]
2318 #[doc = r" access between multiple new instances."]
2319 #[doc = r""]
2320 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2321 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2322 #[doc = r" no stolen instances are passed to such software."]
2323 pub unsafe fn steal() -> Self {
2324 Self {
2325 _marker: PhantomData,
2326 }
2327 }
2328}
2329impl Deref for Sercom4 {
2330 type Target = sercom0::RegisterBlock;
2331 #[inline(always)]
2332 fn deref(&self) -> &Self::Target {
2333 unsafe { &*Self::PTR }
2334 }
2335}
2336impl core::fmt::Debug for Sercom4 {
2337 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2338 f.debug_struct("Sercom4").finish()
2339 }
2340}
2341#[doc = "Serial Communication Interface"]
2342pub use self::sercom0 as sercom4;
2343#[doc = "Serial Communication Interface"]
2344pub struct Sercom5 {
2345 _marker: PhantomData<*const ()>,
2346}
2347unsafe impl Send for Sercom5 {}
2348impl Sercom5 {
2349 #[doc = r"Pointer to the register block"]
2350 pub const PTR: *const sercom0::RegisterBlock = 0x4300_0400 as *const _;
2351 #[doc = r"Return the pointer to the register block"]
2352 #[inline(always)]
2353 pub const fn ptr() -> *const sercom0::RegisterBlock {
2354 Self::PTR
2355 }
2356 #[doc = r" Steal an instance of this peripheral"]
2357 #[doc = r""]
2358 #[doc = r" # Safety"]
2359 #[doc = r""]
2360 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2361 #[doc = r" that may race with any existing instances, for example by only"]
2362 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2363 #[doc = r" original peripheral and using critical sections to coordinate"]
2364 #[doc = r" access between multiple new instances."]
2365 #[doc = r""]
2366 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2367 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2368 #[doc = r" no stolen instances are passed to such software."]
2369 pub unsafe fn steal() -> Self {
2370 Self {
2371 _marker: PhantomData,
2372 }
2373 }
2374}
2375impl Deref for Sercom5 {
2376 type Target = sercom0::RegisterBlock;
2377 #[inline(always)]
2378 fn deref(&self) -> &Self::Target {
2379 unsafe { &*Self::PTR }
2380 }
2381}
2382impl core::fmt::Debug for Sercom5 {
2383 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2384 f.debug_struct("Sercom5").finish()
2385 }
2386}
2387#[doc = "Serial Communication Interface"]
2388pub use self::sercom0 as sercom5;
2389#[doc = "Supply Controller"]
2390pub struct Supc {
2391 _marker: PhantomData<*const ()>,
2392}
2393unsafe impl Send for Supc {}
2394impl Supc {
2395 #[doc = r"Pointer to the register block"]
2396 pub const PTR: *const supc::RegisterBlock = 0x4000_1800 as *const _;
2397 #[doc = r"Return the pointer to the register block"]
2398 #[inline(always)]
2399 pub const fn ptr() -> *const supc::RegisterBlock {
2400 Self::PTR
2401 }
2402 #[doc = r" Steal an instance of this peripheral"]
2403 #[doc = r""]
2404 #[doc = r" # Safety"]
2405 #[doc = r""]
2406 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2407 #[doc = r" that may race with any existing instances, for example by only"]
2408 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2409 #[doc = r" original peripheral and using critical sections to coordinate"]
2410 #[doc = r" access between multiple new instances."]
2411 #[doc = r""]
2412 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2413 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2414 #[doc = r" no stolen instances are passed to such software."]
2415 pub unsafe fn steal() -> Self {
2416 Self {
2417 _marker: PhantomData,
2418 }
2419 }
2420}
2421impl Deref for Supc {
2422 type Target = supc::RegisterBlock;
2423 #[inline(always)]
2424 fn deref(&self) -> &Self::Target {
2425 unsafe { &*Self::PTR }
2426 }
2427}
2428impl core::fmt::Debug for Supc {
2429 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2430 f.debug_struct("Supc").finish()
2431 }
2432}
2433#[doc = "Supply Controller"]
2434pub mod supc;
2435#[doc = "Basic Timer Counter"]
2436pub struct Tc0 {
2437 _marker: PhantomData<*const ()>,
2438}
2439unsafe impl Send for Tc0 {}
2440impl Tc0 {
2441 #[doc = r"Pointer to the register block"]
2442 pub const PTR: *const tc0::RegisterBlock = 0x4000_3800 as *const _;
2443 #[doc = r"Return the pointer to the register block"]
2444 #[inline(always)]
2445 pub const fn ptr() -> *const tc0::RegisterBlock {
2446 Self::PTR
2447 }
2448 #[doc = r" Steal an instance of this peripheral"]
2449 #[doc = r""]
2450 #[doc = r" # Safety"]
2451 #[doc = r""]
2452 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2453 #[doc = r" that may race with any existing instances, for example by only"]
2454 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2455 #[doc = r" original peripheral and using critical sections to coordinate"]
2456 #[doc = r" access between multiple new instances."]
2457 #[doc = r""]
2458 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2459 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2460 #[doc = r" no stolen instances are passed to such software."]
2461 pub unsafe fn steal() -> Self {
2462 Self {
2463 _marker: PhantomData,
2464 }
2465 }
2466}
2467impl Deref for Tc0 {
2468 type Target = tc0::RegisterBlock;
2469 #[inline(always)]
2470 fn deref(&self) -> &Self::Target {
2471 unsafe { &*Self::PTR }
2472 }
2473}
2474impl core::fmt::Debug for Tc0 {
2475 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2476 f.debug_struct("Tc0").finish()
2477 }
2478}
2479#[doc = "Basic Timer Counter"]
2480pub mod tc0;
2481#[doc = "Basic Timer Counter"]
2482pub struct Tc1 {
2483 _marker: PhantomData<*const ()>,
2484}
2485unsafe impl Send for Tc1 {}
2486impl Tc1 {
2487 #[doc = r"Pointer to the register block"]
2488 pub const PTR: *const tc0::RegisterBlock = 0x4000_3c00 as *const _;
2489 #[doc = r"Return the pointer to the register block"]
2490 #[inline(always)]
2491 pub const fn ptr() -> *const tc0::RegisterBlock {
2492 Self::PTR
2493 }
2494 #[doc = r" Steal an instance of this peripheral"]
2495 #[doc = r""]
2496 #[doc = r" # Safety"]
2497 #[doc = r""]
2498 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2499 #[doc = r" that may race with any existing instances, for example by only"]
2500 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2501 #[doc = r" original peripheral and using critical sections to coordinate"]
2502 #[doc = r" access between multiple new instances."]
2503 #[doc = r""]
2504 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2505 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2506 #[doc = r" no stolen instances are passed to such software."]
2507 pub unsafe fn steal() -> Self {
2508 Self {
2509 _marker: PhantomData,
2510 }
2511 }
2512}
2513impl Deref for Tc1 {
2514 type Target = tc0::RegisterBlock;
2515 #[inline(always)]
2516 fn deref(&self) -> &Self::Target {
2517 unsafe { &*Self::PTR }
2518 }
2519}
2520impl core::fmt::Debug for Tc1 {
2521 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2522 f.debug_struct("Tc1").finish()
2523 }
2524}
2525#[doc = "Basic Timer Counter"]
2526pub use self::tc0 as tc1;
2527#[doc = "Basic Timer Counter"]
2528pub struct Tc2 {
2529 _marker: PhantomData<*const ()>,
2530}
2531unsafe impl Send for Tc2 {}
2532impl Tc2 {
2533 #[doc = r"Pointer to the register block"]
2534 pub const PTR: *const tc0::RegisterBlock = 0x4101_a000 as *const _;
2535 #[doc = r"Return the pointer to the register block"]
2536 #[inline(always)]
2537 pub const fn ptr() -> *const tc0::RegisterBlock {
2538 Self::PTR
2539 }
2540 #[doc = r" Steal an instance of this peripheral"]
2541 #[doc = r""]
2542 #[doc = r" # Safety"]
2543 #[doc = r""]
2544 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2545 #[doc = r" that may race with any existing instances, for example by only"]
2546 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2547 #[doc = r" original peripheral and using critical sections to coordinate"]
2548 #[doc = r" access between multiple new instances."]
2549 #[doc = r""]
2550 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2551 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2552 #[doc = r" no stolen instances are passed to such software."]
2553 pub unsafe fn steal() -> Self {
2554 Self {
2555 _marker: PhantomData,
2556 }
2557 }
2558}
2559impl Deref for Tc2 {
2560 type Target = tc0::RegisterBlock;
2561 #[inline(always)]
2562 fn deref(&self) -> &Self::Target {
2563 unsafe { &*Self::PTR }
2564 }
2565}
2566impl core::fmt::Debug for Tc2 {
2567 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2568 f.debug_struct("Tc2").finish()
2569 }
2570}
2571#[doc = "Basic Timer Counter"]
2572pub use self::tc0 as tc2;
2573#[doc = "Basic Timer Counter"]
2574pub struct Tc3 {
2575 _marker: PhantomData<*const ()>,
2576}
2577unsafe impl Send for Tc3 {}
2578impl Tc3 {
2579 #[doc = r"Pointer to the register block"]
2580 pub const PTR: *const tc0::RegisterBlock = 0x4101_c000 as *const _;
2581 #[doc = r"Return the pointer to the register block"]
2582 #[inline(always)]
2583 pub const fn ptr() -> *const tc0::RegisterBlock {
2584 Self::PTR
2585 }
2586 #[doc = r" Steal an instance of this peripheral"]
2587 #[doc = r""]
2588 #[doc = r" # Safety"]
2589 #[doc = r""]
2590 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2591 #[doc = r" that may race with any existing instances, for example by only"]
2592 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2593 #[doc = r" original peripheral and using critical sections to coordinate"]
2594 #[doc = r" access between multiple new instances."]
2595 #[doc = r""]
2596 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2597 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2598 #[doc = r" no stolen instances are passed to such software."]
2599 pub unsafe fn steal() -> Self {
2600 Self {
2601 _marker: PhantomData,
2602 }
2603 }
2604}
2605impl Deref for Tc3 {
2606 type Target = tc0::RegisterBlock;
2607 #[inline(always)]
2608 fn deref(&self) -> &Self::Target {
2609 unsafe { &*Self::PTR }
2610 }
2611}
2612impl core::fmt::Debug for Tc3 {
2613 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2614 f.debug_struct("Tc3").finish()
2615 }
2616}
2617#[doc = "Basic Timer Counter"]
2618pub use self::tc0 as tc3;
2619#[doc = "Basic Timer Counter"]
2620pub struct Tc4 {
2621 _marker: PhantomData<*const ()>,
2622}
2623unsafe impl Send for Tc4 {}
2624impl Tc4 {
2625 #[doc = r"Pointer to the register block"]
2626 pub const PTR: *const tc0::RegisterBlock = 0x4200_1400 as *const _;
2627 #[doc = r"Return the pointer to the register block"]
2628 #[inline(always)]
2629 pub const fn ptr() -> *const tc0::RegisterBlock {
2630 Self::PTR
2631 }
2632 #[doc = r" Steal an instance of this peripheral"]
2633 #[doc = r""]
2634 #[doc = r" # Safety"]
2635 #[doc = r""]
2636 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2637 #[doc = r" that may race with any existing instances, for example by only"]
2638 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2639 #[doc = r" original peripheral and using critical sections to coordinate"]
2640 #[doc = r" access between multiple new instances."]
2641 #[doc = r""]
2642 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2643 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2644 #[doc = r" no stolen instances are passed to such software."]
2645 pub unsafe fn steal() -> Self {
2646 Self {
2647 _marker: PhantomData,
2648 }
2649 }
2650}
2651impl Deref for Tc4 {
2652 type Target = tc0::RegisterBlock;
2653 #[inline(always)]
2654 fn deref(&self) -> &Self::Target {
2655 unsafe { &*Self::PTR }
2656 }
2657}
2658impl core::fmt::Debug for Tc4 {
2659 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2660 f.debug_struct("Tc4").finish()
2661 }
2662}
2663#[doc = "Basic Timer Counter"]
2664pub use self::tc0 as tc4;
2665#[doc = "Basic Timer Counter"]
2666pub struct Tc5 {
2667 _marker: PhantomData<*const ()>,
2668}
2669unsafe impl Send for Tc5 {}
2670impl Tc5 {
2671 #[doc = r"Pointer to the register block"]
2672 pub const PTR: *const tc0::RegisterBlock = 0x4200_1800 as *const _;
2673 #[doc = r"Return the pointer to the register block"]
2674 #[inline(always)]
2675 pub const fn ptr() -> *const tc0::RegisterBlock {
2676 Self::PTR
2677 }
2678 #[doc = r" Steal an instance of this peripheral"]
2679 #[doc = r""]
2680 #[doc = r" # Safety"]
2681 #[doc = r""]
2682 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2683 #[doc = r" that may race with any existing instances, for example by only"]
2684 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2685 #[doc = r" original peripheral and using critical sections to coordinate"]
2686 #[doc = r" access between multiple new instances."]
2687 #[doc = r""]
2688 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2689 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2690 #[doc = r" no stolen instances are passed to such software."]
2691 pub unsafe fn steal() -> Self {
2692 Self {
2693 _marker: PhantomData,
2694 }
2695 }
2696}
2697impl Deref for Tc5 {
2698 type Target = tc0::RegisterBlock;
2699 #[inline(always)]
2700 fn deref(&self) -> &Self::Target {
2701 unsafe { &*Self::PTR }
2702 }
2703}
2704impl core::fmt::Debug for Tc5 {
2705 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2706 f.debug_struct("Tc5").finish()
2707 }
2708}
2709#[doc = "Basic Timer Counter"]
2710pub use self::tc0 as tc5;
2711#[doc = "Timer Counter Control"]
2712pub struct Tcc0 {
2713 _marker: PhantomData<*const ()>,
2714}
2715unsafe impl Send for Tcc0 {}
2716impl Tcc0 {
2717 #[doc = r"Pointer to the register block"]
2718 pub const PTR: *const tcc0::RegisterBlock = 0x4101_6000 as *const _;
2719 #[doc = r"Return the pointer to the register block"]
2720 #[inline(always)]
2721 pub const fn ptr() -> *const tcc0::RegisterBlock {
2722 Self::PTR
2723 }
2724 #[doc = r" Steal an instance of this peripheral"]
2725 #[doc = r""]
2726 #[doc = r" # Safety"]
2727 #[doc = r""]
2728 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2729 #[doc = r" that may race with any existing instances, for example by only"]
2730 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2731 #[doc = r" original peripheral and using critical sections to coordinate"]
2732 #[doc = r" access between multiple new instances."]
2733 #[doc = r""]
2734 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2735 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2736 #[doc = r" no stolen instances are passed to such software."]
2737 pub unsafe fn steal() -> Self {
2738 Self {
2739 _marker: PhantomData,
2740 }
2741 }
2742}
2743impl Deref for Tcc0 {
2744 type Target = tcc0::RegisterBlock;
2745 #[inline(always)]
2746 fn deref(&self) -> &Self::Target {
2747 unsafe { &*Self::PTR }
2748 }
2749}
2750impl core::fmt::Debug for Tcc0 {
2751 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2752 f.debug_struct("Tcc0").finish()
2753 }
2754}
2755#[doc = "Timer Counter Control"]
2756pub mod tcc0;
2757#[doc = "Timer Counter Control"]
2758pub struct Tcc1 {
2759 _marker: PhantomData<*const ()>,
2760}
2761unsafe impl Send for Tcc1 {}
2762impl Tcc1 {
2763 #[doc = r"Pointer to the register block"]
2764 pub const PTR: *const tcc0::RegisterBlock = 0x4101_8000 as *const _;
2765 #[doc = r"Return the pointer to the register block"]
2766 #[inline(always)]
2767 pub const fn ptr() -> *const tcc0::RegisterBlock {
2768 Self::PTR
2769 }
2770 #[doc = r" Steal an instance of this peripheral"]
2771 #[doc = r""]
2772 #[doc = r" # Safety"]
2773 #[doc = r""]
2774 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2775 #[doc = r" that may race with any existing instances, for example by only"]
2776 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2777 #[doc = r" original peripheral and using critical sections to coordinate"]
2778 #[doc = r" access between multiple new instances."]
2779 #[doc = r""]
2780 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2781 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2782 #[doc = r" no stolen instances are passed to such software."]
2783 pub unsafe fn steal() -> Self {
2784 Self {
2785 _marker: PhantomData,
2786 }
2787 }
2788}
2789impl Deref for Tcc1 {
2790 type Target = tcc0::RegisterBlock;
2791 #[inline(always)]
2792 fn deref(&self) -> &Self::Target {
2793 unsafe { &*Self::PTR }
2794 }
2795}
2796impl core::fmt::Debug for Tcc1 {
2797 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2798 f.debug_struct("Tcc1").finish()
2799 }
2800}
2801#[doc = "Timer Counter Control"]
2802pub use self::tcc0 as tcc1;
2803#[doc = "Timer Counter Control"]
2804pub struct Tcc2 {
2805 _marker: PhantomData<*const ()>,
2806}
2807unsafe impl Send for Tcc2 {}
2808impl Tcc2 {
2809 #[doc = r"Pointer to the register block"]
2810 pub const PTR: *const tcc0::RegisterBlock = 0x4200_0c00 as *const _;
2811 #[doc = r"Return the pointer to the register block"]
2812 #[inline(always)]
2813 pub const fn ptr() -> *const tcc0::RegisterBlock {
2814 Self::PTR
2815 }
2816 #[doc = r" Steal an instance of this peripheral"]
2817 #[doc = r""]
2818 #[doc = r" # Safety"]
2819 #[doc = r""]
2820 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2821 #[doc = r" that may race with any existing instances, for example by only"]
2822 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2823 #[doc = r" original peripheral and using critical sections to coordinate"]
2824 #[doc = r" access between multiple new instances."]
2825 #[doc = r""]
2826 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2827 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2828 #[doc = r" no stolen instances are passed to such software."]
2829 pub unsafe fn steal() -> Self {
2830 Self {
2831 _marker: PhantomData,
2832 }
2833 }
2834}
2835impl Deref for Tcc2 {
2836 type Target = tcc0::RegisterBlock;
2837 #[inline(always)]
2838 fn deref(&self) -> &Self::Target {
2839 unsafe { &*Self::PTR }
2840 }
2841}
2842impl core::fmt::Debug for Tcc2 {
2843 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2844 f.debug_struct("Tcc2").finish()
2845 }
2846}
2847#[doc = "Timer Counter Control"]
2848pub use self::tcc0 as tcc2;
2849#[doc = "Timer Counter Control"]
2850pub struct Tcc3 {
2851 _marker: PhantomData<*const ()>,
2852}
2853unsafe impl Send for Tcc3 {}
2854impl Tcc3 {
2855 #[doc = r"Pointer to the register block"]
2856 pub const PTR: *const tcc0::RegisterBlock = 0x4200_1000 as *const _;
2857 #[doc = r"Return the pointer to the register block"]
2858 #[inline(always)]
2859 pub const fn ptr() -> *const tcc0::RegisterBlock {
2860 Self::PTR
2861 }
2862 #[doc = r" Steal an instance of this peripheral"]
2863 #[doc = r""]
2864 #[doc = r" # Safety"]
2865 #[doc = r""]
2866 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2867 #[doc = r" that may race with any existing instances, for example by only"]
2868 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2869 #[doc = r" original peripheral and using critical sections to coordinate"]
2870 #[doc = r" access between multiple new instances."]
2871 #[doc = r""]
2872 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2873 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2874 #[doc = r" no stolen instances are passed to such software."]
2875 pub unsafe fn steal() -> Self {
2876 Self {
2877 _marker: PhantomData,
2878 }
2879 }
2880}
2881impl Deref for Tcc3 {
2882 type Target = tcc0::RegisterBlock;
2883 #[inline(always)]
2884 fn deref(&self) -> &Self::Target {
2885 unsafe { &*Self::PTR }
2886 }
2887}
2888impl core::fmt::Debug for Tcc3 {
2889 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2890 f.debug_struct("Tcc3").finish()
2891 }
2892}
2893#[doc = "Timer Counter Control"]
2894pub use self::tcc0 as tcc3;
2895#[doc = "Timer Counter Control"]
2896pub struct Tcc4 {
2897 _marker: PhantomData<*const ()>,
2898}
2899unsafe impl Send for Tcc4 {}
2900impl Tcc4 {
2901 #[doc = r"Pointer to the register block"]
2902 pub const PTR: *const tcc0::RegisterBlock = 0x4300_1000 as *const _;
2903 #[doc = r"Return the pointer to the register block"]
2904 #[inline(always)]
2905 pub const fn ptr() -> *const tcc0::RegisterBlock {
2906 Self::PTR
2907 }
2908 #[doc = r" Steal an instance of this peripheral"]
2909 #[doc = r""]
2910 #[doc = r" # Safety"]
2911 #[doc = r""]
2912 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2913 #[doc = r" that may race with any existing instances, for example by only"]
2914 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2915 #[doc = r" original peripheral and using critical sections to coordinate"]
2916 #[doc = r" access between multiple new instances."]
2917 #[doc = r""]
2918 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2919 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2920 #[doc = r" no stolen instances are passed to such software."]
2921 pub unsafe fn steal() -> Self {
2922 Self {
2923 _marker: PhantomData,
2924 }
2925 }
2926}
2927impl Deref for Tcc4 {
2928 type Target = tcc0::RegisterBlock;
2929 #[inline(always)]
2930 fn deref(&self) -> &Self::Target {
2931 unsafe { &*Self::PTR }
2932 }
2933}
2934impl core::fmt::Debug for Tcc4 {
2935 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2936 f.debug_struct("Tcc4").finish()
2937 }
2938}
2939#[doc = "Timer Counter Control"]
2940pub use self::tcc0 as tcc4;
2941#[doc = "True Random Generator"]
2942pub struct Trng {
2943 _marker: PhantomData<*const ()>,
2944}
2945unsafe impl Send for Trng {}
2946impl Trng {
2947 #[doc = r"Pointer to the register block"]
2948 pub const PTR: *const trng::RegisterBlock = 0x4200_2800 as *const _;
2949 #[doc = r"Return the pointer to the register block"]
2950 #[inline(always)]
2951 pub const fn ptr() -> *const trng::RegisterBlock {
2952 Self::PTR
2953 }
2954 #[doc = r" Steal an instance of this peripheral"]
2955 #[doc = r""]
2956 #[doc = r" # Safety"]
2957 #[doc = r""]
2958 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2959 #[doc = r" that may race with any existing instances, for example by only"]
2960 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2961 #[doc = r" original peripheral and using critical sections to coordinate"]
2962 #[doc = r" access between multiple new instances."]
2963 #[doc = r""]
2964 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2965 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2966 #[doc = r" no stolen instances are passed to such software."]
2967 pub unsafe fn steal() -> Self {
2968 Self {
2969 _marker: PhantomData,
2970 }
2971 }
2972}
2973impl Deref for Trng {
2974 type Target = trng::RegisterBlock;
2975 #[inline(always)]
2976 fn deref(&self) -> &Self::Target {
2977 unsafe { &*Self::PTR }
2978 }
2979}
2980impl core::fmt::Debug for Trng {
2981 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2982 f.debug_struct("Trng").finish()
2983 }
2984}
2985#[doc = "True Random Generator"]
2986pub mod trng;
2987#[doc = "Universal Serial Bus"]
2988pub struct Usb {
2989 _marker: PhantomData<*const ()>,
2990}
2991unsafe impl Send for Usb {}
2992impl Usb {
2993 #[doc = r"Pointer to the register block"]
2994 pub const PTR: *const usb::RegisterBlock = 0x4100_0000 as *const _;
2995 #[doc = r"Return the pointer to the register block"]
2996 #[inline(always)]
2997 pub const fn ptr() -> *const usb::RegisterBlock {
2998 Self::PTR
2999 }
3000 #[doc = r" Steal an instance of this peripheral"]
3001 #[doc = r""]
3002 #[doc = r" # Safety"]
3003 #[doc = r""]
3004 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3005 #[doc = r" that may race with any existing instances, for example by only"]
3006 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3007 #[doc = r" original peripheral and using critical sections to coordinate"]
3008 #[doc = r" access between multiple new instances."]
3009 #[doc = r""]
3010 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3011 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3012 #[doc = r" no stolen instances are passed to such software."]
3013 pub unsafe fn steal() -> Self {
3014 Self {
3015 _marker: PhantomData,
3016 }
3017 }
3018}
3019impl Deref for Usb {
3020 type Target = usb::RegisterBlock;
3021 #[inline(always)]
3022 fn deref(&self) -> &Self::Target {
3023 unsafe { &*Self::PTR }
3024 }
3025}
3026impl core::fmt::Debug for Usb {
3027 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3028 f.debug_struct("Usb").finish()
3029 }
3030}
3031#[doc = "Universal Serial Bus"]
3032pub mod usb;
3033#[doc = "Watchdog Timer"]
3034pub struct Wdt {
3035 _marker: PhantomData<*const ()>,
3036}
3037unsafe impl Send for Wdt {}
3038impl Wdt {
3039 #[doc = r"Pointer to the register block"]
3040 pub const PTR: *const wdt::RegisterBlock = 0x4000_2000 as *const _;
3041 #[doc = r"Return the pointer to the register block"]
3042 #[inline(always)]
3043 pub const fn ptr() -> *const wdt::RegisterBlock {
3044 Self::PTR
3045 }
3046 #[doc = r" Steal an instance of this peripheral"]
3047 #[doc = r""]
3048 #[doc = r" # Safety"]
3049 #[doc = r""]
3050 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3051 #[doc = r" that may race with any existing instances, for example by only"]
3052 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3053 #[doc = r" original peripheral and using critical sections to coordinate"]
3054 #[doc = r" access between multiple new instances."]
3055 #[doc = r""]
3056 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3057 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3058 #[doc = r" no stolen instances are passed to such software."]
3059 pub unsafe fn steal() -> Self {
3060 Self {
3061 _marker: PhantomData,
3062 }
3063 }
3064}
3065impl Deref for Wdt {
3066 type Target = wdt::RegisterBlock;
3067 #[inline(always)]
3068 fn deref(&self) -> &Self::Target {
3069 unsafe { &*Self::PTR }
3070 }
3071}
3072impl core::fmt::Debug for Wdt {
3073 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3074 f.debug_struct("Wdt").finish()
3075 }
3076}
3077#[doc = "Watchdog Timer"]
3078pub mod wdt;
3079#[doc = "Core Debug Register"]
3080pub struct CoreDebug {
3081 _marker: PhantomData<*const ()>,
3082}
3083unsafe impl Send for CoreDebug {}
3084impl CoreDebug {
3085 #[doc = r"Pointer to the register block"]
3086 pub const PTR: *const core_debug::RegisterBlock = 0xe000_edf0 as *const _;
3087 #[doc = r"Return the pointer to the register block"]
3088 #[inline(always)]
3089 pub const fn ptr() -> *const core_debug::RegisterBlock {
3090 Self::PTR
3091 }
3092 #[doc = r" Steal an instance of this peripheral"]
3093 #[doc = r""]
3094 #[doc = r" # Safety"]
3095 #[doc = r""]
3096 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3097 #[doc = r" that may race with any existing instances, for example by only"]
3098 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3099 #[doc = r" original peripheral and using critical sections to coordinate"]
3100 #[doc = r" access between multiple new instances."]
3101 #[doc = r""]
3102 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3103 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3104 #[doc = r" no stolen instances are passed to such software."]
3105 pub unsafe fn steal() -> Self {
3106 Self {
3107 _marker: PhantomData,
3108 }
3109 }
3110}
3111impl Deref for CoreDebug {
3112 type Target = core_debug::RegisterBlock;
3113 #[inline(always)]
3114 fn deref(&self) -> &Self::Target {
3115 unsafe { &*Self::PTR }
3116 }
3117}
3118impl core::fmt::Debug for CoreDebug {
3119 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3120 f.debug_struct("CoreDebug").finish()
3121 }
3122}
3123#[doc = "Core Debug Register"]
3124pub mod core_debug;
3125#[doc = "Embedded Trace Macrocell"]
3126pub struct Etm {
3127 _marker: PhantomData<*const ()>,
3128}
3129unsafe impl Send for Etm {}
3130impl Etm {
3131 #[doc = r"Pointer to the register block"]
3132 pub const PTR: *const etm::RegisterBlock = 0xe004_1000 as *const _;
3133 #[doc = r"Return the pointer to the register block"]
3134 #[inline(always)]
3135 pub const fn ptr() -> *const etm::RegisterBlock {
3136 Self::PTR
3137 }
3138 #[doc = r" Steal an instance of this peripheral"]
3139 #[doc = r""]
3140 #[doc = r" # Safety"]
3141 #[doc = r""]
3142 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3143 #[doc = r" that may race with any existing instances, for example by only"]
3144 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3145 #[doc = r" original peripheral and using critical sections to coordinate"]
3146 #[doc = r" access between multiple new instances."]
3147 #[doc = r""]
3148 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3149 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3150 #[doc = r" no stolen instances are passed to such software."]
3151 pub unsafe fn steal() -> Self {
3152 Self {
3153 _marker: PhantomData,
3154 }
3155 }
3156}
3157impl Deref for Etm {
3158 type Target = etm::RegisterBlock;
3159 #[inline(always)]
3160 fn deref(&self) -> &Self::Target {
3161 unsafe { &*Self::PTR }
3162 }
3163}
3164impl core::fmt::Debug for Etm {
3165 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3166 f.debug_struct("Etm").finish()
3167 }
3168}
3169#[doc = "Embedded Trace Macrocell"]
3170pub mod etm;
3171#[doc = "System timer"]
3172pub struct SysTick {
3173 _marker: PhantomData<*const ()>,
3174}
3175unsafe impl Send for SysTick {}
3176impl SysTick {
3177 #[doc = r"Pointer to the register block"]
3178 pub const PTR: *const sys_tick::RegisterBlock = 0xe000_e010 as *const _;
3179 #[doc = r"Return the pointer to the register block"]
3180 #[inline(always)]
3181 pub const fn ptr() -> *const sys_tick::RegisterBlock {
3182 Self::PTR
3183 }
3184 #[doc = r" Steal an instance of this peripheral"]
3185 #[doc = r""]
3186 #[doc = r" # Safety"]
3187 #[doc = r""]
3188 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3189 #[doc = r" that may race with any existing instances, for example by only"]
3190 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3191 #[doc = r" original peripheral and using critical sections to coordinate"]
3192 #[doc = r" access between multiple new instances."]
3193 #[doc = r""]
3194 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3195 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3196 #[doc = r" no stolen instances are passed to such software."]
3197 pub unsafe fn steal() -> Self {
3198 Self {
3199 _marker: PhantomData,
3200 }
3201 }
3202}
3203impl Deref for SysTick {
3204 type Target = sys_tick::RegisterBlock;
3205 #[inline(always)]
3206 fn deref(&self) -> &Self::Target {
3207 unsafe { &*Self::PTR }
3208 }
3209}
3210impl core::fmt::Debug for SysTick {
3211 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3212 f.debug_struct("SysTick").finish()
3213 }
3214}
3215#[doc = "System timer"]
3216pub mod sys_tick;
3217#[doc = "System Control Registers"]
3218pub struct SystemControl {
3219 _marker: PhantomData<*const ()>,
3220}
3221unsafe impl Send for SystemControl {}
3222impl SystemControl {
3223 #[doc = r"Pointer to the register block"]
3224 pub const PTR: *const system_control::RegisterBlock = 0xe000_e000 as *const _;
3225 #[doc = r"Return the pointer to the register block"]
3226 #[inline(always)]
3227 pub const fn ptr() -> *const system_control::RegisterBlock {
3228 Self::PTR
3229 }
3230 #[doc = r" Steal an instance of this peripheral"]
3231 #[doc = r""]
3232 #[doc = r" # Safety"]
3233 #[doc = r""]
3234 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3235 #[doc = r" that may race with any existing instances, for example by only"]
3236 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3237 #[doc = r" original peripheral and using critical sections to coordinate"]
3238 #[doc = r" access between multiple new instances."]
3239 #[doc = r""]
3240 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3241 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3242 #[doc = r" no stolen instances are passed to such software."]
3243 pub unsafe fn steal() -> Self {
3244 Self {
3245 _marker: PhantomData,
3246 }
3247 }
3248}
3249impl Deref for SystemControl {
3250 type Target = system_control::RegisterBlock;
3251 #[inline(always)]
3252 fn deref(&self) -> &Self::Target {
3253 unsafe { &*Self::PTR }
3254 }
3255}
3256impl core::fmt::Debug for SystemControl {
3257 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3258 f.debug_struct("SystemControl").finish()
3259 }
3260}
3261#[doc = "System Control Registers"]
3262pub mod system_control;
3263#[no_mangle]
3264static mut DEVICE_PERIPHERALS: bool = false;
3265#[doc = r" All the peripherals."]
3266#[allow(non_snake_case)]
3267pub struct Peripherals {
3268 #[doc = "AC"]
3269 pub ac: Ac,
3270 #[doc = "ADC0"]
3271 pub adc0: Adc0,
3272 #[doc = "ADC1"]
3273 pub adc1: Adc1,
3274 #[doc = "AES"]
3275 pub aes: Aes,
3276 #[doc = "CCL"]
3277 pub ccl: Ccl,
3278 #[doc = "CMCC"]
3279 pub cmcc: Cmcc,
3280 #[doc = "DAC"]
3281 pub dac: Dac,
3282 #[doc = "DMAC"]
3283 pub dmac: Dmac,
3284 #[doc = "DSU"]
3285 pub dsu: Dsu,
3286 #[doc = "EIC"]
3287 pub eic: Eic,
3288 #[doc = "EVSYS"]
3289 pub evsys: Evsys,
3290 #[doc = "FREQM"]
3291 pub freqm: Freqm,
3292 #[doc = "GCLK"]
3293 pub gclk: Gclk,
3294 #[doc = "GMAC"]
3295 pub gmac: Gmac,
3296 #[doc = "HMATRIX"]
3297 pub hmatrix: Hmatrix,
3298 #[doc = "ICM"]
3299 pub icm: Icm,
3300 #[doc = "I2S"]
3301 pub i2s: I2s,
3302 #[doc = "MCLK"]
3303 pub mclk: Mclk,
3304 #[doc = "NVMCTRL"]
3305 pub nvmctrl: Nvmctrl,
3306 #[doc = "OSCCTRL"]
3307 pub oscctrl: Oscctrl,
3308 #[doc = "OSC32KCTRL"]
3309 pub osc32kctrl: Osc32kctrl,
3310 #[doc = "PAC"]
3311 pub pac: Pac,
3312 #[doc = "PCC"]
3313 pub pcc: Pcc,
3314 #[doc = "PDEC"]
3315 pub pdec: Pdec,
3316 #[doc = "PM"]
3317 pub pm: Pm,
3318 #[doc = "PORT"]
3319 pub port: Port,
3320 #[doc = "QSPI"]
3321 pub qspi: Qspi,
3322 #[doc = "RAMECC"]
3323 pub ramecc: Ramecc,
3324 #[doc = "RSTC"]
3325 pub rstc: Rstc,
3326 #[doc = "RTC"]
3327 pub rtc: Rtc,
3328 #[doc = "SDHC0"]
3329 pub sdhc0: Sdhc0,
3330 #[doc = "SERCOM0"]
3331 pub sercom0: Sercom0,
3332 #[doc = "SERCOM1"]
3333 pub sercom1: Sercom1,
3334 #[doc = "SERCOM2"]
3335 pub sercom2: Sercom2,
3336 #[doc = "SERCOM3"]
3337 pub sercom3: Sercom3,
3338 #[doc = "SERCOM4"]
3339 pub sercom4: Sercom4,
3340 #[doc = "SERCOM5"]
3341 pub sercom5: Sercom5,
3342 #[doc = "SUPC"]
3343 pub supc: Supc,
3344 #[doc = "TC0"]
3345 pub tc0: Tc0,
3346 #[doc = "TC1"]
3347 pub tc1: Tc1,
3348 #[doc = "TC2"]
3349 pub tc2: Tc2,
3350 #[doc = "TC3"]
3351 pub tc3: Tc3,
3352 #[doc = "TC4"]
3353 pub tc4: Tc4,
3354 #[doc = "TC5"]
3355 pub tc5: Tc5,
3356 #[doc = "TCC0"]
3357 pub tcc0: Tcc0,
3358 #[doc = "TCC1"]
3359 pub tcc1: Tcc1,
3360 #[doc = "TCC2"]
3361 pub tcc2: Tcc2,
3362 #[doc = "TCC3"]
3363 pub tcc3: Tcc3,
3364 #[doc = "TCC4"]
3365 pub tcc4: Tcc4,
3366 #[doc = "TRNG"]
3367 pub trng: Trng,
3368 #[doc = "USB"]
3369 pub usb: Usb,
3370 #[doc = "WDT"]
3371 pub wdt: Wdt,
3372 #[doc = "CoreDebug"]
3373 pub core_debug: CoreDebug,
3374 #[doc = "ETM"]
3375 pub etm: Etm,
3376 #[doc = "SysTick"]
3377 pub sys_tick: SysTick,
3378 #[doc = "SystemControl"]
3379 pub system_control: SystemControl,
3380}
3381impl Peripherals {
3382 #[doc = r" Returns all the peripherals *once*."]
3383 #[inline]
3384 pub fn take() -> Option<Self> {
3385 critical_section::with(|_| {
3386 if unsafe { DEVICE_PERIPHERALS } {
3387 return None;
3388 }
3389 Some(unsafe { Peripherals::steal() })
3390 })
3391 }
3392 #[doc = r" Unchecked version of `Peripherals::take`."]
3393 #[doc = r""]
3394 #[doc = r" # Safety"]
3395 #[doc = r""]
3396 #[doc = r" Each of the returned peripherals must be used at most once."]
3397 #[inline]
3398 pub unsafe fn steal() -> Self {
3399 DEVICE_PERIPHERALS = true;
3400 Peripherals {
3401 ac: Ac::steal(),
3402 adc0: Adc0::steal(),
3403 adc1: Adc1::steal(),
3404 aes: Aes::steal(),
3405 ccl: Ccl::steal(),
3406 cmcc: Cmcc::steal(),
3407 dac: Dac::steal(),
3408 dmac: Dmac::steal(),
3409 dsu: Dsu::steal(),
3410 eic: Eic::steal(),
3411 evsys: Evsys::steal(),
3412 freqm: Freqm::steal(),
3413 gclk: Gclk::steal(),
3414 gmac: Gmac::steal(),
3415 hmatrix: Hmatrix::steal(),
3416 icm: Icm::steal(),
3417 i2s: I2s::steal(),
3418 mclk: Mclk::steal(),
3419 nvmctrl: Nvmctrl::steal(),
3420 oscctrl: Oscctrl::steal(),
3421 osc32kctrl: Osc32kctrl::steal(),
3422 pac: Pac::steal(),
3423 pcc: Pcc::steal(),
3424 pdec: Pdec::steal(),
3425 pm: Pm::steal(),
3426 port: Port::steal(),
3427 qspi: Qspi::steal(),
3428 ramecc: Ramecc::steal(),
3429 rstc: Rstc::steal(),
3430 rtc: Rtc::steal(),
3431 sdhc0: Sdhc0::steal(),
3432 sercom0: Sercom0::steal(),
3433 sercom1: Sercom1::steal(),
3434 sercom2: Sercom2::steal(),
3435 sercom3: Sercom3::steal(),
3436 sercom4: Sercom4::steal(),
3437 sercom5: Sercom5::steal(),
3438 supc: Supc::steal(),
3439 tc0: Tc0::steal(),
3440 tc1: Tc1::steal(),
3441 tc2: Tc2::steal(),
3442 tc3: Tc3::steal(),
3443 tc4: Tc4::steal(),
3444 tc5: Tc5::steal(),
3445 tcc0: Tcc0::steal(),
3446 tcc1: Tcc1::steal(),
3447 tcc2: Tcc2::steal(),
3448 tcc3: Tcc3::steal(),
3449 tcc4: Tcc4::steal(),
3450 trng: Trng::steal(),
3451 usb: Usb::steal(),
3452 wdt: Wdt::steal(),
3453 core_debug: CoreDebug::steal(),
3454 etm: Etm::steal(),
3455 sys_tick: SysTick::steal(),
3456 system_control: SystemControl::steal(),
3457 }
3458 }
3459}