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