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