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