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