atsam3n2a/
lib.rs

1#![doc = "Peripheral access API for ATSAM3N2A microcontrollers (generated using svd2rust v0.33.0 ( ))\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.0/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#![no_std]
6use core::marker::PhantomData;
7use core::ops::Deref;
8#[doc = r"Number available in the NVIC for configuring priority"]
9pub const NVIC_PRIO_BITS: u8 = 4;
10#[allow(unused_imports)]
11use generic::*;
12#[doc = "Common register and bit access and modify traits"]
13pub mod generic;
14#[cfg(feature = "rt")]
15extern "C" {
16    fn PMC();
17    fn EFC();
18    fn UART0();
19    fn UART1();
20    fn PIOA();
21    fn PIOB();
22    fn USART0();
23    fn TWI0();
24    fn TWI1();
25    fn SPI();
26    fn TC0();
27    fn TC1();
28    fn TC2();
29    fn ADC();
30    fn DACC();
31    fn PWM();
32}
33#[doc(hidden)]
34#[repr(C)]
35pub union Vector {
36    _handler: unsafe extern "C" fn(),
37    _reserved: u32,
38}
39#[cfg(feature = "rt")]
40#[doc(hidden)]
41#[link_section = ".vector_table.interrupts"]
42#[no_mangle]
43pub static __INTERRUPTS: [Vector; 32] = [
44    Vector { _reserved: 0 },
45    Vector { _reserved: 0 },
46    Vector { _reserved: 0 },
47    Vector { _reserved: 0 },
48    Vector { _reserved: 0 },
49    Vector { _handler: PMC },
50    Vector { _handler: EFC },
51    Vector { _reserved: 0 },
52    Vector { _handler: UART0 },
53    Vector { _handler: UART1 },
54    Vector { _reserved: 0 },
55    Vector { _handler: PIOA },
56    Vector { _handler: PIOB },
57    Vector { _reserved: 0 },
58    Vector { _handler: USART0 },
59    Vector { _reserved: 0 },
60    Vector { _reserved: 0 },
61    Vector { _reserved: 0 },
62    Vector { _reserved: 0 },
63    Vector { _handler: TWI0 },
64    Vector { _handler: TWI1 },
65    Vector { _handler: SPI },
66    Vector { _reserved: 0 },
67    Vector { _handler: TC0 },
68    Vector { _handler: TC1 },
69    Vector { _handler: TC2 },
70    Vector { _reserved: 0 },
71    Vector { _reserved: 0 },
72    Vector { _reserved: 0 },
73    Vector { _handler: ADC },
74    Vector { _handler: DACC },
75    Vector { _handler: PWM },
76];
77#[doc = r"Enumeration of all the interrupts."]
78#[derive(Copy, Clone, Debug, PartialEq, Eq)]
79#[repr(u16)]
80pub enum Interrupt {
81    #[doc = "5 - PMC"]
82    PMC = 5,
83    #[doc = "6 - EFC"]
84    EFC = 6,
85    #[doc = "8 - UART0"]
86    UART0 = 8,
87    #[doc = "9 - UART1"]
88    UART1 = 9,
89    #[doc = "11 - PIOA"]
90    PIOA = 11,
91    #[doc = "12 - PIOB"]
92    PIOB = 12,
93    #[doc = "14 - USART0"]
94    USART0 = 14,
95    #[doc = "19 - TWI0"]
96    TWI0 = 19,
97    #[doc = "20 - TWI1"]
98    TWI1 = 20,
99    #[doc = "21 - SPI"]
100    SPI = 21,
101    #[doc = "23 - TC0"]
102    TC0 = 23,
103    #[doc = "24 - TC1"]
104    TC1 = 24,
105    #[doc = "25 - TC2"]
106    TC2 = 25,
107    #[doc = "29 - ADC"]
108    ADC = 29,
109    #[doc = "30 - DACC"]
110    DACC = 30,
111    #[doc = "31 - PWM"]
112    PWM = 31,
113}
114unsafe impl cortex_m::interrupt::InterruptNumber for Interrupt {
115    #[inline(always)]
116    fn number(self) -> u16 {
117        self as u16
118    }
119}
120#[doc = "Serial Peripheral Interface"]
121pub struct SPI {
122    _marker: PhantomData<*const ()>,
123}
124unsafe impl Send for SPI {}
125impl SPI {
126    #[doc = r"Pointer to the register block"]
127    pub const PTR: *const spi::RegisterBlock = 0x4000_8000 as *const _;
128    #[doc = r"Return the pointer to the register block"]
129    #[inline(always)]
130    pub const fn ptr() -> *const spi::RegisterBlock {
131        Self::PTR
132    }
133    #[doc = r" Steal an instance of this peripheral"]
134    #[doc = r""]
135    #[doc = r" # Safety"]
136    #[doc = r""]
137    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
138    #[doc = r" that may race with any existing instances, for example by only"]
139    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
140    #[doc = r" original peripheral and using critical sections to coordinate"]
141    #[doc = r" access between multiple new instances."]
142    #[doc = r""]
143    #[doc = r" Additionally, other software such as HALs may rely on only one"]
144    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
145    #[doc = r" no stolen instances are passed to such software."]
146    pub unsafe fn steal() -> Self {
147        Self {
148            _marker: PhantomData,
149        }
150    }
151}
152impl Deref for SPI {
153    type Target = spi::RegisterBlock;
154    #[inline(always)]
155    fn deref(&self) -> &Self::Target {
156        unsafe { &*Self::PTR }
157    }
158}
159impl core::fmt::Debug for SPI {
160    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
161        f.debug_struct("SPI").finish()
162    }
163}
164#[doc = "Serial Peripheral Interface"]
165pub mod spi;
166#[doc = "Timer Counter 0"]
167pub struct TC0 {
168    _marker: PhantomData<*const ()>,
169}
170unsafe impl Send for TC0 {}
171impl TC0 {
172    #[doc = r"Pointer to the register block"]
173    pub const PTR: *const tc0::RegisterBlock = 0x4001_0000 as *const _;
174    #[doc = r"Return the pointer to the register block"]
175    #[inline(always)]
176    pub const fn ptr() -> *const tc0::RegisterBlock {
177        Self::PTR
178    }
179    #[doc = r" Steal an instance of this peripheral"]
180    #[doc = r""]
181    #[doc = r" # Safety"]
182    #[doc = r""]
183    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
184    #[doc = r" that may race with any existing instances, for example by only"]
185    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
186    #[doc = r" original peripheral and using critical sections to coordinate"]
187    #[doc = r" access between multiple new instances."]
188    #[doc = r""]
189    #[doc = r" Additionally, other software such as HALs may rely on only one"]
190    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
191    #[doc = r" no stolen instances are passed to such software."]
192    pub unsafe fn steal() -> Self {
193        Self {
194            _marker: PhantomData,
195        }
196    }
197}
198impl Deref for TC0 {
199    type Target = tc0::RegisterBlock;
200    #[inline(always)]
201    fn deref(&self) -> &Self::Target {
202        unsafe { &*Self::PTR }
203    }
204}
205impl core::fmt::Debug for TC0 {
206    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
207        f.debug_struct("TC0").finish()
208    }
209}
210#[doc = "Timer Counter 0"]
211pub mod tc0;
212#[doc = "Two-wire Interface 0"]
213pub struct TWI0 {
214    _marker: PhantomData<*const ()>,
215}
216unsafe impl Send for TWI0 {}
217impl TWI0 {
218    #[doc = r"Pointer to the register block"]
219    pub const PTR: *const twi0::RegisterBlock = 0x4001_8000 as *const _;
220    #[doc = r"Return the pointer to the register block"]
221    #[inline(always)]
222    pub const fn ptr() -> *const twi0::RegisterBlock {
223        Self::PTR
224    }
225    #[doc = r" Steal an instance of this peripheral"]
226    #[doc = r""]
227    #[doc = r" # Safety"]
228    #[doc = r""]
229    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
230    #[doc = r" that may race with any existing instances, for example by only"]
231    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
232    #[doc = r" original peripheral and using critical sections to coordinate"]
233    #[doc = r" access between multiple new instances."]
234    #[doc = r""]
235    #[doc = r" Additionally, other software such as HALs may rely on only one"]
236    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
237    #[doc = r" no stolen instances are passed to such software."]
238    pub unsafe fn steal() -> Self {
239        Self {
240            _marker: PhantomData,
241        }
242    }
243}
244impl Deref for TWI0 {
245    type Target = twi0::RegisterBlock;
246    #[inline(always)]
247    fn deref(&self) -> &Self::Target {
248        unsafe { &*Self::PTR }
249    }
250}
251impl core::fmt::Debug for TWI0 {
252    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
253        f.debug_struct("TWI0").finish()
254    }
255}
256#[doc = "Two-wire Interface 0"]
257pub mod twi0;
258#[doc = "Two-wire Interface 1"]
259pub struct TWI1 {
260    _marker: PhantomData<*const ()>,
261}
262unsafe impl Send for TWI1 {}
263impl TWI1 {
264    #[doc = r"Pointer to the register block"]
265    pub const PTR: *const twi1::RegisterBlock = 0x4001_c000 as *const _;
266    #[doc = r"Return the pointer to the register block"]
267    #[inline(always)]
268    pub const fn ptr() -> *const twi1::RegisterBlock {
269        Self::PTR
270    }
271    #[doc = r" Steal an instance of this peripheral"]
272    #[doc = r""]
273    #[doc = r" # Safety"]
274    #[doc = r""]
275    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
276    #[doc = r" that may race with any existing instances, for example by only"]
277    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
278    #[doc = r" original peripheral and using critical sections to coordinate"]
279    #[doc = r" access between multiple new instances."]
280    #[doc = r""]
281    #[doc = r" Additionally, other software such as HALs may rely on only one"]
282    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
283    #[doc = r" no stolen instances are passed to such software."]
284    pub unsafe fn steal() -> Self {
285        Self {
286            _marker: PhantomData,
287        }
288    }
289}
290impl Deref for TWI1 {
291    type Target = twi1::RegisterBlock;
292    #[inline(always)]
293    fn deref(&self) -> &Self::Target {
294        unsafe { &*Self::PTR }
295    }
296}
297impl core::fmt::Debug for TWI1 {
298    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
299        f.debug_struct("TWI1").finish()
300    }
301}
302#[doc = "Two-wire Interface 1"]
303pub mod twi1;
304#[doc = "Pulse Width Modulation Controller"]
305pub struct PWM {
306    _marker: PhantomData<*const ()>,
307}
308unsafe impl Send for PWM {}
309impl PWM {
310    #[doc = r"Pointer to the register block"]
311    pub const PTR: *const pwm::RegisterBlock = 0x4002_0000 as *const _;
312    #[doc = r"Return the pointer to the register block"]
313    #[inline(always)]
314    pub const fn ptr() -> *const pwm::RegisterBlock {
315        Self::PTR
316    }
317    #[doc = r" Steal an instance of this peripheral"]
318    #[doc = r""]
319    #[doc = r" # Safety"]
320    #[doc = r""]
321    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
322    #[doc = r" that may race with any existing instances, for example by only"]
323    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
324    #[doc = r" original peripheral and using critical sections to coordinate"]
325    #[doc = r" access between multiple new instances."]
326    #[doc = r""]
327    #[doc = r" Additionally, other software such as HALs may rely on only one"]
328    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
329    #[doc = r" no stolen instances are passed to such software."]
330    pub unsafe fn steal() -> Self {
331        Self {
332            _marker: PhantomData,
333        }
334    }
335}
336impl Deref for PWM {
337    type Target = pwm::RegisterBlock;
338    #[inline(always)]
339    fn deref(&self) -> &Self::Target {
340        unsafe { &*Self::PTR }
341    }
342}
343impl core::fmt::Debug for PWM {
344    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
345        f.debug_struct("PWM").finish()
346    }
347}
348#[doc = "Pulse Width Modulation Controller"]
349pub mod pwm;
350#[doc = "Universal Synchronous Asynchronous Receiver Transmitter 0"]
351pub struct USART0 {
352    _marker: PhantomData<*const ()>,
353}
354unsafe impl Send for USART0 {}
355impl USART0 {
356    #[doc = r"Pointer to the register block"]
357    pub const PTR: *const usart0::RegisterBlock = 0x4002_4000 as *const _;
358    #[doc = r"Return the pointer to the register block"]
359    #[inline(always)]
360    pub const fn ptr() -> *const usart0::RegisterBlock {
361        Self::PTR
362    }
363    #[doc = r" Steal an instance of this peripheral"]
364    #[doc = r""]
365    #[doc = r" # Safety"]
366    #[doc = r""]
367    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
368    #[doc = r" that may race with any existing instances, for example by only"]
369    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
370    #[doc = r" original peripheral and using critical sections to coordinate"]
371    #[doc = r" access between multiple new instances."]
372    #[doc = r""]
373    #[doc = r" Additionally, other software such as HALs may rely on only one"]
374    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
375    #[doc = r" no stolen instances are passed to such software."]
376    pub unsafe fn steal() -> Self {
377        Self {
378            _marker: PhantomData,
379        }
380    }
381}
382impl Deref for USART0 {
383    type Target = usart0::RegisterBlock;
384    #[inline(always)]
385    fn deref(&self) -> &Self::Target {
386        unsafe { &*Self::PTR }
387    }
388}
389impl core::fmt::Debug for USART0 {
390    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
391        f.debug_struct("USART0").finish()
392    }
393}
394#[doc = "Universal Synchronous Asynchronous Receiver Transmitter 0"]
395pub mod usart0;
396#[doc = "Analog-to-Digital Converter"]
397pub struct ADC {
398    _marker: PhantomData<*const ()>,
399}
400unsafe impl Send for ADC {}
401impl ADC {
402    #[doc = r"Pointer to the register block"]
403    pub const PTR: *const adc::RegisterBlock = 0x4003_8000 as *const _;
404    #[doc = r"Return the pointer to the register block"]
405    #[inline(always)]
406    pub const fn ptr() -> *const adc::RegisterBlock {
407        Self::PTR
408    }
409    #[doc = r" Steal an instance of this peripheral"]
410    #[doc = r""]
411    #[doc = r" # Safety"]
412    #[doc = r""]
413    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
414    #[doc = r" that may race with any existing instances, for example by only"]
415    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
416    #[doc = r" original peripheral and using critical sections to coordinate"]
417    #[doc = r" access between multiple new instances."]
418    #[doc = r""]
419    #[doc = r" Additionally, other software such as HALs may rely on only one"]
420    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
421    #[doc = r" no stolen instances are passed to such software."]
422    pub unsafe fn steal() -> Self {
423        Self {
424            _marker: PhantomData,
425        }
426    }
427}
428impl Deref for ADC {
429    type Target = adc::RegisterBlock;
430    #[inline(always)]
431    fn deref(&self) -> &Self::Target {
432        unsafe { &*Self::PTR }
433    }
434}
435impl core::fmt::Debug for ADC {
436    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
437        f.debug_struct("ADC").finish()
438    }
439}
440#[doc = "Analog-to-Digital Converter"]
441pub mod adc;
442#[doc = "Digital-to-Analog Converter Controller"]
443pub struct DACC {
444    _marker: PhantomData<*const ()>,
445}
446unsafe impl Send for DACC {}
447impl DACC {
448    #[doc = r"Pointer to the register block"]
449    pub const PTR: *const dacc::RegisterBlock = 0x4003_c000 as *const _;
450    #[doc = r"Return the pointer to the register block"]
451    #[inline(always)]
452    pub const fn ptr() -> *const dacc::RegisterBlock {
453        Self::PTR
454    }
455    #[doc = r" Steal an instance of this peripheral"]
456    #[doc = r""]
457    #[doc = r" # Safety"]
458    #[doc = r""]
459    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
460    #[doc = r" that may race with any existing instances, for example by only"]
461    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
462    #[doc = r" original peripheral and using critical sections to coordinate"]
463    #[doc = r" access between multiple new instances."]
464    #[doc = r""]
465    #[doc = r" Additionally, other software such as HALs may rely on only one"]
466    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
467    #[doc = r" no stolen instances are passed to such software."]
468    pub unsafe fn steal() -> Self {
469        Self {
470            _marker: PhantomData,
471        }
472    }
473}
474impl Deref for DACC {
475    type Target = dacc::RegisterBlock;
476    #[inline(always)]
477    fn deref(&self) -> &Self::Target {
478        unsafe { &*Self::PTR }
479    }
480}
481impl core::fmt::Debug for DACC {
482    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
483        f.debug_struct("DACC").finish()
484    }
485}
486#[doc = "Digital-to-Analog Converter Controller"]
487pub mod dacc;
488#[doc = "AHB Bus Matrix"]
489pub struct MATRIX {
490    _marker: PhantomData<*const ()>,
491}
492unsafe impl Send for MATRIX {}
493impl MATRIX {
494    #[doc = r"Pointer to the register block"]
495    pub const PTR: *const matrix::RegisterBlock = 0x400e_0200 as *const _;
496    #[doc = r"Return the pointer to the register block"]
497    #[inline(always)]
498    pub const fn ptr() -> *const matrix::RegisterBlock {
499        Self::PTR
500    }
501    #[doc = r" Steal an instance of this peripheral"]
502    #[doc = r""]
503    #[doc = r" # Safety"]
504    #[doc = r""]
505    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
506    #[doc = r" that may race with any existing instances, for example by only"]
507    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
508    #[doc = r" original peripheral and using critical sections to coordinate"]
509    #[doc = r" access between multiple new instances."]
510    #[doc = r""]
511    #[doc = r" Additionally, other software such as HALs may rely on only one"]
512    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
513    #[doc = r" no stolen instances are passed to such software."]
514    pub unsafe fn steal() -> Self {
515        Self {
516            _marker: PhantomData,
517        }
518    }
519}
520impl Deref for MATRIX {
521    type Target = matrix::RegisterBlock;
522    #[inline(always)]
523    fn deref(&self) -> &Self::Target {
524        unsafe { &*Self::PTR }
525    }
526}
527impl core::fmt::Debug for MATRIX {
528    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
529        f.debug_struct("MATRIX").finish()
530    }
531}
532#[doc = "AHB Bus Matrix"]
533pub mod matrix;
534#[doc = "Power Management Controller"]
535pub struct PMC {
536    _marker: PhantomData<*const ()>,
537}
538unsafe impl Send for PMC {}
539impl PMC {
540    #[doc = r"Pointer to the register block"]
541    pub const PTR: *const pmc::RegisterBlock = 0x400e_0400 as *const _;
542    #[doc = r"Return the pointer to the register block"]
543    #[inline(always)]
544    pub const fn ptr() -> *const pmc::RegisterBlock {
545        Self::PTR
546    }
547    #[doc = r" Steal an instance of this peripheral"]
548    #[doc = r""]
549    #[doc = r" # Safety"]
550    #[doc = r""]
551    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
552    #[doc = r" that may race with any existing instances, for example by only"]
553    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
554    #[doc = r" original peripheral and using critical sections to coordinate"]
555    #[doc = r" access between multiple new instances."]
556    #[doc = r""]
557    #[doc = r" Additionally, other software such as HALs may rely on only one"]
558    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
559    #[doc = r" no stolen instances are passed to such software."]
560    pub unsafe fn steal() -> Self {
561        Self {
562            _marker: PhantomData,
563        }
564    }
565}
566impl Deref for PMC {
567    type Target = pmc::RegisterBlock;
568    #[inline(always)]
569    fn deref(&self) -> &Self::Target {
570        unsafe { &*Self::PTR }
571    }
572}
573impl core::fmt::Debug for PMC {
574    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
575        f.debug_struct("PMC").finish()
576    }
577}
578#[doc = "Power Management Controller"]
579pub mod pmc;
580#[doc = "Universal Asynchronous Receiver Transmitter 0"]
581pub struct UART0 {
582    _marker: PhantomData<*const ()>,
583}
584unsafe impl Send for UART0 {}
585impl UART0 {
586    #[doc = r"Pointer to the register block"]
587    pub const PTR: *const uart0::RegisterBlock = 0x400e_0600 as *const _;
588    #[doc = r"Return the pointer to the register block"]
589    #[inline(always)]
590    pub const fn ptr() -> *const uart0::RegisterBlock {
591        Self::PTR
592    }
593    #[doc = r" Steal an instance of this peripheral"]
594    #[doc = r""]
595    #[doc = r" # Safety"]
596    #[doc = r""]
597    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
598    #[doc = r" that may race with any existing instances, for example by only"]
599    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
600    #[doc = r" original peripheral and using critical sections to coordinate"]
601    #[doc = r" access between multiple new instances."]
602    #[doc = r""]
603    #[doc = r" Additionally, other software such as HALs may rely on only one"]
604    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
605    #[doc = r" no stolen instances are passed to such software."]
606    pub unsafe fn steal() -> Self {
607        Self {
608            _marker: PhantomData,
609        }
610    }
611}
612impl Deref for UART0 {
613    type Target = uart0::RegisterBlock;
614    #[inline(always)]
615    fn deref(&self) -> &Self::Target {
616        unsafe { &*Self::PTR }
617    }
618}
619impl core::fmt::Debug for UART0 {
620    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
621        f.debug_struct("UART0").finish()
622    }
623}
624#[doc = "Universal Asynchronous Receiver Transmitter 0"]
625pub mod uart0;
626#[doc = "Chip Identifier"]
627pub struct CHIPID {
628    _marker: PhantomData<*const ()>,
629}
630unsafe impl Send for CHIPID {}
631impl CHIPID {
632    #[doc = r"Pointer to the register block"]
633    pub const PTR: *const chipid::RegisterBlock = 0x400e_0740 as *const _;
634    #[doc = r"Return the pointer to the register block"]
635    #[inline(always)]
636    pub const fn ptr() -> *const chipid::RegisterBlock {
637        Self::PTR
638    }
639    #[doc = r" Steal an instance of this peripheral"]
640    #[doc = r""]
641    #[doc = r" # Safety"]
642    #[doc = r""]
643    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
644    #[doc = r" that may race with any existing instances, for example by only"]
645    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
646    #[doc = r" original peripheral and using critical sections to coordinate"]
647    #[doc = r" access between multiple new instances."]
648    #[doc = r""]
649    #[doc = r" Additionally, other software such as HALs may rely on only one"]
650    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
651    #[doc = r" no stolen instances are passed to such software."]
652    pub unsafe fn steal() -> Self {
653        Self {
654            _marker: PhantomData,
655        }
656    }
657}
658impl Deref for CHIPID {
659    type Target = chipid::RegisterBlock;
660    #[inline(always)]
661    fn deref(&self) -> &Self::Target {
662        unsafe { &*Self::PTR }
663    }
664}
665impl core::fmt::Debug for CHIPID {
666    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
667        f.debug_struct("CHIPID").finish()
668    }
669}
670#[doc = "Chip Identifier"]
671pub mod chipid;
672#[doc = "Universal Asynchronous Receiver Transmitter 1"]
673pub struct UART1 {
674    _marker: PhantomData<*const ()>,
675}
676unsafe impl Send for UART1 {}
677impl UART1 {
678    #[doc = r"Pointer to the register block"]
679    pub const PTR: *const uart1::RegisterBlock = 0x400e_0800 as *const _;
680    #[doc = r"Return the pointer to the register block"]
681    #[inline(always)]
682    pub const fn ptr() -> *const uart1::RegisterBlock {
683        Self::PTR
684    }
685    #[doc = r" Steal an instance of this peripheral"]
686    #[doc = r""]
687    #[doc = r" # Safety"]
688    #[doc = r""]
689    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
690    #[doc = r" that may race with any existing instances, for example by only"]
691    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
692    #[doc = r" original peripheral and using critical sections to coordinate"]
693    #[doc = r" access between multiple new instances."]
694    #[doc = r""]
695    #[doc = r" Additionally, other software such as HALs may rely on only one"]
696    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
697    #[doc = r" no stolen instances are passed to such software."]
698    pub unsafe fn steal() -> Self {
699        Self {
700            _marker: PhantomData,
701        }
702    }
703}
704impl Deref for UART1 {
705    type Target = uart1::RegisterBlock;
706    #[inline(always)]
707    fn deref(&self) -> &Self::Target {
708        unsafe { &*Self::PTR }
709    }
710}
711impl core::fmt::Debug for UART1 {
712    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
713        f.debug_struct("UART1").finish()
714    }
715}
716#[doc = "Universal Asynchronous Receiver Transmitter 1"]
717pub mod uart1;
718#[doc = "Embedded Flash Controller"]
719pub struct EFC {
720    _marker: PhantomData<*const ()>,
721}
722unsafe impl Send for EFC {}
723impl EFC {
724    #[doc = r"Pointer to the register block"]
725    pub const PTR: *const efc::RegisterBlock = 0x400e_0a00 as *const _;
726    #[doc = r"Return the pointer to the register block"]
727    #[inline(always)]
728    pub const fn ptr() -> *const efc::RegisterBlock {
729        Self::PTR
730    }
731    #[doc = r" Steal an instance of this peripheral"]
732    #[doc = r""]
733    #[doc = r" # Safety"]
734    #[doc = r""]
735    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
736    #[doc = r" that may race with any existing instances, for example by only"]
737    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
738    #[doc = r" original peripheral and using critical sections to coordinate"]
739    #[doc = r" access between multiple new instances."]
740    #[doc = r""]
741    #[doc = r" Additionally, other software such as HALs may rely on only one"]
742    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
743    #[doc = r" no stolen instances are passed to such software."]
744    pub unsafe fn steal() -> Self {
745        Self {
746            _marker: PhantomData,
747        }
748    }
749}
750impl Deref for EFC {
751    type Target = efc::RegisterBlock;
752    #[inline(always)]
753    fn deref(&self) -> &Self::Target {
754        unsafe { &*Self::PTR }
755    }
756}
757impl core::fmt::Debug for EFC {
758    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
759        f.debug_struct("EFC").finish()
760    }
761}
762#[doc = "Embedded Flash Controller"]
763pub mod efc;
764#[doc = "Parallel Input/Output Controller A"]
765pub struct PIOA {
766    _marker: PhantomData<*const ()>,
767}
768unsafe impl Send for PIOA {}
769impl PIOA {
770    #[doc = r"Pointer to the register block"]
771    pub const PTR: *const pioa::RegisterBlock = 0x400e_0e00 as *const _;
772    #[doc = r"Return the pointer to the register block"]
773    #[inline(always)]
774    pub const fn ptr() -> *const pioa::RegisterBlock {
775        Self::PTR
776    }
777    #[doc = r" Steal an instance of this peripheral"]
778    #[doc = r""]
779    #[doc = r" # Safety"]
780    #[doc = r""]
781    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
782    #[doc = r" that may race with any existing instances, for example by only"]
783    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
784    #[doc = r" original peripheral and using critical sections to coordinate"]
785    #[doc = r" access between multiple new instances."]
786    #[doc = r""]
787    #[doc = r" Additionally, other software such as HALs may rely on only one"]
788    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
789    #[doc = r" no stolen instances are passed to such software."]
790    pub unsafe fn steal() -> Self {
791        Self {
792            _marker: PhantomData,
793        }
794    }
795}
796impl Deref for PIOA {
797    type Target = pioa::RegisterBlock;
798    #[inline(always)]
799    fn deref(&self) -> &Self::Target {
800        unsafe { &*Self::PTR }
801    }
802}
803impl core::fmt::Debug for PIOA {
804    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
805        f.debug_struct("PIOA").finish()
806    }
807}
808#[doc = "Parallel Input/Output Controller A"]
809pub mod pioa;
810#[doc = "Parallel Input/Output Controller B"]
811pub struct PIOB {
812    _marker: PhantomData<*const ()>,
813}
814unsafe impl Send for PIOB {}
815impl PIOB {
816    #[doc = r"Pointer to the register block"]
817    pub const PTR: *const piob::RegisterBlock = 0x400e_1000 as *const _;
818    #[doc = r"Return the pointer to the register block"]
819    #[inline(always)]
820    pub const fn ptr() -> *const piob::RegisterBlock {
821        Self::PTR
822    }
823    #[doc = r" Steal an instance of this peripheral"]
824    #[doc = r""]
825    #[doc = r" # Safety"]
826    #[doc = r""]
827    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
828    #[doc = r" that may race with any existing instances, for example by only"]
829    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
830    #[doc = r" original peripheral and using critical sections to coordinate"]
831    #[doc = r" access between multiple new instances."]
832    #[doc = r""]
833    #[doc = r" Additionally, other software such as HALs may rely on only one"]
834    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
835    #[doc = r" no stolen instances are passed to such software."]
836    pub unsafe fn steal() -> Self {
837        Self {
838            _marker: PhantomData,
839        }
840    }
841}
842impl Deref for PIOB {
843    type Target = piob::RegisterBlock;
844    #[inline(always)]
845    fn deref(&self) -> &Self::Target {
846        unsafe { &*Self::PTR }
847    }
848}
849impl core::fmt::Debug for PIOB {
850    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
851        f.debug_struct("PIOB").finish()
852    }
853}
854#[doc = "Parallel Input/Output Controller B"]
855pub mod piob;
856#[doc = "Reset Controller"]
857pub struct RSTC {
858    _marker: PhantomData<*const ()>,
859}
860unsafe impl Send for RSTC {}
861impl RSTC {
862    #[doc = r"Pointer to the register block"]
863    pub const PTR: *const rstc::RegisterBlock = 0x400e_1400 as *const _;
864    #[doc = r"Return the pointer to the register block"]
865    #[inline(always)]
866    pub const fn ptr() -> *const rstc::RegisterBlock {
867        Self::PTR
868    }
869    #[doc = r" Steal an instance of this peripheral"]
870    #[doc = r""]
871    #[doc = r" # Safety"]
872    #[doc = r""]
873    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
874    #[doc = r" that may race with any existing instances, for example by only"]
875    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
876    #[doc = r" original peripheral and using critical sections to coordinate"]
877    #[doc = r" access between multiple new instances."]
878    #[doc = r""]
879    #[doc = r" Additionally, other software such as HALs may rely on only one"]
880    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
881    #[doc = r" no stolen instances are passed to such software."]
882    pub unsafe fn steal() -> Self {
883        Self {
884            _marker: PhantomData,
885        }
886    }
887}
888impl Deref for RSTC {
889    type Target = rstc::RegisterBlock;
890    #[inline(always)]
891    fn deref(&self) -> &Self::Target {
892        unsafe { &*Self::PTR }
893    }
894}
895impl core::fmt::Debug for RSTC {
896    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
897        f.debug_struct("RSTC").finish()
898    }
899}
900#[doc = "Reset Controller"]
901pub mod rstc;
902#[doc = "Supply Controller"]
903pub struct SUPC {
904    _marker: PhantomData<*const ()>,
905}
906unsafe impl Send for SUPC {}
907impl SUPC {
908    #[doc = r"Pointer to the register block"]
909    pub const PTR: *const supc::RegisterBlock = 0x400e_1410 as *const _;
910    #[doc = r"Return the pointer to the register block"]
911    #[inline(always)]
912    pub const fn ptr() -> *const supc::RegisterBlock {
913        Self::PTR
914    }
915    #[doc = r" Steal an instance of this peripheral"]
916    #[doc = r""]
917    #[doc = r" # Safety"]
918    #[doc = r""]
919    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
920    #[doc = r" that may race with any existing instances, for example by only"]
921    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
922    #[doc = r" original peripheral and using critical sections to coordinate"]
923    #[doc = r" access between multiple new instances."]
924    #[doc = r""]
925    #[doc = r" Additionally, other software such as HALs may rely on only one"]
926    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
927    #[doc = r" no stolen instances are passed to such software."]
928    pub unsafe fn steal() -> Self {
929        Self {
930            _marker: PhantomData,
931        }
932    }
933}
934impl Deref for SUPC {
935    type Target = supc::RegisterBlock;
936    #[inline(always)]
937    fn deref(&self) -> &Self::Target {
938        unsafe { &*Self::PTR }
939    }
940}
941impl core::fmt::Debug for SUPC {
942    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
943        f.debug_struct("SUPC").finish()
944    }
945}
946#[doc = "Supply Controller"]
947pub mod supc;
948#[doc = "Real-time Timer"]
949pub struct RTT {
950    _marker: PhantomData<*const ()>,
951}
952unsafe impl Send for RTT {}
953impl RTT {
954    #[doc = r"Pointer to the register block"]
955    pub const PTR: *const rtt::RegisterBlock = 0x400e_1430 as *const _;
956    #[doc = r"Return the pointer to the register block"]
957    #[inline(always)]
958    pub const fn ptr() -> *const rtt::RegisterBlock {
959        Self::PTR
960    }
961    #[doc = r" Steal an instance of this peripheral"]
962    #[doc = r""]
963    #[doc = r" # Safety"]
964    #[doc = r""]
965    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
966    #[doc = r" that may race with any existing instances, for example by only"]
967    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
968    #[doc = r" original peripheral and using critical sections to coordinate"]
969    #[doc = r" access between multiple new instances."]
970    #[doc = r""]
971    #[doc = r" Additionally, other software such as HALs may rely on only one"]
972    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
973    #[doc = r" no stolen instances are passed to such software."]
974    pub unsafe fn steal() -> Self {
975        Self {
976            _marker: PhantomData,
977        }
978    }
979}
980impl Deref for RTT {
981    type Target = rtt::RegisterBlock;
982    #[inline(always)]
983    fn deref(&self) -> &Self::Target {
984        unsafe { &*Self::PTR }
985    }
986}
987impl core::fmt::Debug for RTT {
988    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
989        f.debug_struct("RTT").finish()
990    }
991}
992#[doc = "Real-time Timer"]
993pub mod rtt;
994#[doc = "Watchdog Timer"]
995pub struct WDT {
996    _marker: PhantomData<*const ()>,
997}
998unsafe impl Send for WDT {}
999impl WDT {
1000    #[doc = r"Pointer to the register block"]
1001    pub const PTR: *const wdt::RegisterBlock = 0x400e_1450 as *const _;
1002    #[doc = r"Return the pointer to the register block"]
1003    #[inline(always)]
1004    pub const fn ptr() -> *const wdt::RegisterBlock {
1005        Self::PTR
1006    }
1007    #[doc = r" Steal an instance of this peripheral"]
1008    #[doc = r""]
1009    #[doc = r" # Safety"]
1010    #[doc = r""]
1011    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1012    #[doc = r" that may race with any existing instances, for example by only"]
1013    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1014    #[doc = r" original peripheral and using critical sections to coordinate"]
1015    #[doc = r" access between multiple new instances."]
1016    #[doc = r""]
1017    #[doc = r" Additionally, other software such as HALs may rely on only one"]
1018    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1019    #[doc = r" no stolen instances are passed to such software."]
1020    pub unsafe fn steal() -> Self {
1021        Self {
1022            _marker: PhantomData,
1023        }
1024    }
1025}
1026impl Deref for WDT {
1027    type Target = wdt::RegisterBlock;
1028    #[inline(always)]
1029    fn deref(&self) -> &Self::Target {
1030        unsafe { &*Self::PTR }
1031    }
1032}
1033impl core::fmt::Debug for WDT {
1034    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1035        f.debug_struct("WDT").finish()
1036    }
1037}
1038#[doc = "Watchdog Timer"]
1039pub mod wdt;
1040#[doc = "Real-time Clock"]
1041pub struct RTC {
1042    _marker: PhantomData<*const ()>,
1043}
1044unsafe impl Send for RTC {}
1045impl RTC {
1046    #[doc = r"Pointer to the register block"]
1047    pub const PTR: *const rtc::RegisterBlock = 0x400e_1460 as *const _;
1048    #[doc = r"Return the pointer to the register block"]
1049    #[inline(always)]
1050    pub const fn ptr() -> *const rtc::RegisterBlock {
1051        Self::PTR
1052    }
1053    #[doc = r" Steal an instance of this peripheral"]
1054    #[doc = r""]
1055    #[doc = r" # Safety"]
1056    #[doc = r""]
1057    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1058    #[doc = r" that may race with any existing instances, for example by only"]
1059    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1060    #[doc = r" original peripheral and using critical sections to coordinate"]
1061    #[doc = r" access between multiple new instances."]
1062    #[doc = r""]
1063    #[doc = r" Additionally, other software such as HALs may rely on only one"]
1064    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1065    #[doc = r" no stolen instances are passed to such software."]
1066    pub unsafe fn steal() -> Self {
1067        Self {
1068            _marker: PhantomData,
1069        }
1070    }
1071}
1072impl Deref for RTC {
1073    type Target = rtc::RegisterBlock;
1074    #[inline(always)]
1075    fn deref(&self) -> &Self::Target {
1076        unsafe { &*Self::PTR }
1077    }
1078}
1079impl core::fmt::Debug for RTC {
1080    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1081        f.debug_struct("RTC").finish()
1082    }
1083}
1084#[doc = "Real-time Clock"]
1085pub mod rtc;
1086#[doc = "General Purpose Backup Registers"]
1087pub struct GPBR {
1088    _marker: PhantomData<*const ()>,
1089}
1090unsafe impl Send for GPBR {}
1091impl GPBR {
1092    #[doc = r"Pointer to the register block"]
1093    pub const PTR: *const gpbr::RegisterBlock = 0x400e_1490 as *const _;
1094    #[doc = r"Return the pointer to the register block"]
1095    #[inline(always)]
1096    pub const fn ptr() -> *const gpbr::RegisterBlock {
1097        Self::PTR
1098    }
1099    #[doc = r" Steal an instance of this peripheral"]
1100    #[doc = r""]
1101    #[doc = r" # Safety"]
1102    #[doc = r""]
1103    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1104    #[doc = r" that may race with any existing instances, for example by only"]
1105    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1106    #[doc = r" original peripheral and using critical sections to coordinate"]
1107    #[doc = r" access between multiple new instances."]
1108    #[doc = r""]
1109    #[doc = r" Additionally, other software such as HALs may rely on only one"]
1110    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1111    #[doc = r" no stolen instances are passed to such software."]
1112    pub unsafe fn steal() -> Self {
1113        Self {
1114            _marker: PhantomData,
1115        }
1116    }
1117}
1118impl Deref for GPBR {
1119    type Target = gpbr::RegisterBlock;
1120    #[inline(always)]
1121    fn deref(&self) -> &Self::Target {
1122        unsafe { &*Self::PTR }
1123    }
1124}
1125impl core::fmt::Debug for GPBR {
1126    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1127        f.debug_struct("GPBR").finish()
1128    }
1129}
1130#[doc = "General Purpose Backup Registers"]
1131pub mod gpbr;
1132#[no_mangle]
1133static mut DEVICE_PERIPHERALS: bool = false;
1134#[doc = r" All the peripherals."]
1135#[allow(non_snake_case)]
1136pub struct Peripherals {
1137    #[doc = "SPI"]
1138    pub SPI: SPI,
1139    #[doc = "TC0"]
1140    pub TC0: TC0,
1141    #[doc = "TWI0"]
1142    pub TWI0: TWI0,
1143    #[doc = "TWI1"]
1144    pub TWI1: TWI1,
1145    #[doc = "PWM"]
1146    pub PWM: PWM,
1147    #[doc = "USART0"]
1148    pub USART0: USART0,
1149    #[doc = "ADC"]
1150    pub ADC: ADC,
1151    #[doc = "DACC"]
1152    pub DACC: DACC,
1153    #[doc = "MATRIX"]
1154    pub MATRIX: MATRIX,
1155    #[doc = "PMC"]
1156    pub PMC: PMC,
1157    #[doc = "UART0"]
1158    pub UART0: UART0,
1159    #[doc = "CHIPID"]
1160    pub CHIPID: CHIPID,
1161    #[doc = "UART1"]
1162    pub UART1: UART1,
1163    #[doc = "EFC"]
1164    pub EFC: EFC,
1165    #[doc = "PIOA"]
1166    pub PIOA: PIOA,
1167    #[doc = "PIOB"]
1168    pub PIOB: PIOB,
1169    #[doc = "RSTC"]
1170    pub RSTC: RSTC,
1171    #[doc = "SUPC"]
1172    pub SUPC: SUPC,
1173    #[doc = "RTT"]
1174    pub RTT: RTT,
1175    #[doc = "WDT"]
1176    pub WDT: WDT,
1177    #[doc = "RTC"]
1178    pub RTC: RTC,
1179    #[doc = "GPBR"]
1180    pub GPBR: GPBR,
1181}
1182impl Peripherals {
1183    #[doc = r" Returns all the peripherals *once*."]
1184    #[cfg(feature = "critical-section")]
1185    #[inline]
1186    pub fn take() -> Option<Self> {
1187        critical_section::with(|_| {
1188            if unsafe { DEVICE_PERIPHERALS } {
1189                return None;
1190            }
1191            Some(unsafe { Peripherals::steal() })
1192        })
1193    }
1194    #[doc = r" Unchecked version of `Peripherals::take`."]
1195    #[doc = r""]
1196    #[doc = r" # Safety"]
1197    #[doc = r""]
1198    #[doc = r" Each of the returned peripherals must be used at most once."]
1199    #[inline]
1200    pub unsafe fn steal() -> Self {
1201        DEVICE_PERIPHERALS = true;
1202        Peripherals {
1203            SPI: SPI {
1204                _marker: PhantomData,
1205            },
1206            TC0: TC0 {
1207                _marker: PhantomData,
1208            },
1209            TWI0: TWI0 {
1210                _marker: PhantomData,
1211            },
1212            TWI1: TWI1 {
1213                _marker: PhantomData,
1214            },
1215            PWM: PWM {
1216                _marker: PhantomData,
1217            },
1218            USART0: USART0 {
1219                _marker: PhantomData,
1220            },
1221            ADC: ADC {
1222                _marker: PhantomData,
1223            },
1224            DACC: DACC {
1225                _marker: PhantomData,
1226            },
1227            MATRIX: MATRIX {
1228                _marker: PhantomData,
1229            },
1230            PMC: PMC {
1231                _marker: PhantomData,
1232            },
1233            UART0: UART0 {
1234                _marker: PhantomData,
1235            },
1236            CHIPID: CHIPID {
1237                _marker: PhantomData,
1238            },
1239            UART1: UART1 {
1240                _marker: PhantomData,
1241            },
1242            EFC: EFC {
1243                _marker: PhantomData,
1244            },
1245            PIOA: PIOA {
1246                _marker: PhantomData,
1247            },
1248            PIOB: PIOB {
1249                _marker: PhantomData,
1250            },
1251            RSTC: RSTC {
1252                _marker: PhantomData,
1253            },
1254            SUPC: SUPC {
1255                _marker: PhantomData,
1256            },
1257            RTT: RTT {
1258                _marker: PhantomData,
1259            },
1260            WDT: WDT {
1261                _marker: PhantomData,
1262            },
1263            RTC: RTC {
1264                _marker: PhantomData,
1265            },
1266            GPBR: GPBR {
1267                _marker: PhantomData,
1268            },
1269        }
1270    }
1271}
atsam3n2a/lib.rs

atsam3n2a/
lib.rs
