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