atsamd21g/
lib.rs

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

atsamd21g/
lib.rs
