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