moondancer_pac/
generated.rs

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

moondancer_pac/
generated.rs
