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