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