atsamd21g/
lib.rs

Help
1#![doc = "Peripheral access API for ATSAMD21G microcontrollers (generated using svd2rust v0.33.5 ( ))\n\nYou can find an overview of the generated API [here].\n\nAPI features to be included in the [next]
2svd2rust release can be generated by cloning the svd2rust [repository], checking out the above commit, and running `cargo doc --open`.\n\n[here]: https://docs.rs/svd2rust/0.33.5/svd2rust/#peripheral-api\n[next]: https://github.com/rust-embedded/svd2rust/blob/master/CHANGELOG.md#unreleased\n[repository]: https://github.com/rust-embedded/svd2rust"]
3#![allow(non_camel_case_types)]
4#![allow(non_snake_case)]
5#![allow(clippy::all)]
6#![no_std]
7use core::marker::PhantomData;
8use core::ops::Deref;
9#[doc = r"Number available in the NVIC for configuring priority"]
10pub const NVIC_PRIO_BITS: u8 = 2;
11#[cfg(feature = "rt")]
12pub use self::Interrupt as interrupt;
13pub use cortex_m::peripheral::Peripherals as CorePeripherals;
14pub use cortex_m::peripheral::{CBP, CPUID, DCB, DWT, FPB, ITM, MPU, NVIC, SCB, SYST, TPIU};
15#[cfg(feature = "rt")]
16pub use cortex_m_rt::interrupt;
17#[allow(unused_imports)]
18use generic::*;
19#[doc = r"Common register and bit access and modify traits"]
20pub mod generic;
21#[cfg(feature = "rt")]
22extern "C" {
23    fn PM();
24    fn SYSCTRL();
25    fn WDT();
26    fn RTC();
27    fn EIC();
28    fn NVMCTRL();
29    fn DMAC();
30    fn USB();
31    fn EVSYS();
32    fn SERCOM0();
33    fn SERCOM1();
34    fn SERCOM2();
35    fn SERCOM3();
36    fn SERCOM4();
37    fn SERCOM5();
38    fn TCC0();
39    fn TCC1();
40    fn TCC2();
41    fn TC3();
42    fn TC4();
43    fn TC5();
44    fn ADC();
45    fn AC();
46    fn DAC();
47    fn I2S();
48}
49#[doc(hidden)]
50#[repr(C)]
51pub union Vector {
52    _handler: unsafe extern "C" fn(),
53    _reserved: u32,
54}
55#[cfg(feature = "rt")]
56#[doc(hidden)]
57#[link_section = ".vector_table.interrupts"]
58#[no_mangle]
59pub static __INTERRUPTS: [Vector; 28] = [
60    Vector { _handler: PM },
61    Vector { _handler: SYSCTRL },
62    Vector { _handler: WDT },
63    Vector { _handler: RTC },
64    Vector { _handler: EIC },
65    Vector { _handler: NVMCTRL },
66    Vector { _handler: DMAC },
67    Vector { _handler: USB },
68    Vector { _handler: EVSYS },
69    Vector { _handler: SERCOM0 },
70    Vector { _handler: SERCOM1 },
71    Vector { _handler: SERCOM2 },
72    Vector { _handler: SERCOM3 },
73    Vector { _handler: SERCOM4 },
74    Vector { _handler: SERCOM5 },
75    Vector { _handler: TCC0 },
76    Vector { _handler: TCC1 },
77    Vector { _handler: TCC2 },
78    Vector { _handler: TC3 },
79    Vector { _handler: TC4 },
80    Vector { _handler: TC5 },
81    Vector { _reserved: 0 },
82    Vector { _reserved: 0 },
83    Vector { _handler: ADC },
84    Vector { _handler: AC },
85    Vector { _handler: DAC },
86    Vector { _reserved: 0 },
87    Vector { _handler: I2S },
88];
89#[doc = r"Enumeration of all the interrupts."]
90#[derive(Copy, Clone, Debug, PartialEq, Eq)]
91#[repr(u16)]
92pub enum Interrupt {
93    #[doc = "0 - PM"]
94    PM = 0,
95    #[doc = "1 - SYSCTRL"]
96    SYSCTRL = 1,
97    #[doc = "2 - WDT"]
98    WDT = 2,
99    #[doc = "3 - RTC"]
100    RTC = 3,
101    #[doc = "4 - EIC"]
102    EIC = 4,
103    #[doc = "5 - NVMCTRL"]
104    NVMCTRL = 5,
105    #[doc = "6 - DMAC"]
106    DMAC = 6,
107    #[doc = "7 - USB"]
108    USB = 7,
109    #[doc = "8 - EVSYS"]
110    EVSYS = 8,
111    #[doc = "9 - SERCOM0"]
112    SERCOM0 = 9,
113    #[doc = "10 - SERCOM1"]
114    SERCOM1 = 10,
115    #[doc = "11 - SERCOM2"]
116    SERCOM2 = 11,
117    #[doc = "12 - SERCOM3"]
118    SERCOM3 = 12,
119    #[doc = "13 - SERCOM4"]
120    SERCOM4 = 13,
121    #[doc = "14 - SERCOM5"]
122    SERCOM5 = 14,
123    #[doc = "15 - TCC0"]
124    TCC0 = 15,
125    #[doc = "16 - TCC1"]
126    TCC1 = 16,
127    #[doc = "17 - TCC2"]
128    TCC2 = 17,
129    #[doc = "18 - TC3"]
130    TC3 = 18,
131    #[doc = "19 - TC4"]
132    TC4 = 19,
133    #[doc = "20 - TC5"]
134    TC5 = 20,
135    #[doc = "23 - ADC"]
136    ADC = 23,
137    #[doc = "24 - AC"]
138    AC = 24,
139    #[doc = "25 - DAC"]
140    DAC = 25,
141    #[doc = "27 - I2S"]
142    I2S = 27,
143}
144unsafe impl cortex_m::interrupt::InterruptNumber for Interrupt {
145    #[inline(always)]
146    fn number(self) -> u16 {
147        self as u16
148    }
149}
150#[doc = "Analog Comparators"]
151pub struct Ac {
152    _marker: PhantomData<*const ()>,
153}
154unsafe impl Send for Ac {}
155impl Ac {
156    #[doc = r"Pointer to the register block"]
157    pub const PTR: *const ac::RegisterBlock = 0x4200_4400 as *const _;
158    #[doc = r"Return the pointer to the register block"]
159    #[inline(always)]
160    pub const fn ptr() -> *const ac::RegisterBlock {
161        Self::PTR
162    }
163    #[doc = r" Steal an instance of this peripheral"]
164    #[doc = r""]
165    #[doc = r" # Safety"]
166    #[doc = r""]
167    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
168    #[doc = r" that may race with any existing instances, for example by only"]
169    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
170    #[doc = r" original peripheral and using critical sections to coordinate"]
171    #[doc = r" access between multiple new instances."]
172    #[doc = r""]
173    #[doc = r" Additionally, other software such as HALs may rely on only one"]
174    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
175    #[doc = r" no stolen instances are passed to such software."]
176    pub unsafe fn steal() -> Self {
177        Self {
178            _marker: PhantomData,
179        }
180    }
181}
182impl Deref for Ac {
183    type Target = ac::RegisterBlock;
184    #[inline(always)]
185    fn deref(&self) -> &Self::Target {
186        unsafe { &*Self::PTR }
187    }
188}
189impl core::fmt::Debug for Ac {
190    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
191        f.debug_struct("Ac").finish()
192    }
193}
194#[doc = "Analog Comparators"]
195pub mod ac;
196#[doc = "Analog Digital Converter"]
197pub struct Adc {
198    _marker: PhantomData<*const ()>,
199}
200unsafe impl Send for Adc {}
201impl Adc {
202    #[doc = r"Pointer to the register block"]
203    pub const PTR: *const adc::RegisterBlock = 0x4200_4000 as *const _;
204    #[doc = r"Return the pointer to the register block"]
205    #[inline(always)]
206    pub const fn ptr() -> *const adc::RegisterBlock {
207        Self::PTR
208    }
209    #[doc = r" Steal an instance of this peripheral"]
210    #[doc = r""]
211    #[doc = r" # Safety"]
212    #[doc = r""]
213    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
214    #[doc = r" that may race with any existing instances, for example by only"]
215    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
216    #[doc = r" original peripheral and using critical sections to coordinate"]
217    #[doc = r" access between multiple new instances."]
218    #[doc = r""]
219    #[doc = r" Additionally, other software such as HALs may rely on only one"]
220    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
221    #[doc = r" no stolen instances are passed to such software."]
222    pub unsafe fn steal() -> Self {
223        Self {
224            _marker: PhantomData,
225        }
226    }
227}
228impl Deref for Adc {
229    type Target = adc::RegisterBlock;
230    #[inline(always)]
231    fn deref(&self) -> &Self::Target {
232        unsafe { &*Self::PTR }
233    }
234}
235impl core::fmt::Debug for Adc {
236    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
237        f.debug_struct("Adc").finish()
238    }
239}
240#[doc = "Analog Digital Converter"]
241pub mod adc;
242#[doc = "Digital Analog Converter"]
243pub struct Dac {
244    _marker: PhantomData<*const ()>,
245}
246unsafe impl Send for Dac {}
247impl Dac {
248    #[doc = r"Pointer to the register block"]
249    pub const PTR: *const dac::RegisterBlock = 0x4200_4800 as *const _;
250    #[doc = r"Return the pointer to the register block"]
251    #[inline(always)]
252    pub const fn ptr() -> *const dac::RegisterBlock {
253        Self::PTR
254    }
255    #[doc = r" Steal an instance of this peripheral"]
256    #[doc = r""]
257    #[doc = r" # Safety"]
258    #[doc = r""]
259    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
260    #[doc = r" that may race with any existing instances, for example by only"]
261    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
262    #[doc = r" original peripheral and using critical sections to coordinate"]
263    #[doc = r" access between multiple new instances."]
264    #[doc = r""]
265    #[doc = r" Additionally, other software such as HALs may rely on only one"]
266    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
267    #[doc = r" no stolen instances are passed to such software."]
268    pub unsafe fn steal() -> Self {
269        Self {
270            _marker: PhantomData,
271        }
272    }
273}
274impl Deref for Dac {
275    type Target = dac::RegisterBlock;
276    #[inline(always)]
277    fn deref(&self) -> &Self::Target {
278        unsafe { &*Self::PTR }
279    }
280}
281impl core::fmt::Debug for Dac {
282    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
283        f.debug_struct("Dac").finish()
284    }
285}
286#[doc = "Digital Analog Converter"]
287pub mod dac;
288#[doc = "Direct Memory Access Controller"]
289pub struct Dmac {
290    _marker: PhantomData<*const ()>,
291}
292unsafe impl Send for Dmac {}
293impl Dmac {
294    #[doc = r"Pointer to the register block"]
295    pub const PTR: *const dmac::RegisterBlock = 0x4100_4800 as *const _;
296    #[doc = r"Return the pointer to the register block"]
297    #[inline(always)]
298    pub const fn ptr() -> *const dmac::RegisterBlock {
299        Self::PTR
300    }
301    #[doc = r" Steal an instance of this peripheral"]
302    #[doc = r""]
303    #[doc = r" # Safety"]
304    #[doc = r""]
305    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
306    #[doc = r" that may race with any existing instances, for example by only"]
307    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
308    #[doc = r" original peripheral and using critical sections to coordinate"]
309    #[doc = r" access between multiple new instances."]
310    #[doc = r""]
311    #[doc = r" Additionally, other software such as HALs may rely on only one"]
312    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
313    #[doc = r" no stolen instances are passed to such software."]
314    pub unsafe fn steal() -> Self {
315        Self {
316            _marker: PhantomData,
317        }
318    }
319}
320impl Deref for Dmac {
321    type Target = dmac::RegisterBlock;
322    #[inline(always)]
323    fn deref(&self) -> &Self::Target {
324        unsafe { &*Self::PTR }
325    }
326}
327impl core::fmt::Debug for Dmac {
328    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
329        f.debug_struct("Dmac").finish()
330    }
331}
332#[doc = "Direct Memory Access Controller"]
333pub mod dmac;
334#[doc = "Device Service Unit"]
335pub struct Dsu {
336    _marker: PhantomData<*const ()>,
337}
338unsafe impl Send for Dsu {}
339impl Dsu {
340    #[doc = r"Pointer to the register block"]
341    pub const PTR: *const dsu::RegisterBlock = 0x4100_2000 as *const _;
342    #[doc = r"Return the pointer to the register block"]
343    #[inline(always)]
344    pub const fn ptr() -> *const dsu::RegisterBlock {
345        Self::PTR
346    }
347    #[doc = r" Steal an instance of this peripheral"]
348    #[doc = r""]
349    #[doc = r" # Safety"]
350    #[doc = r""]
351    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
352    #[doc = r" that may race with any existing instances, for example by only"]
353    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
354    #[doc = r" original peripheral and using critical sections to coordinate"]
355    #[doc = r" access between multiple new instances."]
356    #[doc = r""]
357    #[doc = r" Additionally, other software such as HALs may rely on only one"]
358    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
359    #[doc = r" no stolen instances are passed to such software."]
360    pub unsafe fn steal() -> Self {
361        Self {
362            _marker: PhantomData,
363        }
364    }
365}
366impl Deref for Dsu {
367    type Target = dsu::RegisterBlock;
368    #[inline(always)]
369    fn deref(&self) -> &Self::Target {
370        unsafe { &*Self::PTR }
371    }
372}
373impl core::fmt::Debug for Dsu {
374    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
375        f.debug_struct("Dsu").finish()
376    }
377}
378#[doc = "Device Service Unit"]
379pub mod dsu;
380#[doc = "External Interrupt Controller"]
381pub struct Eic {
382    _marker: PhantomData<*const ()>,
383}
384unsafe impl Send for Eic {}
385impl Eic {
386    #[doc = r"Pointer to the register block"]
387    pub const PTR: *const eic::RegisterBlock = 0x4000_1800 as *const _;
388    #[doc = r"Return the pointer to the register block"]
389    #[inline(always)]
390    pub const fn ptr() -> *const eic::RegisterBlock {
391        Self::PTR
392    }
393    #[doc = r" Steal an instance of this peripheral"]
394    #[doc = r""]
395    #[doc = r" # Safety"]
396    #[doc = r""]
397    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
398    #[doc = r" that may race with any existing instances, for example by only"]
399    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
400    #[doc = r" original peripheral and using critical sections to coordinate"]
401    #[doc = r" access between multiple new instances."]
402    #[doc = r""]
403    #[doc = r" Additionally, other software such as HALs may rely on only one"]
404    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
405    #[doc = r" no stolen instances are passed to such software."]
406    pub unsafe fn steal() -> Self {
407        Self {
408            _marker: PhantomData,
409        }
410    }
411}
412impl Deref for Eic {
413    type Target = eic::RegisterBlock;
414    #[inline(always)]
415    fn deref(&self) -> &Self::Target {
416        unsafe { &*Self::PTR }
417    }
418}
419impl core::fmt::Debug for Eic {
420    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
421        f.debug_struct("Eic").finish()
422    }
423}
424#[doc = "External Interrupt Controller"]
425pub mod eic;
426#[doc = "Event System Interface"]
427pub struct Evsys {
428    _marker: PhantomData<*const ()>,
429}
430unsafe impl Send for Evsys {}
431impl Evsys {
432    #[doc = r"Pointer to the register block"]
433    pub const PTR: *const evsys::RegisterBlock = 0x4200_0400 as *const _;
434    #[doc = r"Return the pointer to the register block"]
435    #[inline(always)]
436    pub const fn ptr() -> *const evsys::RegisterBlock {
437        Self::PTR
438    }
439    #[doc = r" Steal an instance of this peripheral"]
440    #[doc = r""]
441    #[doc = r" # Safety"]
442    #[doc = r""]
443    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
444    #[doc = r" that may race with any existing instances, for example by only"]
445    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
446    #[doc = r" original peripheral and using critical sections to coordinate"]
447    #[doc = r" access between multiple new instances."]
448    #[doc = r""]
449    #[doc = r" Additionally, other software such as HALs may rely on only one"]
450    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
451    #[doc = r" no stolen instances are passed to such software."]
452    pub unsafe fn steal() -> Self {
453        Self {
454            _marker: PhantomData,
455        }
456    }
457}
458impl Deref for Evsys {
459    type Target = evsys::RegisterBlock;
460    #[inline(always)]
461    fn deref(&self) -> &Self::Target {
462        unsafe { &*Self::PTR }
463    }
464}
465impl core::fmt::Debug for Evsys {
466    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
467        f.debug_struct("Evsys").finish()
468    }
469}
470#[doc = "Event System Interface"]
471pub mod evsys;
472#[doc = "Generic Clock Generator"]
473pub struct Gclk {
474    _marker: PhantomData<*const ()>,
475}
476unsafe impl Send for Gclk {}
477impl Gclk {
478    #[doc = r"Pointer to the register block"]
479    pub const PTR: *const gclk::RegisterBlock = 0x4000_0c00 as *const _;
480    #[doc = r"Return the pointer to the register block"]
481    #[inline(always)]
482    pub const fn ptr() -> *const gclk::RegisterBlock {
483        Self::PTR
484    }
485    #[doc = r" Steal an instance of this peripheral"]
486    #[doc = r""]
487    #[doc = r" # Safety"]
488    #[doc = r""]
489    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
490    #[doc = r" that may race with any existing instances, for example by only"]
491    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
492    #[doc = r" original peripheral and using critical sections to coordinate"]
493    #[doc = r" access between multiple new instances."]
494    #[doc = r""]
495    #[doc = r" Additionally, other software such as HALs may rely on only one"]
496    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
497    #[doc = r" no stolen instances are passed to such software."]
498    pub unsafe fn steal() -> Self {
499        Self {
500            _marker: PhantomData,
501        }
502    }
503}
504impl Deref for Gclk {
505    type Target = gclk::RegisterBlock;
506    #[inline(always)]
507    fn deref(&self) -> &Self::Target {
508        unsafe { &*Self::PTR }
509    }
510}
511impl core::fmt::Debug for Gclk {
512    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
513        f.debug_struct("Gclk").finish()
514    }
515}
516#[doc = "Generic Clock Generator"]
517pub mod gclk;
518#[doc = "HSB Matrix"]
519pub struct Hmatrix {
520    _marker: PhantomData<*const ()>,
521}
522unsafe impl Send for Hmatrix {}
523impl Hmatrix {
524    #[doc = r"Pointer to the register block"]
525    pub const PTR: *const hmatrix::RegisterBlock = 0x4100_7000 as *const _;
526    #[doc = r"Return the pointer to the register block"]
527    #[inline(always)]
528    pub const fn ptr() -> *const hmatrix::RegisterBlock {
529        Self::PTR
530    }
531    #[doc = r" Steal an instance of this peripheral"]
532    #[doc = r""]
533    #[doc = r" # Safety"]
534    #[doc = r""]
535    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
536    #[doc = r" that may race with any existing instances, for example by only"]
537    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
538    #[doc = r" original peripheral and using critical sections to coordinate"]
539    #[doc = r" access between multiple new instances."]
540    #[doc = r""]
541    #[doc = r" Additionally, other software such as HALs may rely on only one"]
542    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
543    #[doc = r" no stolen instances are passed to such software."]
544    pub unsafe fn steal() -> Self {
545        Self {
546            _marker: PhantomData,
547        }
548    }
549}
550impl Deref for Hmatrix {
551    type Target = hmatrix::RegisterBlock;
552    #[inline(always)]
553    fn deref(&self) -> &Self::Target {
554        unsafe { &*Self::PTR }
555    }
556}
557impl core::fmt::Debug for Hmatrix {
558    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
559        f.debug_struct("Hmatrix").finish()
560    }
561}
562#[doc = "HSB Matrix"]
563pub mod hmatrix;
564#[doc = "Inter-IC Sound Interface"]
565pub struct I2s {
566    _marker: PhantomData<*const ()>,
567}
568unsafe impl Send for I2s {}
569impl I2s {
570    #[doc = r"Pointer to the register block"]
571    pub const PTR: *const i2s::RegisterBlock = 0x4200_5000 as *const _;
572    #[doc = r"Return the pointer to the register block"]
573    #[inline(always)]
574    pub const fn ptr() -> *const i2s::RegisterBlock {
575        Self::PTR
576    }
577    #[doc = r" Steal an instance of this peripheral"]
578    #[doc = r""]
579    #[doc = r" # Safety"]
580    #[doc = r""]
581    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
582    #[doc = r" that may race with any existing instances, for example by only"]
583    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
584    #[doc = r" original peripheral and using critical sections to coordinate"]
585    #[doc = r" access between multiple new instances."]
586    #[doc = r""]
587    #[doc = r" Additionally, other software such as HALs may rely on only one"]
588    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
589    #[doc = r" no stolen instances are passed to such software."]
590    pub unsafe fn steal() -> Self {
591        Self {
592            _marker: PhantomData,
593        }
594    }
595}
596impl Deref for I2s {
597    type Target = i2s::RegisterBlock;
598    #[inline(always)]
599    fn deref(&self) -> &Self::Target {
600        unsafe { &*Self::PTR }
601    }
602}
603impl core::fmt::Debug for I2s {
604    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
605        f.debug_struct("I2s").finish()
606    }
607}
608#[doc = "Inter-IC Sound Interface"]
609pub mod i2s;
610#[doc = "Cortex-M0+ Micro-Trace Buffer"]
611pub struct Mtb {
612    _marker: PhantomData<*const ()>,
613}
614unsafe impl Send for Mtb {}
615impl Mtb {
616    #[doc = r"Pointer to the register block"]
617    pub const PTR: *const mtb::RegisterBlock = 0x4100_6000 as *const _;
618    #[doc = r"Return the pointer to the register block"]
619    #[inline(always)]
620    pub const fn ptr() -> *const mtb::RegisterBlock {
621        Self::PTR
622    }
623    #[doc = r" Steal an instance of this peripheral"]
624    #[doc = r""]
625    #[doc = r" # Safety"]
626    #[doc = r""]
627    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
628    #[doc = r" that may race with any existing instances, for example by only"]
629    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
630    #[doc = r" original peripheral and using critical sections to coordinate"]
631    #[doc = r" access between multiple new instances."]
632    #[doc = r""]
633    #[doc = r" Additionally, other software such as HALs may rely on only one"]
634    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
635    #[doc = r" no stolen instances are passed to such software."]
636    pub unsafe fn steal() -> Self {
637        Self {
638            _marker: PhantomData,
639        }
640    }
641}
642impl Deref for Mtb {
643    type Target = mtb::RegisterBlock;
644    #[inline(always)]
645    fn deref(&self) -> &Self::Target {
646        unsafe { &*Self::PTR }
647    }
648}
649impl core::fmt::Debug for Mtb {
650    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
651        f.debug_struct("Mtb").finish()
652    }
653}
654#[doc = "Cortex-M0+ Micro-Trace Buffer"]
655pub mod mtb;
656#[doc = "Non-Volatile Memory Controller"]
657pub struct Nvmctrl {
658    _marker: PhantomData<*const ()>,
659}
660unsafe impl Send for Nvmctrl {}
661impl Nvmctrl {
662    #[doc = r"Pointer to the register block"]
663    pub const PTR: *const nvmctrl::RegisterBlock = 0x4100_4000 as *const _;
664    #[doc = r"Return the pointer to the register block"]
665    #[inline(always)]
666    pub const fn ptr() -> *const nvmctrl::RegisterBlock {
667        Self::PTR
668    }
669    #[doc = r" Steal an instance of this peripheral"]
670    #[doc = r""]
671    #[doc = r" # Safety"]
672    #[doc = r""]
673    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
674    #[doc = r" that may race with any existing instances, for example by only"]
675    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
676    #[doc = r" original peripheral and using critical sections to coordinate"]
677    #[doc = r" access between multiple new instances."]
678    #[doc = r""]
679    #[doc = r" Additionally, other software such as HALs may rely on only one"]
680    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
681    #[doc = r" no stolen instances are passed to such software."]
682    pub unsafe fn steal() -> Self {
683        Self {
684            _marker: PhantomData,
685        }
686    }
687}
688impl Deref for Nvmctrl {
689    type Target = nvmctrl::RegisterBlock;
690    #[inline(always)]
691    fn deref(&self) -> &Self::Target {
692        unsafe { &*Self::PTR }
693    }
694}
695impl core::fmt::Debug for Nvmctrl {
696    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
697        f.debug_struct("Nvmctrl").finish()
698    }
699}
700#[doc = "Non-Volatile Memory Controller"]
701pub mod nvmctrl;
702#[doc = "Peripheral Access Controller 0"]
703pub struct Pac0 {
704    _marker: PhantomData<*const ()>,
705}
706unsafe impl Send for Pac0 {}
707impl Pac0 {
708    #[doc = r"Pointer to the register block"]
709    pub const PTR: *const pac0::RegisterBlock = 0x4000_0000 as *const _;
710    #[doc = r"Return the pointer to the register block"]
711    #[inline(always)]
712    pub const fn ptr() -> *const pac0::RegisterBlock {
713        Self::PTR
714    }
715    #[doc = r" Steal an instance of this peripheral"]
716    #[doc = r""]
717    #[doc = r" # Safety"]
718    #[doc = r""]
719    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
720    #[doc = r" that may race with any existing instances, for example by only"]
721    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
722    #[doc = r" original peripheral and using critical sections to coordinate"]
723    #[doc = r" access between multiple new instances."]
724    #[doc = r""]
725    #[doc = r" Additionally, other software such as HALs may rely on only one"]
726    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
727    #[doc = r" no stolen instances are passed to such software."]
728    pub unsafe fn steal() -> Self {
729        Self {
730            _marker: PhantomData,
731        }
732    }
733}
734impl Deref for Pac0 {
735    type Target = pac0::RegisterBlock;
736    #[inline(always)]
737    fn deref(&self) -> &Self::Target {
738        unsafe { &*Self::PTR }
739    }
740}
741impl core::fmt::Debug for Pac0 {
742    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
743        f.debug_struct("Pac0").finish()
744    }
745}
746#[doc = "Peripheral Access Controller 0"]
747pub mod pac0;
748#[doc = "Peripheral Access Controller 1"]
749pub struct Pac1 {
750    _marker: PhantomData<*const ()>,
751}
752unsafe impl Send for Pac1 {}
753impl Pac1 {
754    #[doc = r"Pointer to the register block"]
755    pub const PTR: *const pac0::RegisterBlock = 0x4100_0000 as *const _;
756    #[doc = r"Return the pointer to the register block"]
757    #[inline(always)]
758    pub const fn ptr() -> *const pac0::RegisterBlock {
759        Self::PTR
760    }
761    #[doc = r" Steal an instance of this peripheral"]
762    #[doc = r""]
763    #[doc = r" # Safety"]
764    #[doc = r""]
765    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
766    #[doc = r" that may race with any existing instances, for example by only"]
767    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
768    #[doc = r" original peripheral and using critical sections to coordinate"]
769    #[doc = r" access between multiple new instances."]
770    #[doc = r""]
771    #[doc = r" Additionally, other software such as HALs may rely on only one"]
772    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
773    #[doc = r" no stolen instances are passed to such software."]
774    pub unsafe fn steal() -> Self {
775        Self {
776            _marker: PhantomData,
777        }
778    }
779}
780impl Deref for Pac1 {
781    type Target = pac0::RegisterBlock;
782    #[inline(always)]
783    fn deref(&self) -> &Self::Target {
784        unsafe { &*Self::PTR }
785    }
786}
787impl core::fmt::Debug for Pac1 {
788    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
789        f.debug_struct("Pac1").finish()
790    }
791}
792#[doc = "Peripheral Access Controller 1"]
793pub use self::pac0 as pac1;
794#[doc = "Peripheral Access Controller 2"]
795pub struct Pac2 {
796    _marker: PhantomData<*const ()>,
797}
798unsafe impl Send for Pac2 {}
799impl Pac2 {
800    #[doc = r"Pointer to the register block"]
801    pub const PTR: *const pac0::RegisterBlock = 0x4200_0000 as *const _;
802    #[doc = r"Return the pointer to the register block"]
803    #[inline(always)]
804    pub const fn ptr() -> *const pac0::RegisterBlock {
805        Self::PTR
806    }
807    #[doc = r" Steal an instance of this peripheral"]
808    #[doc = r""]
809    #[doc = r" # Safety"]
810    #[doc = r""]
811    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
812    #[doc = r" that may race with any existing instances, for example by only"]
813    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
814    #[doc = r" original peripheral and using critical sections to coordinate"]
815    #[doc = r" access between multiple new instances."]
816    #[doc = r""]
817    #[doc = r" Additionally, other software such as HALs may rely on only one"]
818    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
819    #[doc = r" no stolen instances are passed to such software."]
820    pub unsafe fn steal() -> Self {
821        Self {
822            _marker: PhantomData,
823        }
824    }
825}
826impl Deref for Pac2 {
827    type Target = pac0::RegisterBlock;
828    #[inline(always)]
829    fn deref(&self) -> &Self::Target {
830        unsafe { &*Self::PTR }
831    }
832}
833impl core::fmt::Debug for Pac2 {
834    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
835        f.debug_struct("Pac2").finish()
836    }
837}
838#[doc = "Peripheral Access Controller 2"]
839pub use self::pac0 as pac2;
840#[doc = "Power Manager"]
841pub struct Pm {
842    _marker: PhantomData<*const ()>,
843}
844unsafe impl Send for Pm {}
845impl Pm {
846    #[doc = r"Pointer to the register block"]
847    pub const PTR: *const pm::RegisterBlock = 0x4000_0400 as *const _;
848    #[doc = r"Return the pointer to the register block"]
849    #[inline(always)]
850    pub const fn ptr() -> *const pm::RegisterBlock {
851        Self::PTR
852    }
853    #[doc = r" Steal an instance of this peripheral"]
854    #[doc = r""]
855    #[doc = r" # Safety"]
856    #[doc = r""]
857    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
858    #[doc = r" that may race with any existing instances, for example by only"]
859    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
860    #[doc = r" original peripheral and using critical sections to coordinate"]
861    #[doc = r" access between multiple new instances."]
862    #[doc = r""]
863    #[doc = r" Additionally, other software such as HALs may rely on only one"]
864    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
865    #[doc = r" no stolen instances are passed to such software."]
866    pub unsafe fn steal() -> Self {
867        Self {
868            _marker: PhantomData,
869        }
870    }
871}
872impl Deref for Pm {
873    type Target = pm::RegisterBlock;
874    #[inline(always)]
875    fn deref(&self) -> &Self::Target {
876        unsafe { &*Self::PTR }
877    }
878}
879impl core::fmt::Debug for Pm {
880    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
881        f.debug_struct("Pm").finish()
882    }
883}
884#[doc = "Power Manager"]
885pub mod pm;
886#[doc = "Port Module"]
887pub struct Port {
888    _marker: PhantomData<*const ()>,
889}
890unsafe impl Send for Port {}
891impl Port {
892    #[doc = r"Pointer to the register block"]
893    pub const PTR: *const port::RegisterBlock = 0x4100_4400 as *const _;
894    #[doc = r"Return the pointer to the register block"]
895    #[inline(always)]
896    pub const fn ptr() -> *const port::RegisterBlock {
897        Self::PTR
898    }
899    #[doc = r" Steal an instance of this peripheral"]
900    #[doc = r""]
901    #[doc = r" # Safety"]
902    #[doc = r""]
903    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
904    #[doc = r" that may race with any existing instances, for example by only"]
905    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
906    #[doc = r" original peripheral and using critical sections to coordinate"]
907    #[doc = r" access between multiple new instances."]
908    #[doc = r""]
909    #[doc = r" Additionally, other software such as HALs may rely on only one"]
910    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
911    #[doc = r" no stolen instances are passed to such software."]
912    pub unsafe fn steal() -> Self {
913        Self {
914            _marker: PhantomData,
915        }
916    }
917}
918impl Deref for Port {
919    type Target = port::RegisterBlock;
920    #[inline(always)]
921    fn deref(&self) -> &Self::Target {
922        unsafe { &*Self::PTR }
923    }
924}
925impl core::fmt::Debug for Port {
926    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
927        f.debug_struct("Port").finish()
928    }
929}
930#[doc = "Port Module"]
931pub mod port;
932#[doc = "Port Module (IOBUS)"]
933pub struct PortIobus {
934    _marker: PhantomData<*const ()>,
935}
936unsafe impl Send for PortIobus {}
937impl PortIobus {
938    #[doc = r"Pointer to the register block"]
939    pub const PTR: *const port::RegisterBlock = 0x6000_0000 as *const _;
940    #[doc = r"Return the pointer to the register block"]
941    #[inline(always)]
942    pub const fn ptr() -> *const port::RegisterBlock {
943        Self::PTR
944    }
945    #[doc = r" Steal an instance of this peripheral"]
946    #[doc = r""]
947    #[doc = r" # Safety"]
948    #[doc = r""]
949    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
950    #[doc = r" that may race with any existing instances, for example by only"]
951    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
952    #[doc = r" original peripheral and using critical sections to coordinate"]
953    #[doc = r" access between multiple new instances."]
954    #[doc = r""]
955    #[doc = r" Additionally, other software such as HALs may rely on only one"]
956    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
957    #[doc = r" no stolen instances are passed to such software."]
958    pub unsafe fn steal() -> Self {
959        Self {
960            _marker: PhantomData,
961        }
962    }
963}
964impl Deref for PortIobus {
965    type Target = port::RegisterBlock;
966    #[inline(always)]
967    fn deref(&self) -> &Self::Target {
968        unsafe { &*Self::PTR }
969    }
970}
971impl core::fmt::Debug for PortIobus {
972    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
973        f.debug_struct("PortIobus").finish()
974    }
975}
976#[doc = "Port Module (IOBUS)"]
977pub use self::port as port_iobus;
978#[doc = "Real-Time Counter"]
979pub struct Rtc {
980    _marker: PhantomData<*const ()>,
981}
982unsafe impl Send for Rtc {}
983impl Rtc {
984    #[doc = r"Pointer to the register block"]
985    pub const PTR: *const rtc::RegisterBlock = 0x4000_1400 as *const _;
986    #[doc = r"Return the pointer to the register block"]
987    #[inline(always)]
988    pub const fn ptr() -> *const rtc::RegisterBlock {
989        Self::PTR
990    }
991    #[doc = r" Steal an instance of this peripheral"]
992    #[doc = r""]
993    #[doc = r" # Safety"]
994    #[doc = r""]
995    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
996    #[doc = r" that may race with any existing instances, for example by only"]
997    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
998    #[doc = r" original peripheral and using critical sections to coordinate"]
999    #[doc = r" access between multiple new instances."]
1000    #[doc = r""]
1001    #[doc = r" Additionally, other software such as HALs may rely on only one"]
1002    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1003    #[doc = r" no stolen instances are passed to such software."]
1004    pub unsafe fn steal() -> Self {
1005        Self {
1006            _marker: PhantomData,
1007        }
1008    }
1009}
1010impl Deref for Rtc {
1011    type Target = rtc::RegisterBlock;
1012    #[inline(always)]
1013    fn deref(&self) -> &Self::Target {
1014        unsafe { &*Self::PTR }
1015    }
1016}
1017impl core::fmt::Debug for Rtc {
1018    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1019        f.debug_struct("Rtc").finish()
1020    }
1021}
1022#[doc = "Real-Time Counter"]
1023pub mod rtc;
1024#[doc = "Serial Communication Interface 0"]
1025pub struct Sercom0 {
1026    _marker: PhantomData<*const ()>,
1027}
1028unsafe impl Send for Sercom0 {}
1029impl Sercom0 {
1030    #[doc = r"Pointer to the register block"]
1031    pub const PTR: *const sercom0::RegisterBlock = 0x4200_0800 as *const _;
1032    #[doc = r"Return the pointer to the register block"]
1033    #[inline(always)]
1034    pub const fn ptr() -> *const sercom0::RegisterBlock {
1035        Self::PTR
1036    }
1037    #[doc = r" Steal an instance of this peripheral"]
1038    #[doc = r""]
1039    #[doc = r" # Safety"]
1040    #[doc = r""]
1041    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1042    #[doc = r" that may race with any existing instances, for example by only"]
1043    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1044    #[doc = r" original peripheral and using critical sections to coordinate"]
1045    #[doc = r" access between multiple new instances."]
1046    #[doc = r""]
1047    #[doc = r" Additionally, other software such as HALs may rely on only one"]
1048    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1049    #[doc = r" no stolen instances are passed to such software."]
1050    pub unsafe fn steal() -> Self {
1051        Self {
1052            _marker: PhantomData,
1053        }
1054    }
1055}
1056impl Deref for Sercom0 {
1057    type Target = sercom0::RegisterBlock;
1058    #[inline(always)]
1059    fn deref(&self) -> &Self::Target {
1060        unsafe { &*Self::PTR }
1061    }
1062}
1063impl core::fmt::Debug for Sercom0 {
1064    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1065        f.debug_struct("Sercom0").finish()
1066    }
1067}
1068#[doc = "Serial Communication Interface 0"]
1069pub mod sercom0;
1070#[doc = "Serial Communication Interface 1"]
1071pub struct Sercom1 {
1072    _marker: PhantomData<*const ()>,
1073}
1074unsafe impl Send for Sercom1 {}
1075impl Sercom1 {
1076    #[doc = r"Pointer to the register block"]
1077    pub const PTR: *const sercom0::RegisterBlock = 0x4200_0c00 as *const _;
1078    #[doc = r"Return the pointer to the register block"]
1079    #[inline(always)]
1080    pub const fn ptr() -> *const sercom0::RegisterBlock {
1081        Self::PTR
1082    }
1083    #[doc = r" Steal an instance of this peripheral"]
1084    #[doc = r""]
1085    #[doc = r" # Safety"]
1086    #[doc = r""]
1087    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1088    #[doc = r" that may race with any existing instances, for example by only"]
1089    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1090    #[doc = r" original peripheral and using critical sections to coordinate"]
1091    #[doc = r" access between multiple new instances."]
1092    #[doc = r""]
1093    #[doc = r" Additionally, other software such as HALs may rely on only one"]
1094    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1095    #[doc = r" no stolen instances are passed to such software."]
1096    pub unsafe fn steal() -> Self {
1097        Self {
1098            _marker: PhantomData,
1099        }
1100    }
1101}
1102impl Deref for Sercom1 {
1103    type Target = sercom0::RegisterBlock;
1104    #[inline(always)]
1105    fn deref(&self) -> &Self::Target {
1106        unsafe { &*Self::PTR }
1107    }
1108}
1109impl core::fmt::Debug for Sercom1 {
1110    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1111        f.debug_struct("Sercom1").finish()
1112    }
1113}
1114#[doc = "Serial Communication Interface 1"]
1115pub use self::sercom0 as sercom1;
1116#[doc = "Serial Communication Interface 2"]
1117pub struct Sercom2 {
1118    _marker: PhantomData<*const ()>,
1119}
1120unsafe impl Send for Sercom2 {}
1121impl Sercom2 {
1122    #[doc = r"Pointer to the register block"]
1123    pub const PTR: *const sercom0::RegisterBlock = 0x4200_1000 as *const _;
1124    #[doc = r"Return the pointer to the register block"]
1125    #[inline(always)]
1126    pub const fn ptr() -> *const sercom0::RegisterBlock {
1127        Self::PTR
1128    }
1129    #[doc = r" Steal an instance of this peripheral"]
1130    #[doc = r""]
1131    #[doc = r" # Safety"]
1132    #[doc = r""]
1133    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1134    #[doc = r" that may race with any existing instances, for example by only"]
1135    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1136    #[doc = r" original peripheral and using critical sections to coordinate"]
1137    #[doc = r" access between multiple new instances."]
1138    #[doc = r""]
1139    #[doc = r" Additionally, other software such as HALs may rely on only one"]
1140    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1141    #[doc = r" no stolen instances are passed to such software."]
1142    pub unsafe fn steal() -> Self {
1143        Self {
1144            _marker: PhantomData,
1145        }
1146    }
1147}
1148impl Deref for Sercom2 {
1149    type Target = sercom0::RegisterBlock;
1150    #[inline(always)]
1151    fn deref(&self) -> &Self::Target {
1152        unsafe { &*Self::PTR }
1153    }
1154}
1155impl core::fmt::Debug for Sercom2 {
1156    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1157        f.debug_struct("Sercom2").finish()
1158    }
1159}
1160#[doc = "Serial Communication Interface 2"]
1161pub use self::sercom0 as sercom2;
1162#[doc = "Serial Communication Interface 3"]
1163pub struct Sercom3 {
1164    _marker: PhantomData<*const ()>,
1165}
1166unsafe impl Send for Sercom3 {}
1167impl Sercom3 {
1168    #[doc = r"Pointer to the register block"]
1169    pub const PTR: *const sercom0::RegisterBlock = 0x4200_1400 as *const _;
1170    #[doc = r"Return the pointer to the register block"]
1171    #[inline(always)]
1172    pub const fn ptr() -> *const sercom0::RegisterBlock {
1173        Self::PTR
1174    }
1175    #[doc = r" Steal an instance of this peripheral"]
1176    #[doc = r""]
1177    #[doc = r" # Safety"]
1178    #[doc = r""]
1179    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1180    #[doc = r" that may race with any existing instances, for example by only"]
1181    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1182    #[doc = r" original peripheral and using critical sections to coordinate"]
1183    #[doc = r" access between multiple new instances."]
1184    #[doc = r""]
1185    #[doc = r" Additionally, other software such as HALs may rely on only one"]
1186    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1187    #[doc = r" no stolen instances are passed to such software."]
1188    pub unsafe fn steal() -> Self {
1189        Self {
1190            _marker: PhantomData,
1191        }
1192    }
1193}
1194impl Deref for Sercom3 {
1195    type Target = sercom0::RegisterBlock;
1196    #[inline(always)]
1197    fn deref(&self) -> &Self::Target {
1198        unsafe { &*Self::PTR }
1199    }
1200}
1201impl core::fmt::Debug for Sercom3 {
1202    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1203        f.debug_struct("Sercom3").finish()
1204    }
1205}
1206#[doc = "Serial Communication Interface 3"]
1207pub use self::sercom0 as sercom3;
1208#[doc = "Serial Communication Interface 4"]
1209pub struct Sercom4 {
1210    _marker: PhantomData<*const ()>,
1211}
1212unsafe impl Send for Sercom4 {}
1213impl Sercom4 {
1214    #[doc = r"Pointer to the register block"]
1215    pub const PTR: *const sercom0::RegisterBlock = 0x4200_1800 as *const _;
1216    #[doc = r"Return the pointer to the register block"]
1217    #[inline(always)]
1218    pub const fn ptr() -> *const sercom0::RegisterBlock {
1219        Self::PTR
1220    }
1221    #[doc = r" Steal an instance of this peripheral"]
1222    #[doc = r""]
1223    #[doc = r" # Safety"]
1224    #[doc = r""]
1225    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1226    #[doc = r" that may race with any existing instances, for example by only"]
1227    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1228    #[doc = r" original peripheral and using critical sections to coordinate"]
1229    #[doc = r" access between multiple new instances."]
1230    #[doc = r""]
1231    #[doc = r" Additionally, other software such as HALs may rely on only one"]
1232    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1233    #[doc = r" no stolen instances are passed to such software."]
1234    pub unsafe fn steal() -> Self {
1235        Self {
1236            _marker: PhantomData,
1237        }
1238    }
1239}
1240impl Deref for Sercom4 {
1241    type Target = sercom0::RegisterBlock;
1242    #[inline(always)]
1243    fn deref(&self) -> &Self::Target {
1244        unsafe { &*Self::PTR }
1245    }
1246}
1247impl core::fmt::Debug for Sercom4 {
1248    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1249        f.debug_struct("Sercom4").finish()
1250    }
1251}
1252#[doc = "Serial Communication Interface 4"]
1253pub use self::sercom0 as sercom4;
1254#[doc = "Serial Communication Interface 5"]
1255pub struct Sercom5 {
1256    _marker: PhantomData<*const ()>,
1257}
1258unsafe impl Send for Sercom5 {}
1259impl Sercom5 {
1260    #[doc = r"Pointer to the register block"]
1261    pub const PTR: *const sercom0::RegisterBlock = 0x4200_1c00 as *const _;
1262    #[doc = r"Return the pointer to the register block"]
1263    #[inline(always)]
1264    pub const fn ptr() -> *const sercom0::RegisterBlock {
1265        Self::PTR
1266    }
1267    #[doc = r" Steal an instance of this peripheral"]
1268    #[doc = r""]
1269    #[doc = r" # Safety"]
1270    #[doc = r""]
1271    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1272    #[doc = r" that may race with any existing instances, for example by only"]
1273    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1274    #[doc = r" original peripheral and using critical sections to coordinate"]
1275    #[doc = r" access between multiple new instances."]
1276    #[doc = r""]
1277    #[doc = r" Additionally, other software such as HALs may rely on only one"]
1278    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1279    #[doc = r" no stolen instances are passed to such software."]
1280    pub unsafe fn steal() -> Self {
1281        Self {
1282            _marker: PhantomData,
1283        }
1284    }
1285}
1286impl Deref for Sercom5 {
1287    type Target = sercom0::RegisterBlock;
1288    #[inline(always)]
1289    fn deref(&self) -> &Self::Target {
1290        unsafe { &*Self::PTR }
1291    }
1292}
1293impl core::fmt::Debug for Sercom5 {
1294    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1295        f.debug_struct("Sercom5").finish()
1296    }
1297}
1298#[doc = "Serial Communication Interface 5"]
1299pub use self::sercom0 as sercom5;
1300#[doc = "System Control"]
1301pub struct Sysctrl {
1302    _marker: PhantomData<*const ()>,
1303}
1304unsafe impl Send for Sysctrl {}
1305impl Sysctrl {
1306    #[doc = r"Pointer to the register block"]
1307    pub const PTR: *const sysctrl::RegisterBlock = 0x4000_0800 as *const _;
1308    #[doc = r"Return the pointer to the register block"]
1309    #[inline(always)]
1310    pub const fn ptr() -> *const sysctrl::RegisterBlock {
1311        Self::PTR
1312    }
1313    #[doc = r" Steal an instance of this peripheral"]
1314    #[doc = r""]
1315    #[doc = r" # Safety"]
1316    #[doc = r""]
1317    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1318    #[doc = r" that may race with any existing instances, for example by only"]
1319    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1320    #[doc = r" original peripheral and using critical sections to coordinate"]
1321    #[doc = r" access between multiple new instances."]
1322    #[doc = r""]
1323    #[doc = r" Additionally, other software such as HALs may rely on only one"]
1324    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1325    #[doc = r" no stolen instances are passed to such software."]
1326    pub unsafe fn steal() -> Self {
1327        Self {
1328            _marker: PhantomData,
1329        }
1330    }
1331}
1332impl Deref for Sysctrl {
1333    type Target = sysctrl::RegisterBlock;
1334    #[inline(always)]
1335    fn deref(&self) -> &Self::Target {
1336        unsafe { &*Self::PTR }
1337    }
1338}
1339impl core::fmt::Debug for Sysctrl {
1340    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1341        f.debug_struct("Sysctrl").finish()
1342    }
1343}
1344#[doc = "System Control"]
1345pub mod sysctrl;
1346#[doc = "Basic Timer Counter 3"]
1347pub struct Tc3 {
1348    _marker: PhantomData<*const ()>,
1349}
1350unsafe impl Send for Tc3 {}
1351impl Tc3 {
1352    #[doc = r"Pointer to the register block"]
1353    pub const PTR: *const tc3::RegisterBlock = 0x4200_2c00 as *const _;
1354    #[doc = r"Return the pointer to the register block"]
1355    #[inline(always)]
1356    pub const fn ptr() -> *const tc3::RegisterBlock {
1357        Self::PTR
1358    }
1359    #[doc = r" Steal an instance of this peripheral"]
1360    #[doc = r""]
1361    #[doc = r" # Safety"]
1362    #[doc = r""]
1363    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1364    #[doc = r" that may race with any existing instances, for example by only"]
1365    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1366    #[doc = r" original peripheral and using critical sections to coordinate"]
1367    #[doc = r" access between multiple new instances."]
1368    #[doc = r""]
1369    #[doc = r" Additionally, other software such as HALs may rely on only one"]
1370    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1371    #[doc = r" no stolen instances are passed to such software."]
1372    pub unsafe fn steal() -> Self {
1373        Self {
1374            _marker: PhantomData,
1375        }
1376    }
1377}
1378impl Deref for Tc3 {
1379    type Target = tc3::RegisterBlock;
1380    #[inline(always)]
1381    fn deref(&self) -> &Self::Target {
1382        unsafe { &*Self::PTR }
1383    }
1384}
1385impl core::fmt::Debug for Tc3 {
1386    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1387        f.debug_struct("Tc3").finish()
1388    }
1389}
1390#[doc = "Basic Timer Counter 3"]
1391pub mod tc3;
1392#[doc = "Basic Timer Counter 4"]
1393pub struct Tc4 {
1394    _marker: PhantomData<*const ()>,
1395}
1396unsafe impl Send for Tc4 {}
1397impl Tc4 {
1398    #[doc = r"Pointer to the register block"]
1399    pub const PTR: *const tc3::RegisterBlock = 0x4200_3000 as *const _;
1400    #[doc = r"Return the pointer to the register block"]
1401    #[inline(always)]
1402    pub const fn ptr() -> *const tc3::RegisterBlock {
1403        Self::PTR
1404    }
1405    #[doc = r" Steal an instance of this peripheral"]
1406    #[doc = r""]
1407    #[doc = r" # Safety"]
1408    #[doc = r""]
1409    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1410    #[doc = r" that may race with any existing instances, for example by only"]
1411    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1412    #[doc = r" original peripheral and using critical sections to coordinate"]
1413    #[doc = r" access between multiple new instances."]
1414    #[doc = r""]
1415    #[doc = r" Additionally, other software such as HALs may rely on only one"]
1416    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1417    #[doc = r" no stolen instances are passed to such software."]
1418    pub unsafe fn steal() -> Self {
1419        Self {
1420            _marker: PhantomData,
1421        }
1422    }
1423}
1424impl Deref for Tc4 {
1425    type Target = tc3::RegisterBlock;
1426    #[inline(always)]
1427    fn deref(&self) -> &Self::Target {
1428        unsafe { &*Self::PTR }
1429    }
1430}
1431impl core::fmt::Debug for Tc4 {
1432    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1433        f.debug_struct("Tc4").finish()
1434    }
1435}
1436#[doc = "Basic Timer Counter 4"]
1437pub use self::tc3 as tc4;
1438#[doc = "Basic Timer Counter 5"]
1439pub struct Tc5 {
1440    _marker: PhantomData<*const ()>,
1441}
1442unsafe impl Send for Tc5 {}
1443impl Tc5 {
1444    #[doc = r"Pointer to the register block"]
1445    pub const PTR: *const tc3::RegisterBlock = 0x4200_3400 as *const _;
1446    #[doc = r"Return the pointer to the register block"]
1447    #[inline(always)]
1448    pub const fn ptr() -> *const tc3::RegisterBlock {
1449        Self::PTR
1450    }
1451    #[doc = r" Steal an instance of this peripheral"]
1452    #[doc = r""]
1453    #[doc = r" # Safety"]
1454    #[doc = r""]
1455    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1456    #[doc = r" that may race with any existing instances, for example by only"]
1457    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1458    #[doc = r" original peripheral and using critical sections to coordinate"]
1459    #[doc = r" access between multiple new instances."]
1460    #[doc = r""]
1461    #[doc = r" Additionally, other software such as HALs may rely on only one"]
1462    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1463    #[doc = r" no stolen instances are passed to such software."]
1464    pub unsafe fn steal() -> Self {
1465        Self {
1466            _marker: PhantomData,
1467        }
1468    }
1469}
1470impl Deref for Tc5 {
1471    type Target = tc3::RegisterBlock;
1472    #[inline(always)]
1473    fn deref(&self) -> &Self::Target {
1474        unsafe { &*Self::PTR }
1475    }
1476}
1477impl core::fmt::Debug for Tc5 {
1478    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1479        f.debug_struct("Tc5").finish()
1480    }
1481}
1482#[doc = "Basic Timer Counter 5"]
1483pub use self::tc3 as tc5;
1484#[doc = "Timer Counter Control 0"]
1485pub struct Tcc0 {
1486    _marker: PhantomData<*const ()>,
1487}
1488unsafe impl Send for Tcc0 {}
1489impl Tcc0 {
1490    #[doc = r"Pointer to the register block"]
1491    pub const PTR: *const tcc0::RegisterBlock = 0x4200_2000 as *const _;
1492    #[doc = r"Return the pointer to the register block"]
1493    #[inline(always)]
1494    pub const fn ptr() -> *const tcc0::RegisterBlock {
1495        Self::PTR
1496    }
1497    #[doc = r" Steal an instance of this peripheral"]
1498    #[doc = r""]
1499    #[doc = r" # Safety"]
1500    #[doc = r""]
1501    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1502    #[doc = r" that may race with any existing instances, for example by only"]
1503    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1504    #[doc = r" original peripheral and using critical sections to coordinate"]
1505    #[doc = r" access between multiple new instances."]
1506    #[doc = r""]
1507    #[doc = r" Additionally, other software such as HALs may rely on only one"]
1508    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1509    #[doc = r" no stolen instances are passed to such software."]
1510    pub unsafe fn steal() -> Self {
1511        Self {
1512            _marker: PhantomData,
1513        }
1514    }
1515}
1516impl Deref for Tcc0 {
1517    type Target = tcc0::RegisterBlock;
1518    #[inline(always)]
1519    fn deref(&self) -> &Self::Target {
1520        unsafe { &*Self::PTR }
1521    }
1522}
1523impl core::fmt::Debug for Tcc0 {
1524    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1525        f.debug_struct("Tcc0").finish()
1526    }
1527}
1528#[doc = "Timer Counter Control 0"]
1529pub mod tcc0;
1530#[doc = "Timer Counter Control 1"]
1531pub struct Tcc1 {
1532    _marker: PhantomData<*const ()>,
1533}
1534unsafe impl Send for Tcc1 {}
1535impl Tcc1 {
1536    #[doc = r"Pointer to the register block"]
1537    pub const PTR: *const tcc0::RegisterBlock = 0x4200_2400 as *const _;
1538    #[doc = r"Return the pointer to the register block"]
1539    #[inline(always)]
1540    pub const fn ptr() -> *const tcc0::RegisterBlock {
1541        Self::PTR
1542    }
1543    #[doc = r" Steal an instance of this peripheral"]
1544    #[doc = r""]
1545    #[doc = r" # Safety"]
1546    #[doc = r""]
1547    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1548    #[doc = r" that may race with any existing instances, for example by only"]
1549    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1550    #[doc = r" original peripheral and using critical sections to coordinate"]
1551    #[doc = r" access between multiple new instances."]
1552    #[doc = r""]
1553    #[doc = r" Additionally, other software such as HALs may rely on only one"]
1554    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1555    #[doc = r" no stolen instances are passed to such software."]
1556    pub unsafe fn steal() -> Self {
1557        Self {
1558            _marker: PhantomData,
1559        }
1560    }
1561}
1562impl Deref for Tcc1 {
1563    type Target = tcc0::RegisterBlock;
1564    #[inline(always)]
1565    fn deref(&self) -> &Self::Target {
1566        unsafe { &*Self::PTR }
1567    }
1568}
1569impl core::fmt::Debug for Tcc1 {
1570    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1571        f.debug_struct("Tcc1").finish()
1572    }
1573}
1574#[doc = "Timer Counter Control 1"]
1575pub use self::tcc0 as tcc1;
1576#[doc = "Timer Counter Control 2"]
1577pub struct Tcc2 {
1578    _marker: PhantomData<*const ()>,
1579}
1580unsafe impl Send for Tcc2 {}
1581impl Tcc2 {
1582    #[doc = r"Pointer to the register block"]
1583    pub const PTR: *const tcc0::RegisterBlock = 0x4200_2800 as *const _;
1584    #[doc = r"Return the pointer to the register block"]
1585    #[inline(always)]
1586    pub const fn ptr() -> *const tcc0::RegisterBlock {
1587        Self::PTR
1588    }
1589    #[doc = r" Steal an instance of this peripheral"]
1590    #[doc = r""]
1591    #[doc = r" # Safety"]
1592    #[doc = r""]
1593    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1594    #[doc = r" that may race with any existing instances, for example by only"]
1595    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1596    #[doc = r" original peripheral and using critical sections to coordinate"]
1597    #[doc = r" access between multiple new instances."]
1598    #[doc = r""]
1599    #[doc = r" Additionally, other software such as HALs may rely on only one"]
1600    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1601    #[doc = r" no stolen instances are passed to such software."]
1602    pub unsafe fn steal() -> Self {
1603        Self {
1604            _marker: PhantomData,
1605        }
1606    }
1607}
1608impl Deref for Tcc2 {
1609    type Target = tcc0::RegisterBlock;
1610    #[inline(always)]
1611    fn deref(&self) -> &Self::Target {
1612        unsafe { &*Self::PTR }
1613    }
1614}
1615impl core::fmt::Debug for Tcc2 {
1616    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1617        f.debug_struct("Tcc2").finish()
1618    }
1619}
1620#[doc = "Timer Counter Control 2"]
1621pub use self::tcc0 as tcc2;
1622#[doc = "Universal Serial Bus"]
1623pub struct Usb {
1624    _marker: PhantomData<*const ()>,
1625}
1626unsafe impl Send for Usb {}
1627impl Usb {
1628    #[doc = r"Pointer to the register block"]
1629    pub const PTR: *const usb::RegisterBlock = 0x4100_5000 as *const _;
1630    #[doc = r"Return the pointer to the register block"]
1631    #[inline(always)]
1632    pub const fn ptr() -> *const usb::RegisterBlock {
1633        Self::PTR
1634    }
1635    #[doc = r" Steal an instance of this peripheral"]
1636    #[doc = r""]
1637    #[doc = r" # Safety"]
1638    #[doc = r""]
1639    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1640    #[doc = r" that may race with any existing instances, for example by only"]
1641    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1642    #[doc = r" original peripheral and using critical sections to coordinate"]
1643    #[doc = r" access between multiple new instances."]
1644    #[doc = r""]
1645    #[doc = r" Additionally, other software such as HALs may rely on only one"]
1646    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1647    #[doc = r" no stolen instances are passed to such software."]
1648    pub unsafe fn steal() -> Self {
1649        Self {
1650            _marker: PhantomData,
1651        }
1652    }
1653}
1654impl Deref for Usb {
1655    type Target = usb::RegisterBlock;
1656    #[inline(always)]
1657    fn deref(&self) -> &Self::Target {
1658        unsafe { &*Self::PTR }
1659    }
1660}
1661impl core::fmt::Debug for Usb {
1662    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1663        f.debug_struct("Usb").finish()
1664    }
1665}
1666#[doc = "Universal Serial Bus"]
1667pub mod usb;
1668#[doc = "Watchdog Timer"]
1669pub struct Wdt {
1670    _marker: PhantomData<*const ()>,
1671}
1672unsafe impl Send for Wdt {}
1673impl Wdt {
1674    #[doc = r"Pointer to the register block"]
1675    pub const PTR: *const wdt::RegisterBlock = 0x4000_1000 as *const _;
1676    #[doc = r"Return the pointer to the register block"]
1677    #[inline(always)]
1678    pub const fn ptr() -> *const wdt::RegisterBlock {
1679        Self::PTR
1680    }
1681    #[doc = r" Steal an instance of this peripheral"]
1682    #[doc = r""]
1683    #[doc = r" # Safety"]
1684    #[doc = r""]
1685    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1686    #[doc = r" that may race with any existing instances, for example by only"]
1687    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1688    #[doc = r" original peripheral and using critical sections to coordinate"]
1689    #[doc = r" access between multiple new instances."]
1690    #[doc = r""]
1691    #[doc = r" Additionally, other software such as HALs may rely on only one"]
1692    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1693    #[doc = r" no stolen instances are passed to such software."]
1694    pub unsafe fn steal() -> Self {
1695        Self {
1696            _marker: PhantomData,
1697        }
1698    }
1699}
1700impl Deref for Wdt {
1701    type Target = wdt::RegisterBlock;
1702    #[inline(always)]
1703    fn deref(&self) -> &Self::Target {
1704        unsafe { &*Self::PTR }
1705    }
1706}
1707impl core::fmt::Debug for Wdt {
1708    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1709        f.debug_struct("Wdt").finish()
1710    }
1711}
1712#[doc = "Watchdog Timer"]
1713pub mod wdt;
1714#[no_mangle]
1715static mut DEVICE_PERIPHERALS: bool = false;
1716#[doc = r" All the peripherals."]
1717#[allow(non_snake_case)]
1718pub struct Peripherals {
1719    #[doc = "AC"]
1720    pub ac: Ac,
1721    #[doc = "ADC"]
1722    pub adc: Adc,
1723    #[doc = "DAC"]
1724    pub dac: Dac,
1725    #[doc = "DMAC"]
1726    pub dmac: Dmac,
1727    #[doc = "DSU"]
1728    pub dsu: Dsu,
1729    #[doc = "EIC"]
1730    pub eic: Eic,
1731    #[doc = "EVSYS"]
1732    pub evsys: Evsys,
1733    #[doc = "GCLK"]
1734    pub gclk: Gclk,
1735    #[doc = "HMATRIX"]
1736    pub hmatrix: Hmatrix,
1737    #[doc = "I2S"]
1738    pub i2s: I2s,
1739    #[doc = "MTB"]
1740    pub mtb: Mtb,
1741    #[doc = "NVMCTRL"]
1742    pub nvmctrl: Nvmctrl,
1743    #[doc = "PAC0"]
1744    pub pac0: Pac0,
1745    #[doc = "PAC1"]
1746    pub pac1: Pac1,
1747    #[doc = "PAC2"]
1748    pub pac2: Pac2,
1749    #[doc = "PM"]
1750    pub pm: Pm,
1751    #[doc = "PORT"]
1752    pub port: Port,
1753    #[doc = "PORT_IOBUS"]
1754    pub port_iobus: PortIobus,
1755    #[doc = "RTC"]
1756    pub rtc: Rtc,
1757    #[doc = "SERCOM0"]
1758    pub sercom0: Sercom0,
1759    #[doc = "SERCOM1"]
1760    pub sercom1: Sercom1,
1761    #[doc = "SERCOM2"]
1762    pub sercom2: Sercom2,
1763    #[doc = "SERCOM3"]
1764    pub sercom3: Sercom3,
1765    #[doc = "SERCOM4"]
1766    pub sercom4: Sercom4,
1767    #[doc = "SERCOM5"]
1768    pub sercom5: Sercom5,
1769    #[doc = "SYSCTRL"]
1770    pub sysctrl: Sysctrl,
1771    #[doc = "TC3"]
1772    pub tc3: Tc3,
1773    #[doc = "TC4"]
1774    pub tc4: Tc4,
1775    #[doc = "TC5"]
1776    pub tc5: Tc5,
1777    #[doc = "TCC0"]
1778    pub tcc0: Tcc0,
1779    #[doc = "TCC1"]
1780    pub tcc1: Tcc1,
1781    #[doc = "TCC2"]
1782    pub tcc2: Tcc2,
1783    #[doc = "USB"]
1784    pub usb: Usb,
1785    #[doc = "WDT"]
1786    pub wdt: Wdt,
1787}
1788impl Peripherals {
1789    #[doc = r" Returns all the peripherals *once*."]
1790    #[inline]
1791    pub fn take() -> Option<Self> {
1792        critical_section::with(|_| {
1793            if unsafe { DEVICE_PERIPHERALS } {
1794                return None;
1795            }
1796            Some(unsafe { Peripherals::steal() })
1797        })
1798    }
1799    #[doc = r" Unchecked version of `Peripherals::take`."]
1800    #[doc = r""]
1801    #[doc = r" # Safety"]
1802    #[doc = r""]
1803    #[doc = r" Each of the returned peripherals must be used at most once."]
1804    #[inline]
1805    pub unsafe fn steal() -> Self {
1806        DEVICE_PERIPHERALS = true;
1807        Peripherals {
1808            ac: Ac::steal(),
1809            adc: Adc::steal(),
1810            dac: Dac::steal(),
1811            dmac: Dmac::steal(),
1812            dsu: Dsu::steal(),
1813            eic: Eic::steal(),
1814            evsys: Evsys::steal(),
1815            gclk: Gclk::steal(),
1816            hmatrix: Hmatrix::steal(),
1817            i2s: I2s::steal(),
1818            mtb: Mtb::steal(),
1819            nvmctrl: Nvmctrl::steal(),
1820            pac0: Pac0::steal(),
1821            pac1: Pac1::steal(),
1822            pac2: Pac2::steal(),
1823            pm: Pm::steal(),
1824            port: Port::steal(),
1825            port_iobus: PortIobus::steal(),
1826            rtc: Rtc::steal(),
1827            sercom0: Sercom0::steal(),
1828            sercom1: Sercom1::steal(),
1829            sercom2: Sercom2::steal(),
1830            sercom3: Sercom3::steal(),
1831            sercom4: Sercom4::steal(),
1832            sercom5: Sercom5::steal(),
1833            sysctrl: Sysctrl::steal(),
1834            tc3: Tc3::steal(),
1835            tc4: Tc4::steal(),
1836            tc5: Tc5::steal(),
1837            tcc0: Tcc0::steal(),
1838            tcc1: Tcc1::steal(),
1839            tcc2: Tcc2::steal(),
1840            usb: Usb::steal(),
1841            wdt: Wdt::steal(),
1842        }
1843    }
1844}
atsamd21g/lib.rs

atsamd21g/
lib.rs
