1#![doc = "Peripheral access API for XMC4200 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"]
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 = 6;
10#[allow(unused_imports)]
11use generic::*;
12#[doc = r"Common register and bit access and modify traits"]
13pub mod generic;
14#[cfg(feature = "rt")]
15extern "C" {
16 fn SCU_0();
17 fn ERU0_0();
18 fn ERU0_1();
19 fn ERU0_2();
20 fn ERU0_3();
21 fn ERU1_0();
22 fn ERU1_1();
23 fn ERU1_2();
24 fn ERU1_3();
25 fn PMU0_0();
26 fn VADC0_C0_0();
27 fn VADC0_C0_1();
28 fn VADC0_C0_2();
29 fn VADC0_C0_3();
30 fn VADC0_G0_0();
31 fn VADC0_G0_1();
32 fn VADC0_G0_2();
33 fn VADC0_G0_3();
34 fn VADC0_G1_0();
35 fn VADC0_G1_1();
36 fn VADC0_G1_2();
37 fn VADC0_G1_3();
38 fn DAC0_0();
39 fn DAC0_1();
40 fn CCU40_0();
41 fn CCU40_1();
42 fn CCU40_2();
43 fn CCU40_3();
44 fn CCU41_0();
45 fn CCU41_1();
46 fn CCU41_2();
47 fn CCU41_3();
48 fn CCU80_0();
49 fn CCU80_1();
50 fn CCU80_2();
51 fn CCU80_3();
52 fn POSIF0_0();
53 fn POSIF0_1();
54 fn HRPWM_0();
55 fn HRPWM_1();
56 fn HRPWM_2();
57 fn HRPWM_3();
58 fn CAN0_0();
59 fn CAN0_1();
60 fn CAN0_2();
61 fn CAN0_3();
62 fn CAN0_4();
63 fn CAN0_5();
64 fn CAN0_6();
65 fn CAN0_7();
66 fn USIC0_0();
67 fn USIC0_1();
68 fn USIC0_2();
69 fn USIC0_3();
70 fn USIC0_4();
71 fn USIC0_5();
72 fn USIC1_0();
73 fn USIC1_1();
74 fn USIC1_2();
75 fn USIC1_3();
76 fn USIC1_4();
77 fn USIC1_5();
78 fn LEDTS0_0();
79 fn FCE0_0();
80 fn GPDMA0_0();
81 fn USB0_0();
82}
83#[doc(hidden)]
84#[repr(C)]
85pub union Vector {
86 _handler: unsafe extern "C" fn(),
87 _reserved: u32,
88}
89#[cfg(feature = "rt")]
90#[doc(hidden)]
91#[link_section = ".vector_table.interrupts"]
92#[no_mangle]
93pub static __INTERRUPTS: [Vector; 108] = [
94 Vector { _handler: SCU_0 },
95 Vector { _handler: ERU0_0 },
96 Vector { _handler: ERU0_1 },
97 Vector { _handler: ERU0_2 },
98 Vector { _handler: ERU0_3 },
99 Vector { _handler: ERU1_0 },
100 Vector { _handler: ERU1_1 },
101 Vector { _handler: ERU1_2 },
102 Vector { _handler: ERU1_3 },
103 Vector { _reserved: 0 },
104 Vector { _reserved: 0 },
105 Vector { _reserved: 0 },
106 Vector { _handler: PMU0_0 },
107 Vector { _reserved: 0 },
108 Vector { _handler: VADC0_C0_0 },
109 Vector { _handler: VADC0_C0_1 },
110 Vector { _handler: VADC0_C0_2 },
111 Vector { _handler: VADC0_C0_3 },
112 Vector { _handler: VADC0_G0_0 },
113 Vector { _handler: VADC0_G0_1 },
114 Vector { _handler: VADC0_G0_2 },
115 Vector { _handler: VADC0_G0_3 },
116 Vector { _handler: VADC0_G1_0 },
117 Vector { _handler: VADC0_G1_1 },
118 Vector { _handler: VADC0_G1_2 },
119 Vector { _handler: VADC0_G1_3 },
120 Vector { _reserved: 0 },
121 Vector { _reserved: 0 },
122 Vector { _reserved: 0 },
123 Vector { _reserved: 0 },
124 Vector { _reserved: 0 },
125 Vector { _reserved: 0 },
126 Vector { _reserved: 0 },
127 Vector { _reserved: 0 },
128 Vector { _reserved: 0 },
129 Vector { _reserved: 0 },
130 Vector { _reserved: 0 },
131 Vector { _reserved: 0 },
132 Vector { _reserved: 0 },
133 Vector { _reserved: 0 },
134 Vector { _reserved: 0 },
135 Vector { _reserved: 0 },
136 Vector { _handler: DAC0_0 },
137 Vector { _handler: DAC0_1 },
138 Vector { _handler: CCU40_0 },
139 Vector { _handler: CCU40_1 },
140 Vector { _handler: CCU40_2 },
141 Vector { _handler: CCU40_3 },
142 Vector { _handler: CCU41_0 },
143 Vector { _handler: CCU41_1 },
144 Vector { _handler: CCU41_2 },
145 Vector { _handler: CCU41_3 },
146 Vector { _reserved: 0 },
147 Vector { _reserved: 0 },
148 Vector { _reserved: 0 },
149 Vector { _reserved: 0 },
150 Vector { _reserved: 0 },
151 Vector { _reserved: 0 },
152 Vector { _reserved: 0 },
153 Vector { _reserved: 0 },
154 Vector { _handler: CCU80_0 },
155 Vector { _handler: CCU80_1 },
156 Vector { _handler: CCU80_2 },
157 Vector { _handler: CCU80_3 },
158 Vector { _reserved: 0 },
159 Vector { _reserved: 0 },
160 Vector { _reserved: 0 },
161 Vector { _reserved: 0 },
162 Vector { _handler: POSIF0_0 },
163 Vector { _handler: POSIF0_1 },
164 Vector { _reserved: 0 },
165 Vector { _reserved: 0 },
166 Vector { _handler: HRPWM_0 },
167 Vector { _handler: HRPWM_1 },
168 Vector { _handler: HRPWM_2 },
169 Vector { _handler: HRPWM_3 },
170 Vector { _handler: CAN0_0 },
171 Vector { _handler: CAN0_1 },
172 Vector { _handler: CAN0_2 },
173 Vector { _handler: CAN0_3 },
174 Vector { _handler: CAN0_4 },
175 Vector { _handler: CAN0_5 },
176 Vector { _handler: CAN0_6 },
177 Vector { _handler: CAN0_7 },
178 Vector { _handler: USIC0_0 },
179 Vector { _handler: USIC0_1 },
180 Vector { _handler: USIC0_2 },
181 Vector { _handler: USIC0_3 },
182 Vector { _handler: USIC0_4 },
183 Vector { _handler: USIC0_5 },
184 Vector { _handler: USIC1_0 },
185 Vector { _handler: USIC1_1 },
186 Vector { _handler: USIC1_2 },
187 Vector { _handler: USIC1_3 },
188 Vector { _handler: USIC1_4 },
189 Vector { _handler: USIC1_5 },
190 Vector { _reserved: 0 },
191 Vector { _reserved: 0 },
192 Vector { _reserved: 0 },
193 Vector { _reserved: 0 },
194 Vector { _reserved: 0 },
195 Vector { _reserved: 0 },
196 Vector { _handler: LEDTS0_0 },
197 Vector { _reserved: 0 },
198 Vector { _handler: FCE0_0 },
199 Vector { _handler: GPDMA0_0 },
200 Vector { _reserved: 0 },
201 Vector { _handler: USB0_0 },
202];
203#[doc = r"Enumeration of all the interrupts."]
204#[derive(Copy, Clone, Debug, PartialEq, Eq)]
205#[repr(u16)]
206pub enum Interrupt {
207 #[doc = "0 - System Control"]
208 SCU_0 = 0,
209 #[doc = "1 - External Request Unit 0"]
210 ERU0_0 = 1,
211 #[doc = "2 - External Request Unit 0"]
212 ERU0_1 = 2,
213 #[doc = "3 - External Request Unit 0"]
214 ERU0_2 = 3,
215 #[doc = "4 - External Request Unit 0"]
216 ERU0_3 = 4,
217 #[doc = "5 - External Request Unit 1"]
218 ERU1_0 = 5,
219 #[doc = "6 - External Request Unit 1"]
220 ERU1_1 = 6,
221 #[doc = "7 - External Request Unit 1"]
222 ERU1_2 = 7,
223 #[doc = "8 - External Request Unit 1"]
224 ERU1_3 = 8,
225 #[doc = "12 - Program Management Unit"]
226 PMU0_0 = 12,
227 #[doc = "14 - Analog to Digital Converter Common Block 0"]
228 VADC0_C0_0 = 14,
229 #[doc = "15 - Analog to Digital Converter Common Block 0"]
230 VADC0_C0_1 = 15,
231 #[doc = "16 - Analog to Digital Converter Common Block 0"]
232 VADC0_C0_2 = 16,
233 #[doc = "17 - Analog to Digital Converter Common Block 0"]
234 VADC0_C0_3 = 17,
235 #[doc = "18 - Analog to Digital Converter Group 0"]
236 VADC0_G0_0 = 18,
237 #[doc = "19 - Analog to Digital Converter Group 0"]
238 VADC0_G0_1 = 19,
239 #[doc = "20 - Analog to Digital Converter Group 0"]
240 VADC0_G0_2 = 20,
241 #[doc = "21 - Analog to Digital Converter Group 0"]
242 VADC0_G0_3 = 21,
243 #[doc = "22 - Analog to Digital Converter Group 1"]
244 VADC0_G1_0 = 22,
245 #[doc = "23 - Analog to Digital Converter Group 1"]
246 VADC0_G1_1 = 23,
247 #[doc = "24 - Analog to Digital Converter Group 1"]
248 VADC0_G1_2 = 24,
249 #[doc = "25 - Analog to Digital Converter Group 1"]
250 VADC0_G1_3 = 25,
251 #[doc = "42 - Digital to Analog Converter"]
252 DAC0_0 = 42,
253 #[doc = "43 - Digital to Analog Converter"]
254 DAC0_1 = 43,
255 #[doc = "44 - Capture Compare Unit 4 (Module 0)"]
256 CCU40_0 = 44,
257 #[doc = "45 - Capture Compare Unit 4 (Module 0)"]
258 CCU40_1 = 45,
259 #[doc = "46 - Capture Compare Unit 4 (Module 0)"]
260 CCU40_2 = 46,
261 #[doc = "47 - Capture Compare Unit 4 (Module 0)"]
262 CCU40_3 = 47,
263 #[doc = "48 - Capture Compare Unit 4 (Module 1)"]
264 CCU41_0 = 48,
265 #[doc = "49 - Capture Compare Unit 4 (Module 1)"]
266 CCU41_1 = 49,
267 #[doc = "50 - Capture Compare Unit 4 (Module 1)"]
268 CCU41_2 = 50,
269 #[doc = "51 - Capture Compare Unit 4 (Module 1)"]
270 CCU41_3 = 51,
271 #[doc = "60 - Capture Compare Unit 8 (Module 0)"]
272 CCU80_0 = 60,
273 #[doc = "61 - Capture Compare Unit 8 (Module 0)"]
274 CCU80_1 = 61,
275 #[doc = "62 - Capture Compare Unit 8 (Module 0)"]
276 CCU80_2 = 62,
277 #[doc = "63 - Capture Compare Unit 8 (Module 0)"]
278 CCU80_3 = 63,
279 #[doc = "68 - Position Interface (Module 0)"]
280 POSIF0_0 = 68,
281 #[doc = "69 - Position Interface (Module 0)"]
282 POSIF0_1 = 69,
283 #[doc = "72 - High Resolution Pulse Width Modulation (Module 0)"]
284 HRPWM_0 = 72,
285 #[doc = "73 - High Resolution Pulse Width Modulation (Module 0)"]
286 HRPWM_1 = 73,
287 #[doc = "74 - High Resolution Pulse Width Modulation (Module 0)"]
288 HRPWM_2 = 74,
289 #[doc = "75 - High Resolution Pulse Width Modulation (Module 0)"]
290 HRPWM_3 = 75,
291 #[doc = "76 - MultiCAN"]
292 CAN0_0 = 76,
293 #[doc = "77 - MultiCAN"]
294 CAN0_1 = 77,
295 #[doc = "78 - MultiCAN"]
296 CAN0_2 = 78,
297 #[doc = "79 - MultiCAN"]
298 CAN0_3 = 79,
299 #[doc = "80 - MultiCAN"]
300 CAN0_4 = 80,
301 #[doc = "81 - MultiCAN"]
302 CAN0_5 = 81,
303 #[doc = "82 - MultiCAN"]
304 CAN0_6 = 82,
305 #[doc = "83 - MultiCAN"]
306 CAN0_7 = 83,
307 #[doc = "84 - Universal Serial Interface Channel (Module 0)"]
308 USIC0_0 = 84,
309 #[doc = "85 - Universal Serial Interface Channel (Module 0)"]
310 USIC0_1 = 85,
311 #[doc = "86 - Universal Serial Interface Channel (Module 0)"]
312 USIC0_2 = 86,
313 #[doc = "87 - Universal Serial Interface Channel (Module 0)"]
314 USIC0_3 = 87,
315 #[doc = "88 - Universal Serial Interface Channel (Module 0)"]
316 USIC0_4 = 88,
317 #[doc = "89 - Universal Serial Interface Channel (Module 0)"]
318 USIC0_5 = 89,
319 #[doc = "90 - Universal Serial Interface Channel (Module 1)"]
320 USIC1_0 = 90,
321 #[doc = "91 - Universal Serial Interface Channel (Module 1)"]
322 USIC1_1 = 91,
323 #[doc = "92 - Universal Serial Interface Channel (Module 1)"]
324 USIC1_2 = 92,
325 #[doc = "93 - Universal Serial Interface Channel (Module 1)"]
326 USIC1_3 = 93,
327 #[doc = "94 - Universal Serial Interface Channel (Module 1)"]
328 USIC1_4 = 94,
329 #[doc = "95 - Universal Serial Interface Channel (Module 1)"]
330 USIC1_5 = 95,
331 #[doc = "102 - LED and Touch Sense Control Unit (Module 0)"]
332 LEDTS0_0 = 102,
333 #[doc = "104 - Flexible CRC Engine"]
334 FCE0_0 = 104,
335 #[doc = "105 - General Purpose DMA Unit 0"]
336 GPDMA0_0 = 105,
337 #[doc = "107 - Universal Serial Bus (Module 0)"]
338 USB0_0 = 107,
339}
340unsafe impl cortex_m::interrupt::InterruptNumber for Interrupt {
341 #[inline(always)]
342 fn number(self) -> u16 {
343 self as u16
344 }
345}
346#[doc = "Cortex-M4 Private Peripheral Block"]
347pub struct PPB {
348 _marker: PhantomData<*const ()>,
349}
350unsafe impl Send for PPB {}
351impl PPB {
352 #[doc = r"Pointer to the register block"]
353 pub const PTR: *const ppb::RegisterBlock = 0xe000_e000 as *const _;
354 #[doc = r"Return the pointer to the register block"]
355 #[inline(always)]
356 pub const fn ptr() -> *const ppb::RegisterBlock {
357 Self::PTR
358 }
359 #[doc = r" Steal an instance of this peripheral"]
360 #[doc = r""]
361 #[doc = r" # Safety"]
362 #[doc = r""]
363 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
364 #[doc = r" that may race with any existing instances, for example by only"]
365 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
366 #[doc = r" original peripheral and using critical sections to coordinate"]
367 #[doc = r" access between multiple new instances."]
368 #[doc = r""]
369 #[doc = r" Additionally, other software such as HALs may rely on only one"]
370 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
371 #[doc = r" no stolen instances are passed to such software."]
372 pub unsafe fn steal() -> Self {
373 Self { _marker: PhantomData }
374 }
375}
376impl Deref for PPB {
377 type Target = ppb::RegisterBlock;
378 #[inline(always)]
379 fn deref(&self) -> &Self::Target {
380 unsafe { &*Self::PTR }
381 }
382}
383impl core::fmt::Debug for PPB {
384 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
385 f.debug_struct("PPB").finish()
386 }
387}
388#[doc = "Cortex-M4 Private Peripheral Block"]
389pub mod ppb;
390#[doc = "DMA Line Router"]
391pub struct DLR {
392 _marker: PhantomData<*const ()>,
393}
394unsafe impl Send for DLR {}
395impl DLR {
396 #[doc = r"Pointer to the register block"]
397 pub const PTR: *const dlr::RegisterBlock = 0x5000_4900 as *const _;
398 #[doc = r"Return the pointer to the register block"]
399 #[inline(always)]
400 pub const fn ptr() -> *const dlr::RegisterBlock {
401 Self::PTR
402 }
403 #[doc = r" Steal an instance of this peripheral"]
404 #[doc = r""]
405 #[doc = r" # Safety"]
406 #[doc = r""]
407 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
408 #[doc = r" that may race with any existing instances, for example by only"]
409 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
410 #[doc = r" original peripheral and using critical sections to coordinate"]
411 #[doc = r" access between multiple new instances."]
412 #[doc = r""]
413 #[doc = r" Additionally, other software such as HALs may rely on only one"]
414 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
415 #[doc = r" no stolen instances are passed to such software."]
416 pub unsafe fn steal() -> Self {
417 Self { _marker: PhantomData }
418 }
419}
420impl Deref for DLR {
421 type Target = dlr::RegisterBlock;
422 #[inline(always)]
423 fn deref(&self) -> &Self::Target {
424 unsafe { &*Self::PTR }
425 }
426}
427impl core::fmt::Debug for DLR {
428 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
429 f.debug_struct("DLR").finish()
430 }
431}
432#[doc = "DMA Line Router"]
433pub mod dlr;
434#[doc = "Event Request Unit 0"]
435pub struct ERU0 {
436 _marker: PhantomData<*const ()>,
437}
438unsafe impl Send for ERU0 {}
439impl ERU0 {
440 #[doc = r"Pointer to the register block"]
441 pub const PTR: *const eru0::RegisterBlock = 0x5000_4800 as *const _;
442 #[doc = r"Return the pointer to the register block"]
443 #[inline(always)]
444 pub const fn ptr() -> *const eru0::RegisterBlock {
445 Self::PTR
446 }
447 #[doc = r" Steal an instance of this peripheral"]
448 #[doc = r""]
449 #[doc = r" # Safety"]
450 #[doc = r""]
451 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
452 #[doc = r" that may race with any existing instances, for example by only"]
453 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
454 #[doc = r" original peripheral and using critical sections to coordinate"]
455 #[doc = r" access between multiple new instances."]
456 #[doc = r""]
457 #[doc = r" Additionally, other software such as HALs may rely on only one"]
458 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
459 #[doc = r" no stolen instances are passed to such software."]
460 pub unsafe fn steal() -> Self {
461 Self { _marker: PhantomData }
462 }
463}
464impl Deref for ERU0 {
465 type Target = eru0::RegisterBlock;
466 #[inline(always)]
467 fn deref(&self) -> &Self::Target {
468 unsafe { &*Self::PTR }
469 }
470}
471impl core::fmt::Debug for ERU0 {
472 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
473 f.debug_struct("ERU0").finish()
474 }
475}
476#[doc = "Event Request Unit 0"]
477pub mod eru0;
478#[doc = "Event Request Unit 1"]
479pub struct ERU1 {
480 _marker: PhantomData<*const ()>,
481}
482unsafe impl Send for ERU1 {}
483impl ERU1 {
484 #[doc = r"Pointer to the register block"]
485 pub const PTR: *const eru0::RegisterBlock = 0x4004_4000 as *const _;
486 #[doc = r"Return the pointer to the register block"]
487 #[inline(always)]
488 pub const fn ptr() -> *const eru0::RegisterBlock {
489 Self::PTR
490 }
491 #[doc = r" Steal an instance of this peripheral"]
492 #[doc = r""]
493 #[doc = r" # Safety"]
494 #[doc = r""]
495 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
496 #[doc = r" that may race with any existing instances, for example by only"]
497 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
498 #[doc = r" original peripheral and using critical sections to coordinate"]
499 #[doc = r" access between multiple new instances."]
500 #[doc = r""]
501 #[doc = r" Additionally, other software such as HALs may rely on only one"]
502 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
503 #[doc = r" no stolen instances are passed to such software."]
504 pub unsafe fn steal() -> Self {
505 Self { _marker: PhantomData }
506 }
507}
508impl Deref for ERU1 {
509 type Target = eru0::RegisterBlock;
510 #[inline(always)]
511 fn deref(&self) -> &Self::Target {
512 unsafe { &*Self::PTR }
513 }
514}
515impl core::fmt::Debug for ERU1 {
516 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
517 f.debug_struct("ERU1").finish()
518 }
519}
520#[doc = "Event Request Unit 1"]
521pub use self::eru0 as eru1;
522#[doc = "General Purpose DMA Unit 0"]
523pub struct GPDMA0 {
524 _marker: PhantomData<*const ()>,
525}
526unsafe impl Send for GPDMA0 {}
527impl GPDMA0 {
528 #[doc = r"Pointer to the register block"]
529 pub const PTR: *const gpdma0::RegisterBlock = 0x5001_42c0 as *const _;
530 #[doc = r"Return the pointer to the register block"]
531 #[inline(always)]
532 pub const fn ptr() -> *const gpdma0::RegisterBlock {
533 Self::PTR
534 }
535 #[doc = r" Steal an instance of this peripheral"]
536 #[doc = r""]
537 #[doc = r" # Safety"]
538 #[doc = r""]
539 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
540 #[doc = r" that may race with any existing instances, for example by only"]
541 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
542 #[doc = r" original peripheral and using critical sections to coordinate"]
543 #[doc = r" access between multiple new instances."]
544 #[doc = r""]
545 #[doc = r" Additionally, other software such as HALs may rely on only one"]
546 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
547 #[doc = r" no stolen instances are passed to such software."]
548 pub unsafe fn steal() -> Self {
549 Self { _marker: PhantomData }
550 }
551}
552impl Deref for GPDMA0 {
553 type Target = gpdma0::RegisterBlock;
554 #[inline(always)]
555 fn deref(&self) -> &Self::Target {
556 unsafe { &*Self::PTR }
557 }
558}
559impl core::fmt::Debug for GPDMA0 {
560 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
561 f.debug_struct("GPDMA0").finish()
562 }
563}
564#[doc = "General Purpose DMA Unit 0"]
565pub mod gpdma0;
566#[doc = "General Purpose DMA Unit 0"]
567pub struct GPDMA0_CH0 {
568 _marker: PhantomData<*const ()>,
569}
570unsafe impl Send for GPDMA0_CH0 {}
571impl GPDMA0_CH0 {
572 #[doc = r"Pointer to the register block"]
573 pub const PTR: *const gpdma0_ch0::RegisterBlock = 0x5001_4000 as *const _;
574 #[doc = r"Return the pointer to the register block"]
575 #[inline(always)]
576 pub const fn ptr() -> *const gpdma0_ch0::RegisterBlock {
577 Self::PTR
578 }
579 #[doc = r" Steal an instance of this peripheral"]
580 #[doc = r""]
581 #[doc = r" # Safety"]
582 #[doc = r""]
583 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
584 #[doc = r" that may race with any existing instances, for example by only"]
585 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
586 #[doc = r" original peripheral and using critical sections to coordinate"]
587 #[doc = r" access between multiple new instances."]
588 #[doc = r""]
589 #[doc = r" Additionally, other software such as HALs may rely on only one"]
590 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
591 #[doc = r" no stolen instances are passed to such software."]
592 pub unsafe fn steal() -> Self {
593 Self { _marker: PhantomData }
594 }
595}
596impl Deref for GPDMA0_CH0 {
597 type Target = gpdma0_ch0::RegisterBlock;
598 #[inline(always)]
599 fn deref(&self) -> &Self::Target {
600 unsafe { &*Self::PTR }
601 }
602}
603impl core::fmt::Debug for GPDMA0_CH0 {
604 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
605 f.debug_struct("GPDMA0_CH0").finish()
606 }
607}
608#[doc = "General Purpose DMA Unit 0"]
609pub mod gpdma0_ch0;
610#[doc = "General Purpose DMA Unit 0"]
611pub struct GPDMA0_CH1 {
612 _marker: PhantomData<*const ()>,
613}
614unsafe impl Send for GPDMA0_CH1 {}
615impl GPDMA0_CH1 {
616 #[doc = r"Pointer to the register block"]
617 pub const PTR: *const gpdma0_ch0::RegisterBlock = 0x5001_4058 as *const _;
618 #[doc = r"Return the pointer to the register block"]
619 #[inline(always)]
620 pub const fn ptr() -> *const gpdma0_ch0::RegisterBlock {
621 Self::PTR
622 }
623 #[doc = r" Steal an instance of this peripheral"]
624 #[doc = r""]
625 #[doc = r" # Safety"]
626 #[doc = r""]
627 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
628 #[doc = r" that may race with any existing instances, for example by only"]
629 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
630 #[doc = r" original peripheral and using critical sections to coordinate"]
631 #[doc = r" access between multiple new instances."]
632 #[doc = r""]
633 #[doc = r" Additionally, other software such as HALs may rely on only one"]
634 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
635 #[doc = r" no stolen instances are passed to such software."]
636 pub unsafe fn steal() -> Self {
637 Self { _marker: PhantomData }
638 }
639}
640impl Deref for GPDMA0_CH1 {
641 type Target = gpdma0_ch0::RegisterBlock;
642 #[inline(always)]
643 fn deref(&self) -> &Self::Target {
644 unsafe { &*Self::PTR }
645 }
646}
647impl core::fmt::Debug for GPDMA0_CH1 {
648 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
649 f.debug_struct("GPDMA0_CH1").finish()
650 }
651}
652#[doc = "General Purpose DMA Unit 0"]
653pub use self::gpdma0_ch0 as gpdma0_ch1;
654#[doc = "General Purpose DMA Unit 0"]
655pub struct GPDMA0_CH2 {
656 _marker: PhantomData<*const ()>,
657}
658unsafe impl Send for GPDMA0_CH2 {}
659impl GPDMA0_CH2 {
660 #[doc = r"Pointer to the register block"]
661 pub const PTR: *const gpdma0_ch2::RegisterBlock = 0x5001_40b0 as *const _;
662 #[doc = r"Return the pointer to the register block"]
663 #[inline(always)]
664 pub const fn ptr() -> *const gpdma0_ch2::RegisterBlock {
665 Self::PTR
666 }
667 #[doc = r" Steal an instance of this peripheral"]
668 #[doc = r""]
669 #[doc = r" # Safety"]
670 #[doc = r""]
671 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
672 #[doc = r" that may race with any existing instances, for example by only"]
673 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
674 #[doc = r" original peripheral and using critical sections to coordinate"]
675 #[doc = r" access between multiple new instances."]
676 #[doc = r""]
677 #[doc = r" Additionally, other software such as HALs may rely on only one"]
678 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
679 #[doc = r" no stolen instances are passed to such software."]
680 pub unsafe fn steal() -> Self {
681 Self { _marker: PhantomData }
682 }
683}
684impl Deref for GPDMA0_CH2 {
685 type Target = gpdma0_ch2::RegisterBlock;
686 #[inline(always)]
687 fn deref(&self) -> &Self::Target {
688 unsafe { &*Self::PTR }
689 }
690}
691impl core::fmt::Debug for GPDMA0_CH2 {
692 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
693 f.debug_struct("GPDMA0_CH2").finish()
694 }
695}
696#[doc = "General Purpose DMA Unit 0"]
697pub mod gpdma0_ch2;
698#[doc = "General Purpose DMA Unit 0"]
699pub struct GPDMA0_CH3 {
700 _marker: PhantomData<*const ()>,
701}
702unsafe impl Send for GPDMA0_CH3 {}
703impl GPDMA0_CH3 {
704 #[doc = r"Pointer to the register block"]
705 pub const PTR: *const gpdma0_ch2::RegisterBlock = 0x5001_4108 as *const _;
706 #[doc = r"Return the pointer to the register block"]
707 #[inline(always)]
708 pub const fn ptr() -> *const gpdma0_ch2::RegisterBlock {
709 Self::PTR
710 }
711 #[doc = r" Steal an instance of this peripheral"]
712 #[doc = r""]
713 #[doc = r" # Safety"]
714 #[doc = r""]
715 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
716 #[doc = r" that may race with any existing instances, for example by only"]
717 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
718 #[doc = r" original peripheral and using critical sections to coordinate"]
719 #[doc = r" access between multiple new instances."]
720 #[doc = r""]
721 #[doc = r" Additionally, other software such as HALs may rely on only one"]
722 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
723 #[doc = r" no stolen instances are passed to such software."]
724 pub unsafe fn steal() -> Self {
725 Self { _marker: PhantomData }
726 }
727}
728impl Deref for GPDMA0_CH3 {
729 type Target = gpdma0_ch2::RegisterBlock;
730 #[inline(always)]
731 fn deref(&self) -> &Self::Target {
732 unsafe { &*Self::PTR }
733 }
734}
735impl core::fmt::Debug for GPDMA0_CH3 {
736 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
737 f.debug_struct("GPDMA0_CH3").finish()
738 }
739}
740#[doc = "General Purpose DMA Unit 0"]
741pub use self::gpdma0_ch2 as gpdma0_ch3;
742#[doc = "General Purpose DMA Unit 0"]
743pub struct GPDMA0_CH4 {
744 _marker: PhantomData<*const ()>,
745}
746unsafe impl Send for GPDMA0_CH4 {}
747impl GPDMA0_CH4 {
748 #[doc = r"Pointer to the register block"]
749 pub const PTR: *const gpdma0_ch2::RegisterBlock = 0x5001_4160 as *const _;
750 #[doc = r"Return the pointer to the register block"]
751 #[inline(always)]
752 pub const fn ptr() -> *const gpdma0_ch2::RegisterBlock {
753 Self::PTR
754 }
755 #[doc = r" Steal an instance of this peripheral"]
756 #[doc = r""]
757 #[doc = r" # Safety"]
758 #[doc = r""]
759 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
760 #[doc = r" that may race with any existing instances, for example by only"]
761 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
762 #[doc = r" original peripheral and using critical sections to coordinate"]
763 #[doc = r" access between multiple new instances."]
764 #[doc = r""]
765 #[doc = r" Additionally, other software such as HALs may rely on only one"]
766 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
767 #[doc = r" no stolen instances are passed to such software."]
768 pub unsafe fn steal() -> Self {
769 Self { _marker: PhantomData }
770 }
771}
772impl Deref for GPDMA0_CH4 {
773 type Target = gpdma0_ch2::RegisterBlock;
774 #[inline(always)]
775 fn deref(&self) -> &Self::Target {
776 unsafe { &*Self::PTR }
777 }
778}
779impl core::fmt::Debug for GPDMA0_CH4 {
780 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
781 f.debug_struct("GPDMA0_CH4").finish()
782 }
783}
784#[doc = "General Purpose DMA Unit 0"]
785pub use self::gpdma0_ch2 as gpdma0_ch4;
786#[doc = "General Purpose DMA Unit 0"]
787pub struct GPDMA0_CH5 {
788 _marker: PhantomData<*const ()>,
789}
790unsafe impl Send for GPDMA0_CH5 {}
791impl GPDMA0_CH5 {
792 #[doc = r"Pointer to the register block"]
793 pub const PTR: *const gpdma0_ch2::RegisterBlock = 0x5001_41b8 as *const _;
794 #[doc = r"Return the pointer to the register block"]
795 #[inline(always)]
796 pub const fn ptr() -> *const gpdma0_ch2::RegisterBlock {
797 Self::PTR
798 }
799 #[doc = r" Steal an instance of this peripheral"]
800 #[doc = r""]
801 #[doc = r" # Safety"]
802 #[doc = r""]
803 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
804 #[doc = r" that may race with any existing instances, for example by only"]
805 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
806 #[doc = r" original peripheral and using critical sections to coordinate"]
807 #[doc = r" access between multiple new instances."]
808 #[doc = r""]
809 #[doc = r" Additionally, other software such as HALs may rely on only one"]
810 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
811 #[doc = r" no stolen instances are passed to such software."]
812 pub unsafe fn steal() -> Self {
813 Self { _marker: PhantomData }
814 }
815}
816impl Deref for GPDMA0_CH5 {
817 type Target = gpdma0_ch2::RegisterBlock;
818 #[inline(always)]
819 fn deref(&self) -> &Self::Target {
820 unsafe { &*Self::PTR }
821 }
822}
823impl core::fmt::Debug for GPDMA0_CH5 {
824 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
825 f.debug_struct("GPDMA0_CH5").finish()
826 }
827}
828#[doc = "General Purpose DMA Unit 0"]
829pub use self::gpdma0_ch2 as gpdma0_ch5;
830#[doc = "General Purpose DMA Unit 0"]
831pub struct GPDMA0_CH6 {
832 _marker: PhantomData<*const ()>,
833}
834unsafe impl Send for GPDMA0_CH6 {}
835impl GPDMA0_CH6 {
836 #[doc = r"Pointer to the register block"]
837 pub const PTR: *const gpdma0_ch2::RegisterBlock = 0x5001_4210 as *const _;
838 #[doc = r"Return the pointer to the register block"]
839 #[inline(always)]
840 pub const fn ptr() -> *const gpdma0_ch2::RegisterBlock {
841 Self::PTR
842 }
843 #[doc = r" Steal an instance of this peripheral"]
844 #[doc = r""]
845 #[doc = r" # Safety"]
846 #[doc = r""]
847 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
848 #[doc = r" that may race with any existing instances, for example by only"]
849 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
850 #[doc = r" original peripheral and using critical sections to coordinate"]
851 #[doc = r" access between multiple new instances."]
852 #[doc = r""]
853 #[doc = r" Additionally, other software such as HALs may rely on only one"]
854 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
855 #[doc = r" no stolen instances are passed to such software."]
856 pub unsafe fn steal() -> Self {
857 Self { _marker: PhantomData }
858 }
859}
860impl Deref for GPDMA0_CH6 {
861 type Target = gpdma0_ch2::RegisterBlock;
862 #[inline(always)]
863 fn deref(&self) -> &Self::Target {
864 unsafe { &*Self::PTR }
865 }
866}
867impl core::fmt::Debug for GPDMA0_CH6 {
868 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
869 f.debug_struct("GPDMA0_CH6").finish()
870 }
871}
872#[doc = "General Purpose DMA Unit 0"]
873pub use self::gpdma0_ch2 as gpdma0_ch6;
874#[doc = "General Purpose DMA Unit 0"]
875pub struct GPDMA0_CH7 {
876 _marker: PhantomData<*const ()>,
877}
878unsafe impl Send for GPDMA0_CH7 {}
879impl GPDMA0_CH7 {
880 #[doc = r"Pointer to the register block"]
881 pub const PTR: *const gpdma0_ch2::RegisterBlock = 0x5001_4268 as *const _;
882 #[doc = r"Return the pointer to the register block"]
883 #[inline(always)]
884 pub const fn ptr() -> *const gpdma0_ch2::RegisterBlock {
885 Self::PTR
886 }
887 #[doc = r" Steal an instance of this peripheral"]
888 #[doc = r""]
889 #[doc = r" # Safety"]
890 #[doc = r""]
891 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
892 #[doc = r" that may race with any existing instances, for example by only"]
893 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
894 #[doc = r" original peripheral and using critical sections to coordinate"]
895 #[doc = r" access between multiple new instances."]
896 #[doc = r""]
897 #[doc = r" Additionally, other software such as HALs may rely on only one"]
898 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
899 #[doc = r" no stolen instances are passed to such software."]
900 pub unsafe fn steal() -> Self {
901 Self { _marker: PhantomData }
902 }
903}
904impl Deref for GPDMA0_CH7 {
905 type Target = gpdma0_ch2::RegisterBlock;
906 #[inline(always)]
907 fn deref(&self) -> &Self::Target {
908 unsafe { &*Self::PTR }
909 }
910}
911impl core::fmt::Debug for GPDMA0_CH7 {
912 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
913 f.debug_struct("GPDMA0_CH7").finish()
914 }
915}
916#[doc = "General Purpose DMA Unit 0"]
917pub use self::gpdma0_ch2 as gpdma0_ch7;
918#[doc = "Flexible CRC Engine"]
919pub struct FCE {
920 _marker: PhantomData<*const ()>,
921}
922unsafe impl Send for FCE {}
923impl FCE {
924 #[doc = r"Pointer to the register block"]
925 pub const PTR: *const fce::RegisterBlock = 0x5002_0000 as *const _;
926 #[doc = r"Return the pointer to the register block"]
927 #[inline(always)]
928 pub const fn ptr() -> *const fce::RegisterBlock {
929 Self::PTR
930 }
931 #[doc = r" Steal an instance of this peripheral"]
932 #[doc = r""]
933 #[doc = r" # Safety"]
934 #[doc = r""]
935 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
936 #[doc = r" that may race with any existing instances, for example by only"]
937 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
938 #[doc = r" original peripheral and using critical sections to coordinate"]
939 #[doc = r" access between multiple new instances."]
940 #[doc = r""]
941 #[doc = r" Additionally, other software such as HALs may rely on only one"]
942 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
943 #[doc = r" no stolen instances are passed to such software."]
944 pub unsafe fn steal() -> Self {
945 Self { _marker: PhantomData }
946 }
947}
948impl Deref for FCE {
949 type Target = fce::RegisterBlock;
950 #[inline(always)]
951 fn deref(&self) -> &Self::Target {
952 unsafe { &*Self::PTR }
953 }
954}
955impl core::fmt::Debug for FCE {
956 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
957 f.debug_struct("FCE").finish()
958 }
959}
960#[doc = "Flexible CRC Engine"]
961pub mod fce;
962#[doc = "Flexible CRC Engine"]
963pub struct FCE_KE0 {
964 _marker: PhantomData<*const ()>,
965}
966unsafe impl Send for FCE_KE0 {}
967impl FCE_KE0 {
968 #[doc = r"Pointer to the register block"]
969 pub const PTR: *const fce_ke0::RegisterBlock = 0x5002_0020 as *const _;
970 #[doc = r"Return the pointer to the register block"]
971 #[inline(always)]
972 pub const fn ptr() -> *const fce_ke0::RegisterBlock {
973 Self::PTR
974 }
975 #[doc = r" Steal an instance of this peripheral"]
976 #[doc = r""]
977 #[doc = r" # Safety"]
978 #[doc = r""]
979 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
980 #[doc = r" that may race with any existing instances, for example by only"]
981 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
982 #[doc = r" original peripheral and using critical sections to coordinate"]
983 #[doc = r" access between multiple new instances."]
984 #[doc = r""]
985 #[doc = r" Additionally, other software such as HALs may rely on only one"]
986 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
987 #[doc = r" no stolen instances are passed to such software."]
988 pub unsafe fn steal() -> Self {
989 Self { _marker: PhantomData }
990 }
991}
992impl Deref for FCE_KE0 {
993 type Target = fce_ke0::RegisterBlock;
994 #[inline(always)]
995 fn deref(&self) -> &Self::Target {
996 unsafe { &*Self::PTR }
997 }
998}
999impl core::fmt::Debug for FCE_KE0 {
1000 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1001 f.debug_struct("FCE_KE0").finish()
1002 }
1003}
1004#[doc = "Flexible CRC Engine"]
1005pub mod fce_ke0;
1006#[doc = "Flexible CRC Engine"]
1007pub struct FCE_KE1 {
1008 _marker: PhantomData<*const ()>,
1009}
1010unsafe impl Send for FCE_KE1 {}
1011impl FCE_KE1 {
1012 #[doc = r"Pointer to the register block"]
1013 pub const PTR: *const fce_ke0::RegisterBlock = 0x5002_0040 as *const _;
1014 #[doc = r"Return the pointer to the register block"]
1015 #[inline(always)]
1016 pub const fn ptr() -> *const fce_ke0::RegisterBlock {
1017 Self::PTR
1018 }
1019 #[doc = r" Steal an instance of this peripheral"]
1020 #[doc = r""]
1021 #[doc = r" # Safety"]
1022 #[doc = r""]
1023 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1024 #[doc = r" that may race with any existing instances, for example by only"]
1025 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1026 #[doc = r" original peripheral and using critical sections to coordinate"]
1027 #[doc = r" access between multiple new instances."]
1028 #[doc = r""]
1029 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1030 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1031 #[doc = r" no stolen instances are passed to such software."]
1032 pub unsafe fn steal() -> Self {
1033 Self { _marker: PhantomData }
1034 }
1035}
1036impl Deref for FCE_KE1 {
1037 type Target = fce_ke0::RegisterBlock;
1038 #[inline(always)]
1039 fn deref(&self) -> &Self::Target {
1040 unsafe { &*Self::PTR }
1041 }
1042}
1043impl core::fmt::Debug for FCE_KE1 {
1044 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1045 f.debug_struct("FCE_KE1").finish()
1046 }
1047}
1048#[doc = "Flexible CRC Engine"]
1049pub use self::fce_ke0 as fce_ke1;
1050#[doc = "Flexible CRC Engine"]
1051pub struct FCE_KE2 {
1052 _marker: PhantomData<*const ()>,
1053}
1054unsafe impl Send for FCE_KE2 {}
1055impl FCE_KE2 {
1056 #[doc = r"Pointer to the register block"]
1057 pub const PTR: *const fce_ke0::RegisterBlock = 0x5002_0060 as *const _;
1058 #[doc = r"Return the pointer to the register block"]
1059 #[inline(always)]
1060 pub const fn ptr() -> *const fce_ke0::RegisterBlock {
1061 Self::PTR
1062 }
1063 #[doc = r" Steal an instance of this peripheral"]
1064 #[doc = r""]
1065 #[doc = r" # Safety"]
1066 #[doc = r""]
1067 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1068 #[doc = r" that may race with any existing instances, for example by only"]
1069 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1070 #[doc = r" original peripheral and using critical sections to coordinate"]
1071 #[doc = r" access between multiple new instances."]
1072 #[doc = r""]
1073 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1074 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1075 #[doc = r" no stolen instances are passed to such software."]
1076 pub unsafe fn steal() -> Self {
1077 Self { _marker: PhantomData }
1078 }
1079}
1080impl Deref for FCE_KE2 {
1081 type Target = fce_ke0::RegisterBlock;
1082 #[inline(always)]
1083 fn deref(&self) -> &Self::Target {
1084 unsafe { &*Self::PTR }
1085 }
1086}
1087impl core::fmt::Debug for FCE_KE2 {
1088 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1089 f.debug_struct("FCE_KE2").finish()
1090 }
1091}
1092#[doc = "Flexible CRC Engine"]
1093pub use self::fce_ke0 as fce_ke2;
1094#[doc = "Flexible CRC Engine"]
1095pub struct FCE_KE3 {
1096 _marker: PhantomData<*const ()>,
1097}
1098unsafe impl Send for FCE_KE3 {}
1099impl FCE_KE3 {
1100 #[doc = r"Pointer to the register block"]
1101 pub const PTR: *const fce_ke0::RegisterBlock = 0x5002_0080 as *const _;
1102 #[doc = r"Return the pointer to the register block"]
1103 #[inline(always)]
1104 pub const fn ptr() -> *const fce_ke0::RegisterBlock {
1105 Self::PTR
1106 }
1107 #[doc = r" Steal an instance of this peripheral"]
1108 #[doc = r""]
1109 #[doc = r" # Safety"]
1110 #[doc = r""]
1111 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1112 #[doc = r" that may race with any existing instances, for example by only"]
1113 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1114 #[doc = r" original peripheral and using critical sections to coordinate"]
1115 #[doc = r" access between multiple new instances."]
1116 #[doc = r""]
1117 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1118 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1119 #[doc = r" no stolen instances are passed to such software."]
1120 pub unsafe fn steal() -> Self {
1121 Self { _marker: PhantomData }
1122 }
1123}
1124impl Deref for FCE_KE3 {
1125 type Target = fce_ke0::RegisterBlock;
1126 #[inline(always)]
1127 fn deref(&self) -> &Self::Target {
1128 unsafe { &*Self::PTR }
1129 }
1130}
1131impl core::fmt::Debug for FCE_KE3 {
1132 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1133 f.debug_struct("FCE_KE3").finish()
1134 }
1135}
1136#[doc = "Flexible CRC Engine"]
1137pub use self::fce_ke0 as fce_ke3;
1138#[doc = "Peripheral Bridge AHB 0"]
1139pub struct PBA0 {
1140 _marker: PhantomData<*const ()>,
1141}
1142unsafe impl Send for PBA0 {}
1143impl PBA0 {
1144 #[doc = r"Pointer to the register block"]
1145 pub const PTR: *const pba0::RegisterBlock = 0x4000_0000 as *const _;
1146 #[doc = r"Return the pointer to the register block"]
1147 #[inline(always)]
1148 pub const fn ptr() -> *const pba0::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 { _marker: PhantomData }
1166 }
1167}
1168impl Deref for PBA0 {
1169 type Target = pba0::RegisterBlock;
1170 #[inline(always)]
1171 fn deref(&self) -> &Self::Target {
1172 unsafe { &*Self::PTR }
1173 }
1174}
1175impl core::fmt::Debug for PBA0 {
1176 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1177 f.debug_struct("PBA0").finish()
1178 }
1179}
1180#[doc = "Peripheral Bridge AHB 0"]
1181pub mod pba0;
1182#[doc = "Peripheral Bridge AHB 1"]
1183pub struct PBA1 {
1184 _marker: PhantomData<*const ()>,
1185}
1186unsafe impl Send for PBA1 {}
1187impl PBA1 {
1188 #[doc = r"Pointer to the register block"]
1189 pub const PTR: *const pba0::RegisterBlock = 0x4800_0000 as *const _;
1190 #[doc = r"Return the pointer to the register block"]
1191 #[inline(always)]
1192 pub const fn ptr() -> *const pba0::RegisterBlock {
1193 Self::PTR
1194 }
1195 #[doc = r" Steal an instance of this peripheral"]
1196 #[doc = r""]
1197 #[doc = r" # Safety"]
1198 #[doc = r""]
1199 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1200 #[doc = r" that may race with any existing instances, for example by only"]
1201 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1202 #[doc = r" original peripheral and using critical sections to coordinate"]
1203 #[doc = r" access between multiple new instances."]
1204 #[doc = r""]
1205 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1206 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1207 #[doc = r" no stolen instances are passed to such software."]
1208 pub unsafe fn steal() -> Self {
1209 Self { _marker: PhantomData }
1210 }
1211}
1212impl Deref for PBA1 {
1213 type Target = pba0::RegisterBlock;
1214 #[inline(always)]
1215 fn deref(&self) -> &Self::Target {
1216 unsafe { &*Self::PTR }
1217 }
1218}
1219impl core::fmt::Debug for PBA1 {
1220 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1221 f.debug_struct("PBA1").finish()
1222 }
1223}
1224#[doc = "Peripheral Bridge AHB 1"]
1225pub use self::pba0 as pba1;
1226#[doc = "Flash Memory Controller"]
1227pub struct FLASH0 {
1228 _marker: PhantomData<*const ()>,
1229}
1230unsafe impl Send for FLASH0 {}
1231impl FLASH0 {
1232 #[doc = r"Pointer to the register block"]
1233 pub const PTR: *const flash0::RegisterBlock = 0x5800_1000 as *const _;
1234 #[doc = r"Return the pointer to the register block"]
1235 #[inline(always)]
1236 pub const fn ptr() -> *const flash0::RegisterBlock {
1237 Self::PTR
1238 }
1239 #[doc = r" Steal an instance of this peripheral"]
1240 #[doc = r""]
1241 #[doc = r" # Safety"]
1242 #[doc = r""]
1243 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1244 #[doc = r" that may race with any existing instances, for example by only"]
1245 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1246 #[doc = r" original peripheral and using critical sections to coordinate"]
1247 #[doc = r" access between multiple new instances."]
1248 #[doc = r""]
1249 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1250 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1251 #[doc = r" no stolen instances are passed to such software."]
1252 pub unsafe fn steal() -> Self {
1253 Self { _marker: PhantomData }
1254 }
1255}
1256impl Deref for FLASH0 {
1257 type Target = flash0::RegisterBlock;
1258 #[inline(always)]
1259 fn deref(&self) -> &Self::Target {
1260 unsafe { &*Self::PTR }
1261 }
1262}
1263impl core::fmt::Debug for FLASH0 {
1264 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1265 f.debug_struct("FLASH0").finish()
1266 }
1267}
1268#[doc = "Flash Memory Controller"]
1269pub mod flash0;
1270#[doc = "Prefetch Unit"]
1271pub struct PREF {
1272 _marker: PhantomData<*const ()>,
1273}
1274unsafe impl Send for PREF {}
1275impl PREF {
1276 #[doc = r"Pointer to the register block"]
1277 pub const PTR: *const pref::RegisterBlock = 0x5800_4000 as *const _;
1278 #[doc = r"Return the pointer to the register block"]
1279 #[inline(always)]
1280 pub const fn ptr() -> *const pref::RegisterBlock {
1281 Self::PTR
1282 }
1283 #[doc = r" Steal an instance of this peripheral"]
1284 #[doc = r""]
1285 #[doc = r" # Safety"]
1286 #[doc = r""]
1287 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1288 #[doc = r" that may race with any existing instances, for example by only"]
1289 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1290 #[doc = r" original peripheral and using critical sections to coordinate"]
1291 #[doc = r" access between multiple new instances."]
1292 #[doc = r""]
1293 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1294 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1295 #[doc = r" no stolen instances are passed to such software."]
1296 pub unsafe fn steal() -> Self {
1297 Self { _marker: PhantomData }
1298 }
1299}
1300impl Deref for PREF {
1301 type Target = pref::RegisterBlock;
1302 #[inline(always)]
1303 fn deref(&self) -> &Self::Target {
1304 unsafe { &*Self::PTR }
1305 }
1306}
1307impl core::fmt::Debug for PREF {
1308 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1309 f.debug_struct("PREF").finish()
1310 }
1311}
1312#[doc = "Prefetch Unit"]
1313pub mod pref;
1314#[doc = "Program Management Unit"]
1315pub struct PMU0 {
1316 _marker: PhantomData<*const ()>,
1317}
1318unsafe impl Send for PMU0 {}
1319impl PMU0 {
1320 #[doc = r"Pointer to the register block"]
1321 pub const PTR: *const pmu0::RegisterBlock = 0x5800_0508 as *const _;
1322 #[doc = r"Return the pointer to the register block"]
1323 #[inline(always)]
1324 pub const fn ptr() -> *const pmu0::RegisterBlock {
1325 Self::PTR
1326 }
1327 #[doc = r" Steal an instance of this peripheral"]
1328 #[doc = r""]
1329 #[doc = r" # Safety"]
1330 #[doc = r""]
1331 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1332 #[doc = r" that may race with any existing instances, for example by only"]
1333 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1334 #[doc = r" original peripheral and using critical sections to coordinate"]
1335 #[doc = r" access between multiple new instances."]
1336 #[doc = r""]
1337 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1338 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1339 #[doc = r" no stolen instances are passed to such software."]
1340 pub unsafe fn steal() -> Self {
1341 Self { _marker: PhantomData }
1342 }
1343}
1344impl Deref for PMU0 {
1345 type Target = pmu0::RegisterBlock;
1346 #[inline(always)]
1347 fn deref(&self) -> &Self::Target {
1348 unsafe { &*Self::PTR }
1349 }
1350}
1351impl core::fmt::Debug for PMU0 {
1352 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1353 f.debug_struct("PMU0").finish()
1354 }
1355}
1356#[doc = "Program Management Unit"]
1357pub mod pmu0;
1358#[doc = "Watch Dog Timer"]
1359pub struct WDT {
1360 _marker: PhantomData<*const ()>,
1361}
1362unsafe impl Send for WDT {}
1363impl WDT {
1364 #[doc = r"Pointer to the register block"]
1365 pub const PTR: *const wdt::RegisterBlock = 0x5000_8000 as *const _;
1366 #[doc = r"Return the pointer to the register block"]
1367 #[inline(always)]
1368 pub const fn ptr() -> *const wdt::RegisterBlock {
1369 Self::PTR
1370 }
1371 #[doc = r" Steal an instance of this peripheral"]
1372 #[doc = r""]
1373 #[doc = r" # Safety"]
1374 #[doc = r""]
1375 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1376 #[doc = r" that may race with any existing instances, for example by only"]
1377 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1378 #[doc = r" original peripheral and using critical sections to coordinate"]
1379 #[doc = r" access between multiple new instances."]
1380 #[doc = r""]
1381 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1382 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1383 #[doc = r" no stolen instances are passed to such software."]
1384 pub unsafe fn steal() -> Self {
1385 Self { _marker: PhantomData }
1386 }
1387}
1388impl Deref for WDT {
1389 type Target = wdt::RegisterBlock;
1390 #[inline(always)]
1391 fn deref(&self) -> &Self::Target {
1392 unsafe { &*Self::PTR }
1393 }
1394}
1395impl core::fmt::Debug for WDT {
1396 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1397 f.debug_struct("WDT").finish()
1398 }
1399}
1400#[doc = "Watch Dog Timer"]
1401pub mod wdt;
1402#[doc = "Real Time Clock"]
1403pub struct RTC {
1404 _marker: PhantomData<*const ()>,
1405}
1406unsafe impl Send for RTC {}
1407impl RTC {
1408 #[doc = r"Pointer to the register block"]
1409 pub const PTR: *const rtc::RegisterBlock = 0x5000_4a00 as *const _;
1410 #[doc = r"Return the pointer to the register block"]
1411 #[inline(always)]
1412 pub const fn ptr() -> *const rtc::RegisterBlock {
1413 Self::PTR
1414 }
1415 #[doc = r" Steal an instance of this peripheral"]
1416 #[doc = r""]
1417 #[doc = r" # Safety"]
1418 #[doc = r""]
1419 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1420 #[doc = r" that may race with any existing instances, for example by only"]
1421 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1422 #[doc = r" original peripheral and using critical sections to coordinate"]
1423 #[doc = r" access between multiple new instances."]
1424 #[doc = r""]
1425 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1426 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1427 #[doc = r" no stolen instances are passed to such software."]
1428 pub unsafe fn steal() -> Self {
1429 Self { _marker: PhantomData }
1430 }
1431}
1432impl Deref for RTC {
1433 type Target = rtc::RegisterBlock;
1434 #[inline(always)]
1435 fn deref(&self) -> &Self::Target {
1436 unsafe { &*Self::PTR }
1437 }
1438}
1439impl core::fmt::Debug for RTC {
1440 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1441 f.debug_struct("RTC").finish()
1442 }
1443}
1444#[doc = "Real Time Clock"]
1445pub mod rtc;
1446#[doc = "System Control Unit"]
1447pub struct SCU_CLK {
1448 _marker: PhantomData<*const ()>,
1449}
1450unsafe impl Send for SCU_CLK {}
1451impl SCU_CLK {
1452 #[doc = r"Pointer to the register block"]
1453 pub const PTR: *const scu_clk::RegisterBlock = 0x5000_4600 as *const _;
1454 #[doc = r"Return the pointer to the register block"]
1455 #[inline(always)]
1456 pub const fn ptr() -> *const scu_clk::RegisterBlock {
1457 Self::PTR
1458 }
1459 #[doc = r" Steal an instance of this peripheral"]
1460 #[doc = r""]
1461 #[doc = r" # Safety"]
1462 #[doc = r""]
1463 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1464 #[doc = r" that may race with any existing instances, for example by only"]
1465 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1466 #[doc = r" original peripheral and using critical sections to coordinate"]
1467 #[doc = r" access between multiple new instances."]
1468 #[doc = r""]
1469 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1470 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1471 #[doc = r" no stolen instances are passed to such software."]
1472 pub unsafe fn steal() -> Self {
1473 Self { _marker: PhantomData }
1474 }
1475}
1476impl Deref for SCU_CLK {
1477 type Target = scu_clk::RegisterBlock;
1478 #[inline(always)]
1479 fn deref(&self) -> &Self::Target {
1480 unsafe { &*Self::PTR }
1481 }
1482}
1483impl core::fmt::Debug for SCU_CLK {
1484 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1485 f.debug_struct("SCU_CLK").finish()
1486 }
1487}
1488#[doc = "System Control Unit"]
1489pub mod scu_clk;
1490#[doc = "System Control Unit"]
1491pub struct SCU_OSC {
1492 _marker: PhantomData<*const ()>,
1493}
1494unsafe impl Send for SCU_OSC {}
1495impl SCU_OSC {
1496 #[doc = r"Pointer to the register block"]
1497 pub const PTR: *const scu_osc::RegisterBlock = 0x5000_4700 as *const _;
1498 #[doc = r"Return the pointer to the register block"]
1499 #[inline(always)]
1500 pub const fn ptr() -> *const scu_osc::RegisterBlock {
1501 Self::PTR
1502 }
1503 #[doc = r" Steal an instance of this peripheral"]
1504 #[doc = r""]
1505 #[doc = r" # Safety"]
1506 #[doc = r""]
1507 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1508 #[doc = r" that may race with any existing instances, for example by only"]
1509 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1510 #[doc = r" original peripheral and using critical sections to coordinate"]
1511 #[doc = r" access between multiple new instances."]
1512 #[doc = r""]
1513 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1514 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1515 #[doc = r" no stolen instances are passed to such software."]
1516 pub unsafe fn steal() -> Self {
1517 Self { _marker: PhantomData }
1518 }
1519}
1520impl Deref for SCU_OSC {
1521 type Target = scu_osc::RegisterBlock;
1522 #[inline(always)]
1523 fn deref(&self) -> &Self::Target {
1524 unsafe { &*Self::PTR }
1525 }
1526}
1527impl core::fmt::Debug for SCU_OSC {
1528 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1529 f.debug_struct("SCU_OSC").finish()
1530 }
1531}
1532#[doc = "System Control Unit"]
1533pub mod scu_osc;
1534#[doc = "System Control Unit"]
1535pub struct SCU_PLL {
1536 _marker: PhantomData<*const ()>,
1537}
1538unsafe impl Send for SCU_PLL {}
1539impl SCU_PLL {
1540 #[doc = r"Pointer to the register block"]
1541 pub const PTR: *const scu_pll::RegisterBlock = 0x5000_4710 as *const _;
1542 #[doc = r"Return the pointer to the register block"]
1543 #[inline(always)]
1544 pub const fn ptr() -> *const scu_pll::RegisterBlock {
1545 Self::PTR
1546 }
1547 #[doc = r" Steal an instance of this peripheral"]
1548 #[doc = r""]
1549 #[doc = r" # Safety"]
1550 #[doc = r""]
1551 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1552 #[doc = r" that may race with any existing instances, for example by only"]
1553 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1554 #[doc = r" original peripheral and using critical sections to coordinate"]
1555 #[doc = r" access between multiple new instances."]
1556 #[doc = r""]
1557 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1558 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1559 #[doc = r" no stolen instances are passed to such software."]
1560 pub unsafe fn steal() -> Self {
1561 Self { _marker: PhantomData }
1562 }
1563}
1564impl Deref for SCU_PLL {
1565 type Target = scu_pll::RegisterBlock;
1566 #[inline(always)]
1567 fn deref(&self) -> &Self::Target {
1568 unsafe { &*Self::PTR }
1569 }
1570}
1571impl core::fmt::Debug for SCU_PLL {
1572 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1573 f.debug_struct("SCU_PLL").finish()
1574 }
1575}
1576#[doc = "System Control Unit"]
1577pub mod scu_pll;
1578#[doc = "System Control Unit"]
1579pub struct SCU_GENERAL {
1580 _marker: PhantomData<*const ()>,
1581}
1582unsafe impl Send for SCU_GENERAL {}
1583impl SCU_GENERAL {
1584 #[doc = r"Pointer to the register block"]
1585 pub const PTR: *const scu_general::RegisterBlock = 0x5000_4000 as *const _;
1586 #[doc = r"Return the pointer to the register block"]
1587 #[inline(always)]
1588 pub const fn ptr() -> *const scu_general::RegisterBlock {
1589 Self::PTR
1590 }
1591 #[doc = r" Steal an instance of this peripheral"]
1592 #[doc = r""]
1593 #[doc = r" # Safety"]
1594 #[doc = r""]
1595 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1596 #[doc = r" that may race with any existing instances, for example by only"]
1597 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1598 #[doc = r" original peripheral and using critical sections to coordinate"]
1599 #[doc = r" access between multiple new instances."]
1600 #[doc = r""]
1601 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1602 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1603 #[doc = r" no stolen instances are passed to such software."]
1604 pub unsafe fn steal() -> Self {
1605 Self { _marker: PhantomData }
1606 }
1607}
1608impl Deref for SCU_GENERAL {
1609 type Target = scu_general::RegisterBlock;
1610 #[inline(always)]
1611 fn deref(&self) -> &Self::Target {
1612 unsafe { &*Self::PTR }
1613 }
1614}
1615impl core::fmt::Debug for SCU_GENERAL {
1616 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1617 f.debug_struct("SCU_GENERAL").finish()
1618 }
1619}
1620#[doc = "System Control Unit"]
1621pub mod scu_general;
1622#[doc = "System Control Unit"]
1623pub struct SCU_INTERRUPT {
1624 _marker: PhantomData<*const ()>,
1625}
1626unsafe impl Send for SCU_INTERRUPT {}
1627impl SCU_INTERRUPT {
1628 #[doc = r"Pointer to the register block"]
1629 pub const PTR: *const scu_interrupt::RegisterBlock = 0x5000_4074 as *const _;
1630 #[doc = r"Return the pointer to the register block"]
1631 #[inline(always)]
1632 pub const fn ptr() -> *const scu_interrupt::RegisterBlock {
1633 Self::PTR
1634 }
1635 #[doc = r" Steal an instance of this peripheral"]
1636 #[doc = r""]
1637 #[doc = r" # Safety"]
1638 #[doc = r""]
1639 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1640 #[doc = r" that may race with any existing instances, for example by only"]
1641 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1642 #[doc = r" original peripheral and using critical sections to coordinate"]
1643 #[doc = r" access between multiple new instances."]
1644 #[doc = r""]
1645 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1646 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1647 #[doc = r" no stolen instances are passed to such software."]
1648 pub unsafe fn steal() -> Self {
1649 Self { _marker: PhantomData }
1650 }
1651}
1652impl Deref for SCU_INTERRUPT {
1653 type Target = scu_interrupt::RegisterBlock;
1654 #[inline(always)]
1655 fn deref(&self) -> &Self::Target {
1656 unsafe { &*Self::PTR }
1657 }
1658}
1659impl core::fmt::Debug for SCU_INTERRUPT {
1660 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1661 f.debug_struct("SCU_INTERRUPT").finish()
1662 }
1663}
1664#[doc = "System Control Unit"]
1665pub mod scu_interrupt;
1666#[doc = "System Control Unit"]
1667pub struct SCU_PARITY {
1668 _marker: PhantomData<*const ()>,
1669}
1670unsafe impl Send for SCU_PARITY {}
1671impl SCU_PARITY {
1672 #[doc = r"Pointer to the register block"]
1673 pub const PTR: *const scu_parity::RegisterBlock = 0x5000_413c as *const _;
1674 #[doc = r"Return the pointer to the register block"]
1675 #[inline(always)]
1676 pub const fn ptr() -> *const scu_parity::RegisterBlock {
1677 Self::PTR
1678 }
1679 #[doc = r" Steal an instance of this peripheral"]
1680 #[doc = r""]
1681 #[doc = r" # Safety"]
1682 #[doc = r""]
1683 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1684 #[doc = r" that may race with any existing instances, for example by only"]
1685 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1686 #[doc = r" original peripheral and using critical sections to coordinate"]
1687 #[doc = r" access between multiple new instances."]
1688 #[doc = r""]
1689 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1690 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1691 #[doc = r" no stolen instances are passed to such software."]
1692 pub unsafe fn steal() -> Self {
1693 Self { _marker: PhantomData }
1694 }
1695}
1696impl Deref for SCU_PARITY {
1697 type Target = scu_parity::RegisterBlock;
1698 #[inline(always)]
1699 fn deref(&self) -> &Self::Target {
1700 unsafe { &*Self::PTR }
1701 }
1702}
1703impl core::fmt::Debug for SCU_PARITY {
1704 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1705 f.debug_struct("SCU_PARITY").finish()
1706 }
1707}
1708#[doc = "System Control Unit"]
1709pub mod scu_parity;
1710#[doc = "System Control Unit"]
1711pub struct SCU_TRAP {
1712 _marker: PhantomData<*const ()>,
1713}
1714unsafe impl Send for SCU_TRAP {}
1715impl SCU_TRAP {
1716 #[doc = r"Pointer to the register block"]
1717 pub const PTR: *const scu_trap::RegisterBlock = 0x5000_4160 as *const _;
1718 #[doc = r"Return the pointer to the register block"]
1719 #[inline(always)]
1720 pub const fn ptr() -> *const scu_trap::RegisterBlock {
1721 Self::PTR
1722 }
1723 #[doc = r" Steal an instance of this peripheral"]
1724 #[doc = r""]
1725 #[doc = r" # Safety"]
1726 #[doc = r""]
1727 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1728 #[doc = r" that may race with any existing instances, for example by only"]
1729 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1730 #[doc = r" original peripheral and using critical sections to coordinate"]
1731 #[doc = r" access between multiple new instances."]
1732 #[doc = r""]
1733 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1734 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1735 #[doc = r" no stolen instances are passed to such software."]
1736 pub unsafe fn steal() -> Self {
1737 Self { _marker: PhantomData }
1738 }
1739}
1740impl Deref for SCU_TRAP {
1741 type Target = scu_trap::RegisterBlock;
1742 #[inline(always)]
1743 fn deref(&self) -> &Self::Target {
1744 unsafe { &*Self::PTR }
1745 }
1746}
1747impl core::fmt::Debug for SCU_TRAP {
1748 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1749 f.debug_struct("SCU_TRAP").finish()
1750 }
1751}
1752#[doc = "System Control Unit"]
1753pub mod scu_trap;
1754#[doc = "System Control Unit"]
1755pub struct SCU_HIBERNATE {
1756 _marker: PhantomData<*const ()>,
1757}
1758unsafe impl Send for SCU_HIBERNATE {}
1759impl SCU_HIBERNATE {
1760 #[doc = r"Pointer to the register block"]
1761 pub const PTR: *const scu_hibernate::RegisterBlock = 0x5000_4300 as *const _;
1762 #[doc = r"Return the pointer to the register block"]
1763 #[inline(always)]
1764 pub const fn ptr() -> *const scu_hibernate::RegisterBlock {
1765 Self::PTR
1766 }
1767 #[doc = r" Steal an instance of this peripheral"]
1768 #[doc = r""]
1769 #[doc = r" # Safety"]
1770 #[doc = r""]
1771 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1772 #[doc = r" that may race with any existing instances, for example by only"]
1773 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1774 #[doc = r" original peripheral and using critical sections to coordinate"]
1775 #[doc = r" access between multiple new instances."]
1776 #[doc = r""]
1777 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1778 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1779 #[doc = r" no stolen instances are passed to such software."]
1780 pub unsafe fn steal() -> Self {
1781 Self { _marker: PhantomData }
1782 }
1783}
1784impl Deref for SCU_HIBERNATE {
1785 type Target = scu_hibernate::RegisterBlock;
1786 #[inline(always)]
1787 fn deref(&self) -> &Self::Target {
1788 unsafe { &*Self::PTR }
1789 }
1790}
1791impl core::fmt::Debug for SCU_HIBERNATE {
1792 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1793 f.debug_struct("SCU_HIBERNATE").finish()
1794 }
1795}
1796#[doc = "System Control Unit"]
1797pub mod scu_hibernate;
1798#[doc = "System Control Unit"]
1799pub struct SCU_POWER {
1800 _marker: PhantomData<*const ()>,
1801}
1802unsafe impl Send for SCU_POWER {}
1803impl SCU_POWER {
1804 #[doc = r"Pointer to the register block"]
1805 pub const PTR: *const scu_power::RegisterBlock = 0x5000_4200 as *const _;
1806 #[doc = r"Return the pointer to the register block"]
1807 #[inline(always)]
1808 pub const fn ptr() -> *const scu_power::RegisterBlock {
1809 Self::PTR
1810 }
1811 #[doc = r" Steal an instance of this peripheral"]
1812 #[doc = r""]
1813 #[doc = r" # Safety"]
1814 #[doc = r""]
1815 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1816 #[doc = r" that may race with any existing instances, for example by only"]
1817 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1818 #[doc = r" original peripheral and using critical sections to coordinate"]
1819 #[doc = r" access between multiple new instances."]
1820 #[doc = r""]
1821 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1822 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1823 #[doc = r" no stolen instances are passed to such software."]
1824 pub unsafe fn steal() -> Self {
1825 Self { _marker: PhantomData }
1826 }
1827}
1828impl Deref for SCU_POWER {
1829 type Target = scu_power::RegisterBlock;
1830 #[inline(always)]
1831 fn deref(&self) -> &Self::Target {
1832 unsafe { &*Self::PTR }
1833 }
1834}
1835impl core::fmt::Debug for SCU_POWER {
1836 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1837 f.debug_struct("SCU_POWER").finish()
1838 }
1839}
1840#[doc = "System Control Unit"]
1841pub mod scu_power;
1842#[doc = "System Control Unit"]
1843pub struct SCU_RESET {
1844 _marker: PhantomData<*const ()>,
1845}
1846unsafe impl Send for SCU_RESET {}
1847impl SCU_RESET {
1848 #[doc = r"Pointer to the register block"]
1849 pub const PTR: *const scu_reset::RegisterBlock = 0x5000_4400 as *const _;
1850 #[doc = r"Return the pointer to the register block"]
1851 #[inline(always)]
1852 pub const fn ptr() -> *const scu_reset::RegisterBlock {
1853 Self::PTR
1854 }
1855 #[doc = r" Steal an instance of this peripheral"]
1856 #[doc = r""]
1857 #[doc = r" # Safety"]
1858 #[doc = r""]
1859 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1860 #[doc = r" that may race with any existing instances, for example by only"]
1861 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1862 #[doc = r" original peripheral and using critical sections to coordinate"]
1863 #[doc = r" access between multiple new instances."]
1864 #[doc = r""]
1865 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1866 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1867 #[doc = r" no stolen instances are passed to such software."]
1868 pub unsafe fn steal() -> Self {
1869 Self { _marker: PhantomData }
1870 }
1871}
1872impl Deref for SCU_RESET {
1873 type Target = scu_reset::RegisterBlock;
1874 #[inline(always)]
1875 fn deref(&self) -> &Self::Target {
1876 unsafe { &*Self::PTR }
1877 }
1878}
1879impl core::fmt::Debug for SCU_RESET {
1880 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1881 f.debug_struct("SCU_RESET").finish()
1882 }
1883}
1884#[doc = "System Control Unit"]
1885pub mod scu_reset;
1886#[doc = "LED and Touch Sense Unit 0"]
1887pub struct LEDTS0 {
1888 _marker: PhantomData<*const ()>,
1889}
1890unsafe impl Send for LEDTS0 {}
1891impl LEDTS0 {
1892 #[doc = r"Pointer to the register block"]
1893 pub const PTR: *const ledts0::RegisterBlock = 0x4801_0000 as *const _;
1894 #[doc = r"Return the pointer to the register block"]
1895 #[inline(always)]
1896 pub const fn ptr() -> *const ledts0::RegisterBlock {
1897 Self::PTR
1898 }
1899 #[doc = r" Steal an instance of this peripheral"]
1900 #[doc = r""]
1901 #[doc = r" # Safety"]
1902 #[doc = r""]
1903 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1904 #[doc = r" that may race with any existing instances, for example by only"]
1905 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1906 #[doc = r" original peripheral and using critical sections to coordinate"]
1907 #[doc = r" access between multiple new instances."]
1908 #[doc = r""]
1909 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1910 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1911 #[doc = r" no stolen instances are passed to such software."]
1912 pub unsafe fn steal() -> Self {
1913 Self { _marker: PhantomData }
1914 }
1915}
1916impl Deref for LEDTS0 {
1917 type Target = ledts0::RegisterBlock;
1918 #[inline(always)]
1919 fn deref(&self) -> &Self::Target {
1920 unsafe { &*Self::PTR }
1921 }
1922}
1923impl core::fmt::Debug for LEDTS0 {
1924 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1925 f.debug_struct("LEDTS0").finish()
1926 }
1927}
1928#[doc = "LED and Touch Sense Unit 0"]
1929pub mod ledts0;
1930#[doc = "Universal Serial Bus"]
1931pub struct USB0 {
1932 _marker: PhantomData<*const ()>,
1933}
1934unsafe impl Send for USB0 {}
1935impl USB0 {
1936 #[doc = r"Pointer to the register block"]
1937 pub const PTR: *const usb0::RegisterBlock = 0x5004_0000 as *const _;
1938 #[doc = r"Return the pointer to the register block"]
1939 #[inline(always)]
1940 pub const fn ptr() -> *const usb0::RegisterBlock {
1941 Self::PTR
1942 }
1943 #[doc = r" Steal an instance of this peripheral"]
1944 #[doc = r""]
1945 #[doc = r" # Safety"]
1946 #[doc = r""]
1947 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1948 #[doc = r" that may race with any existing instances, for example by only"]
1949 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1950 #[doc = r" original peripheral and using critical sections to coordinate"]
1951 #[doc = r" access between multiple new instances."]
1952 #[doc = r""]
1953 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1954 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1955 #[doc = r" no stolen instances are passed to such software."]
1956 pub unsafe fn steal() -> Self {
1957 Self { _marker: PhantomData }
1958 }
1959}
1960impl Deref for USB0 {
1961 type Target = usb0::RegisterBlock;
1962 #[inline(always)]
1963 fn deref(&self) -> &Self::Target {
1964 unsafe { &*Self::PTR }
1965 }
1966}
1967impl core::fmt::Debug for USB0 {
1968 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1969 f.debug_struct("USB0").finish()
1970 }
1971}
1972#[doc = "Universal Serial Bus"]
1973pub mod usb0;
1974#[doc = "Universal Serial Bus"]
1975pub struct USB0_EP0 {
1976 _marker: PhantomData<*const ()>,
1977}
1978unsafe impl Send for USB0_EP0 {}
1979impl USB0_EP0 {
1980 #[doc = r"Pointer to the register block"]
1981 pub const PTR: *const usb0_ep0::RegisterBlock = 0x5004_0900 as *const _;
1982 #[doc = r"Return the pointer to the register block"]
1983 #[inline(always)]
1984 pub const fn ptr() -> *const usb0_ep0::RegisterBlock {
1985 Self::PTR
1986 }
1987 #[doc = r" Steal an instance of this peripheral"]
1988 #[doc = r""]
1989 #[doc = r" # Safety"]
1990 #[doc = r""]
1991 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1992 #[doc = r" that may race with any existing instances, for example by only"]
1993 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1994 #[doc = r" original peripheral and using critical sections to coordinate"]
1995 #[doc = r" access between multiple new instances."]
1996 #[doc = r""]
1997 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1998 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1999 #[doc = r" no stolen instances are passed to such software."]
2000 pub unsafe fn steal() -> Self {
2001 Self { _marker: PhantomData }
2002 }
2003}
2004impl Deref for USB0_EP0 {
2005 type Target = usb0_ep0::RegisterBlock;
2006 #[inline(always)]
2007 fn deref(&self) -> &Self::Target {
2008 unsafe { &*Self::PTR }
2009 }
2010}
2011impl core::fmt::Debug for USB0_EP0 {
2012 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2013 f.debug_struct("USB0_EP0").finish()
2014 }
2015}
2016#[doc = "Universal Serial Bus"]
2017pub mod usb0_ep0;
2018#[doc = "Universal Serial Bus"]
2019pub struct USB0_EP1 {
2020 _marker: PhantomData<*const ()>,
2021}
2022unsafe impl Send for USB0_EP1 {}
2023impl USB0_EP1 {
2024 #[doc = r"Pointer to the register block"]
2025 pub const PTR: *const usb0_ep1::RegisterBlock = 0x5004_0920 as *const _;
2026 #[doc = r"Return the pointer to the register block"]
2027 #[inline(always)]
2028 pub const fn ptr() -> *const usb0_ep1::RegisterBlock {
2029 Self::PTR
2030 }
2031 #[doc = r" Steal an instance of this peripheral"]
2032 #[doc = r""]
2033 #[doc = r" # Safety"]
2034 #[doc = r""]
2035 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2036 #[doc = r" that may race with any existing instances, for example by only"]
2037 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2038 #[doc = r" original peripheral and using critical sections to coordinate"]
2039 #[doc = r" access between multiple new instances."]
2040 #[doc = r""]
2041 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2042 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2043 #[doc = r" no stolen instances are passed to such software."]
2044 pub unsafe fn steal() -> Self {
2045 Self { _marker: PhantomData }
2046 }
2047}
2048impl Deref for USB0_EP1 {
2049 type Target = usb0_ep1::RegisterBlock;
2050 #[inline(always)]
2051 fn deref(&self) -> &Self::Target {
2052 unsafe { &*Self::PTR }
2053 }
2054}
2055impl core::fmt::Debug for USB0_EP1 {
2056 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2057 f.debug_struct("USB0_EP1").finish()
2058 }
2059}
2060#[doc = "Universal Serial Bus"]
2061pub mod usb0_ep1;
2062#[doc = "Universal Serial Bus"]
2063pub struct USB0_EP2 {
2064 _marker: PhantomData<*const ()>,
2065}
2066unsafe impl Send for USB0_EP2 {}
2067impl USB0_EP2 {
2068 #[doc = r"Pointer to the register block"]
2069 pub const PTR: *const usb0_ep1::RegisterBlock = 0x5004_0940 as *const _;
2070 #[doc = r"Return the pointer to the register block"]
2071 #[inline(always)]
2072 pub const fn ptr() -> *const usb0_ep1::RegisterBlock {
2073 Self::PTR
2074 }
2075 #[doc = r" Steal an instance of this peripheral"]
2076 #[doc = r""]
2077 #[doc = r" # Safety"]
2078 #[doc = r""]
2079 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2080 #[doc = r" that may race with any existing instances, for example by only"]
2081 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2082 #[doc = r" original peripheral and using critical sections to coordinate"]
2083 #[doc = r" access between multiple new instances."]
2084 #[doc = r""]
2085 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2086 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2087 #[doc = r" no stolen instances are passed to such software."]
2088 pub unsafe fn steal() -> Self {
2089 Self { _marker: PhantomData }
2090 }
2091}
2092impl Deref for USB0_EP2 {
2093 type Target = usb0_ep1::RegisterBlock;
2094 #[inline(always)]
2095 fn deref(&self) -> &Self::Target {
2096 unsafe { &*Self::PTR }
2097 }
2098}
2099impl core::fmt::Debug for USB0_EP2 {
2100 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2101 f.debug_struct("USB0_EP2").finish()
2102 }
2103}
2104#[doc = "Universal Serial Bus"]
2105pub use self::usb0_ep1 as usb0_ep2;
2106#[doc = "Universal Serial Bus"]
2107pub struct USB0_EP3 {
2108 _marker: PhantomData<*const ()>,
2109}
2110unsafe impl Send for USB0_EP3 {}
2111impl USB0_EP3 {
2112 #[doc = r"Pointer to the register block"]
2113 pub const PTR: *const usb0_ep1::RegisterBlock = 0x5004_0960 as *const _;
2114 #[doc = r"Return the pointer to the register block"]
2115 #[inline(always)]
2116 pub const fn ptr() -> *const usb0_ep1::RegisterBlock {
2117 Self::PTR
2118 }
2119 #[doc = r" Steal an instance of this peripheral"]
2120 #[doc = r""]
2121 #[doc = r" # Safety"]
2122 #[doc = r""]
2123 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2124 #[doc = r" that may race with any existing instances, for example by only"]
2125 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2126 #[doc = r" original peripheral and using critical sections to coordinate"]
2127 #[doc = r" access between multiple new instances."]
2128 #[doc = r""]
2129 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2130 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2131 #[doc = r" no stolen instances are passed to such software."]
2132 pub unsafe fn steal() -> Self {
2133 Self { _marker: PhantomData }
2134 }
2135}
2136impl Deref for USB0_EP3 {
2137 type Target = usb0_ep1::RegisterBlock;
2138 #[inline(always)]
2139 fn deref(&self) -> &Self::Target {
2140 unsafe { &*Self::PTR }
2141 }
2142}
2143impl core::fmt::Debug for USB0_EP3 {
2144 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2145 f.debug_struct("USB0_EP3").finish()
2146 }
2147}
2148#[doc = "Universal Serial Bus"]
2149pub use self::usb0_ep1 as usb0_ep3;
2150#[doc = "Universal Serial Bus"]
2151pub struct USB0_EP4 {
2152 _marker: PhantomData<*const ()>,
2153}
2154unsafe impl Send for USB0_EP4 {}
2155impl USB0_EP4 {
2156 #[doc = r"Pointer to the register block"]
2157 pub const PTR: *const usb0_ep1::RegisterBlock = 0x5004_0980 as *const _;
2158 #[doc = r"Return the pointer to the register block"]
2159 #[inline(always)]
2160 pub const fn ptr() -> *const usb0_ep1::RegisterBlock {
2161 Self::PTR
2162 }
2163 #[doc = r" Steal an instance of this peripheral"]
2164 #[doc = r""]
2165 #[doc = r" # Safety"]
2166 #[doc = r""]
2167 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2168 #[doc = r" that may race with any existing instances, for example by only"]
2169 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2170 #[doc = r" original peripheral and using critical sections to coordinate"]
2171 #[doc = r" access between multiple new instances."]
2172 #[doc = r""]
2173 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2174 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2175 #[doc = r" no stolen instances are passed to such software."]
2176 pub unsafe fn steal() -> Self {
2177 Self { _marker: PhantomData }
2178 }
2179}
2180impl Deref for USB0_EP4 {
2181 type Target = usb0_ep1::RegisterBlock;
2182 #[inline(always)]
2183 fn deref(&self) -> &Self::Target {
2184 unsafe { &*Self::PTR }
2185 }
2186}
2187impl core::fmt::Debug for USB0_EP4 {
2188 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2189 f.debug_struct("USB0_EP4").finish()
2190 }
2191}
2192#[doc = "Universal Serial Bus"]
2193pub use self::usb0_ep1 as usb0_ep4;
2194#[doc = "Universal Serial Bus"]
2195pub struct USB0_EP5 {
2196 _marker: PhantomData<*const ()>,
2197}
2198unsafe impl Send for USB0_EP5 {}
2199impl USB0_EP5 {
2200 #[doc = r"Pointer to the register block"]
2201 pub const PTR: *const usb0_ep1::RegisterBlock = 0x5004_09a0 as *const _;
2202 #[doc = r"Return the pointer to the register block"]
2203 #[inline(always)]
2204 pub const fn ptr() -> *const usb0_ep1::RegisterBlock {
2205 Self::PTR
2206 }
2207 #[doc = r" Steal an instance of this peripheral"]
2208 #[doc = r""]
2209 #[doc = r" # Safety"]
2210 #[doc = r""]
2211 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2212 #[doc = r" that may race with any existing instances, for example by only"]
2213 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2214 #[doc = r" original peripheral and using critical sections to coordinate"]
2215 #[doc = r" access between multiple new instances."]
2216 #[doc = r""]
2217 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2218 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2219 #[doc = r" no stolen instances are passed to such software."]
2220 pub unsafe fn steal() -> Self {
2221 Self { _marker: PhantomData }
2222 }
2223}
2224impl Deref for USB0_EP5 {
2225 type Target = usb0_ep1::RegisterBlock;
2226 #[inline(always)]
2227 fn deref(&self) -> &Self::Target {
2228 unsafe { &*Self::PTR }
2229 }
2230}
2231impl core::fmt::Debug for USB0_EP5 {
2232 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2233 f.debug_struct("USB0_EP5").finish()
2234 }
2235}
2236#[doc = "Universal Serial Bus"]
2237pub use self::usb0_ep1 as usb0_ep5;
2238#[doc = "Universal Serial Bus"]
2239pub struct USB0_EP6 {
2240 _marker: PhantomData<*const ()>,
2241}
2242unsafe impl Send for USB0_EP6 {}
2243impl USB0_EP6 {
2244 #[doc = r"Pointer to the register block"]
2245 pub const PTR: *const usb0_ep1::RegisterBlock = 0x5004_09c0 as *const _;
2246 #[doc = r"Return the pointer to the register block"]
2247 #[inline(always)]
2248 pub const fn ptr() -> *const usb0_ep1::RegisterBlock {
2249 Self::PTR
2250 }
2251 #[doc = r" Steal an instance of this peripheral"]
2252 #[doc = r""]
2253 #[doc = r" # Safety"]
2254 #[doc = r""]
2255 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2256 #[doc = r" that may race with any existing instances, for example by only"]
2257 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2258 #[doc = r" original peripheral and using critical sections to coordinate"]
2259 #[doc = r" access between multiple new instances."]
2260 #[doc = r""]
2261 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2262 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2263 #[doc = r" no stolen instances are passed to such software."]
2264 pub unsafe fn steal() -> Self {
2265 Self { _marker: PhantomData }
2266 }
2267}
2268impl Deref for USB0_EP6 {
2269 type Target = usb0_ep1::RegisterBlock;
2270 #[inline(always)]
2271 fn deref(&self) -> &Self::Target {
2272 unsafe { &*Self::PTR }
2273 }
2274}
2275impl core::fmt::Debug for USB0_EP6 {
2276 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2277 f.debug_struct("USB0_EP6").finish()
2278 }
2279}
2280#[doc = "Universal Serial Bus"]
2281pub use self::usb0_ep1 as usb0_ep6;
2282#[doc = "Universal Serial Interface Controller 0"]
2283pub struct USIC0 {
2284 _marker: PhantomData<*const ()>,
2285}
2286unsafe impl Send for USIC0 {}
2287impl USIC0 {
2288 #[doc = r"Pointer to the register block"]
2289 pub const PTR: *const usic0::RegisterBlock = 0x4003_0008 as *const _;
2290 #[doc = r"Return the pointer to the register block"]
2291 #[inline(always)]
2292 pub const fn ptr() -> *const usic0::RegisterBlock {
2293 Self::PTR
2294 }
2295 #[doc = r" Steal an instance of this peripheral"]
2296 #[doc = r""]
2297 #[doc = r" # Safety"]
2298 #[doc = r""]
2299 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2300 #[doc = r" that may race with any existing instances, for example by only"]
2301 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2302 #[doc = r" original peripheral and using critical sections to coordinate"]
2303 #[doc = r" access between multiple new instances."]
2304 #[doc = r""]
2305 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2306 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2307 #[doc = r" no stolen instances are passed to such software."]
2308 pub unsafe fn steal() -> Self {
2309 Self { _marker: PhantomData }
2310 }
2311}
2312impl Deref for USIC0 {
2313 type Target = usic0::RegisterBlock;
2314 #[inline(always)]
2315 fn deref(&self) -> &Self::Target {
2316 unsafe { &*Self::PTR }
2317 }
2318}
2319impl core::fmt::Debug for USIC0 {
2320 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2321 f.debug_struct("USIC0").finish()
2322 }
2323}
2324#[doc = "Universal Serial Interface Controller 0"]
2325pub mod usic0;
2326#[doc = "Universal Serial Interface Controller 1"]
2327pub struct USIC1 {
2328 _marker: PhantomData<*const ()>,
2329}
2330unsafe impl Send for USIC1 {}
2331impl USIC1 {
2332 #[doc = r"Pointer to the register block"]
2333 pub const PTR: *const usic0::RegisterBlock = 0x4802_0008 as *const _;
2334 #[doc = r"Return the pointer to the register block"]
2335 #[inline(always)]
2336 pub const fn ptr() -> *const usic0::RegisterBlock {
2337 Self::PTR
2338 }
2339 #[doc = r" Steal an instance of this peripheral"]
2340 #[doc = r""]
2341 #[doc = r" # Safety"]
2342 #[doc = r""]
2343 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2344 #[doc = r" that may race with any existing instances, for example by only"]
2345 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2346 #[doc = r" original peripheral and using critical sections to coordinate"]
2347 #[doc = r" access between multiple new instances."]
2348 #[doc = r""]
2349 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2350 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2351 #[doc = r" no stolen instances are passed to such software."]
2352 pub unsafe fn steal() -> Self {
2353 Self { _marker: PhantomData }
2354 }
2355}
2356impl Deref for USIC1 {
2357 type Target = usic0::RegisterBlock;
2358 #[inline(always)]
2359 fn deref(&self) -> &Self::Target {
2360 unsafe { &*Self::PTR }
2361 }
2362}
2363impl core::fmt::Debug for USIC1 {
2364 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2365 f.debug_struct("USIC1").finish()
2366 }
2367}
2368#[doc = "Universal Serial Interface Controller 1"]
2369pub use self::usic0 as usic1;
2370#[doc = "Universal Serial Interface Controller 0"]
2371pub struct USIC0_CH0 {
2372 _marker: PhantomData<*const ()>,
2373}
2374unsafe impl Send for USIC0_CH0 {}
2375impl USIC0_CH0 {
2376 #[doc = r"Pointer to the register block"]
2377 pub const PTR: *const usic0_ch0::RegisterBlock = 0x4003_0000 as *const _;
2378 #[doc = r"Return the pointer to the register block"]
2379 #[inline(always)]
2380 pub const fn ptr() -> *const usic0_ch0::RegisterBlock {
2381 Self::PTR
2382 }
2383 #[doc = r" Steal an instance of this peripheral"]
2384 #[doc = r""]
2385 #[doc = r" # Safety"]
2386 #[doc = r""]
2387 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2388 #[doc = r" that may race with any existing instances, for example by only"]
2389 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2390 #[doc = r" original peripheral and using critical sections to coordinate"]
2391 #[doc = r" access between multiple new instances."]
2392 #[doc = r""]
2393 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2394 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2395 #[doc = r" no stolen instances are passed to such software."]
2396 pub unsafe fn steal() -> Self {
2397 Self { _marker: PhantomData }
2398 }
2399}
2400impl Deref for USIC0_CH0 {
2401 type Target = usic0_ch0::RegisterBlock;
2402 #[inline(always)]
2403 fn deref(&self) -> &Self::Target {
2404 unsafe { &*Self::PTR }
2405 }
2406}
2407impl core::fmt::Debug for USIC0_CH0 {
2408 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2409 f.debug_struct("USIC0_CH0").finish()
2410 }
2411}
2412#[doc = "Universal Serial Interface Controller 0"]
2413pub mod usic0_ch0;
2414#[doc = "Universal Serial Interface Controller 0"]
2415pub struct USIC0_CH1 {
2416 _marker: PhantomData<*const ()>,
2417}
2418unsafe impl Send for USIC0_CH1 {}
2419impl USIC0_CH1 {
2420 #[doc = r"Pointer to the register block"]
2421 pub const PTR: *const usic0_ch0::RegisterBlock = 0x4003_0200 as *const _;
2422 #[doc = r"Return the pointer to the register block"]
2423 #[inline(always)]
2424 pub const fn ptr() -> *const usic0_ch0::RegisterBlock {
2425 Self::PTR
2426 }
2427 #[doc = r" Steal an instance of this peripheral"]
2428 #[doc = r""]
2429 #[doc = r" # Safety"]
2430 #[doc = r""]
2431 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2432 #[doc = r" that may race with any existing instances, for example by only"]
2433 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2434 #[doc = r" original peripheral and using critical sections to coordinate"]
2435 #[doc = r" access between multiple new instances."]
2436 #[doc = r""]
2437 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2438 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2439 #[doc = r" no stolen instances are passed to such software."]
2440 pub unsafe fn steal() -> Self {
2441 Self { _marker: PhantomData }
2442 }
2443}
2444impl Deref for USIC0_CH1 {
2445 type Target = usic0_ch0::RegisterBlock;
2446 #[inline(always)]
2447 fn deref(&self) -> &Self::Target {
2448 unsafe { &*Self::PTR }
2449 }
2450}
2451impl core::fmt::Debug for USIC0_CH1 {
2452 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2453 f.debug_struct("USIC0_CH1").finish()
2454 }
2455}
2456#[doc = "Universal Serial Interface Controller 0"]
2457pub use self::usic0_ch0 as usic0_ch1;
2458#[doc = "Universal Serial Interface Controller 1"]
2459pub struct USIC1_CH0 {
2460 _marker: PhantomData<*const ()>,
2461}
2462unsafe impl Send for USIC1_CH0 {}
2463impl USIC1_CH0 {
2464 #[doc = r"Pointer to the register block"]
2465 pub const PTR: *const usic0_ch0::RegisterBlock = 0x4802_0000 as *const _;
2466 #[doc = r"Return the pointer to the register block"]
2467 #[inline(always)]
2468 pub const fn ptr() -> *const usic0_ch0::RegisterBlock {
2469 Self::PTR
2470 }
2471 #[doc = r" Steal an instance of this peripheral"]
2472 #[doc = r""]
2473 #[doc = r" # Safety"]
2474 #[doc = r""]
2475 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2476 #[doc = r" that may race with any existing instances, for example by only"]
2477 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2478 #[doc = r" original peripheral and using critical sections to coordinate"]
2479 #[doc = r" access between multiple new instances."]
2480 #[doc = r""]
2481 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2482 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2483 #[doc = r" no stolen instances are passed to such software."]
2484 pub unsafe fn steal() -> Self {
2485 Self { _marker: PhantomData }
2486 }
2487}
2488impl Deref for USIC1_CH0 {
2489 type Target = usic0_ch0::RegisterBlock;
2490 #[inline(always)]
2491 fn deref(&self) -> &Self::Target {
2492 unsafe { &*Self::PTR }
2493 }
2494}
2495impl core::fmt::Debug for USIC1_CH0 {
2496 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2497 f.debug_struct("USIC1_CH0").finish()
2498 }
2499}
2500#[doc = "Universal Serial Interface Controller 1"]
2501pub use self::usic0_ch0 as usic1_ch0;
2502#[doc = "Universal Serial Interface Controller 1"]
2503pub struct USIC1_CH1 {
2504 _marker: PhantomData<*const ()>,
2505}
2506unsafe impl Send for USIC1_CH1 {}
2507impl USIC1_CH1 {
2508 #[doc = r"Pointer to the register block"]
2509 pub const PTR: *const usic0_ch0::RegisterBlock = 0x4802_0200 as *const _;
2510 #[doc = r"Return the pointer to the register block"]
2511 #[inline(always)]
2512 pub const fn ptr() -> *const usic0_ch0::RegisterBlock {
2513 Self::PTR
2514 }
2515 #[doc = r" Steal an instance of this peripheral"]
2516 #[doc = r""]
2517 #[doc = r" # Safety"]
2518 #[doc = r""]
2519 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2520 #[doc = r" that may race with any existing instances, for example by only"]
2521 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2522 #[doc = r" original peripheral and using critical sections to coordinate"]
2523 #[doc = r" access between multiple new instances."]
2524 #[doc = r""]
2525 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2526 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2527 #[doc = r" no stolen instances are passed to such software."]
2528 pub unsafe fn steal() -> Self {
2529 Self { _marker: PhantomData }
2530 }
2531}
2532impl Deref for USIC1_CH1 {
2533 type Target = usic0_ch0::RegisterBlock;
2534 #[inline(always)]
2535 fn deref(&self) -> &Self::Target {
2536 unsafe { &*Self::PTR }
2537 }
2538}
2539impl core::fmt::Debug for USIC1_CH1 {
2540 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2541 f.debug_struct("USIC1_CH1").finish()
2542 }
2543}
2544#[doc = "Universal Serial Interface Controller 1"]
2545pub use self::usic0_ch0 as usic1_ch1;
2546#[doc = "Controller Area Networks"]
2547pub struct CAN {
2548 _marker: PhantomData<*const ()>,
2549}
2550unsafe impl Send for CAN {}
2551impl CAN {
2552 #[doc = r"Pointer to the register block"]
2553 pub const PTR: *const can::RegisterBlock = 0x4801_4000 as *const _;
2554 #[doc = r"Return the pointer to the register block"]
2555 #[inline(always)]
2556 pub const fn ptr() -> *const can::RegisterBlock {
2557 Self::PTR
2558 }
2559 #[doc = r" Steal an instance of this peripheral"]
2560 #[doc = r""]
2561 #[doc = r" # Safety"]
2562 #[doc = r""]
2563 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2564 #[doc = r" that may race with any existing instances, for example by only"]
2565 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2566 #[doc = r" original peripheral and using critical sections to coordinate"]
2567 #[doc = r" access between multiple new instances."]
2568 #[doc = r""]
2569 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2570 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2571 #[doc = r" no stolen instances are passed to such software."]
2572 pub unsafe fn steal() -> Self {
2573 Self { _marker: PhantomData }
2574 }
2575}
2576impl Deref for CAN {
2577 type Target = can::RegisterBlock;
2578 #[inline(always)]
2579 fn deref(&self) -> &Self::Target {
2580 unsafe { &*Self::PTR }
2581 }
2582}
2583impl core::fmt::Debug for CAN {
2584 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2585 f.debug_struct("CAN").finish()
2586 }
2587}
2588#[doc = "Controller Area Networks"]
2589pub mod can;
2590#[doc = "Controller Area Networks"]
2591pub struct CAN_NODE0 {
2592 _marker: PhantomData<*const ()>,
2593}
2594unsafe impl Send for CAN_NODE0 {}
2595impl CAN_NODE0 {
2596 #[doc = r"Pointer to the register block"]
2597 pub const PTR: *const can_node0::RegisterBlock = 0x4801_4200 as *const _;
2598 #[doc = r"Return the pointer to the register block"]
2599 #[inline(always)]
2600 pub const fn ptr() -> *const can_node0::RegisterBlock {
2601 Self::PTR
2602 }
2603 #[doc = r" Steal an instance of this peripheral"]
2604 #[doc = r""]
2605 #[doc = r" # Safety"]
2606 #[doc = r""]
2607 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2608 #[doc = r" that may race with any existing instances, for example by only"]
2609 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2610 #[doc = r" original peripheral and using critical sections to coordinate"]
2611 #[doc = r" access between multiple new instances."]
2612 #[doc = r""]
2613 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2614 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2615 #[doc = r" no stolen instances are passed to such software."]
2616 pub unsafe fn steal() -> Self {
2617 Self { _marker: PhantomData }
2618 }
2619}
2620impl Deref for CAN_NODE0 {
2621 type Target = can_node0::RegisterBlock;
2622 #[inline(always)]
2623 fn deref(&self) -> &Self::Target {
2624 unsafe { &*Self::PTR }
2625 }
2626}
2627impl core::fmt::Debug for CAN_NODE0 {
2628 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2629 f.debug_struct("CAN_NODE0").finish()
2630 }
2631}
2632#[doc = "Controller Area Networks"]
2633pub mod can_node0;
2634#[doc = "Controller Area Networks"]
2635pub struct CAN_NODE1 {
2636 _marker: PhantomData<*const ()>,
2637}
2638unsafe impl Send for CAN_NODE1 {}
2639impl CAN_NODE1 {
2640 #[doc = r"Pointer to the register block"]
2641 pub const PTR: *const can_node0::RegisterBlock = 0x4801_4300 as *const _;
2642 #[doc = r"Return the pointer to the register block"]
2643 #[inline(always)]
2644 pub const fn ptr() -> *const can_node0::RegisterBlock {
2645 Self::PTR
2646 }
2647 #[doc = r" Steal an instance of this peripheral"]
2648 #[doc = r""]
2649 #[doc = r" # Safety"]
2650 #[doc = r""]
2651 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2652 #[doc = r" that may race with any existing instances, for example by only"]
2653 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2654 #[doc = r" original peripheral and using critical sections to coordinate"]
2655 #[doc = r" access between multiple new instances."]
2656 #[doc = r""]
2657 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2658 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2659 #[doc = r" no stolen instances are passed to such software."]
2660 pub unsafe fn steal() -> Self {
2661 Self { _marker: PhantomData }
2662 }
2663}
2664impl Deref for CAN_NODE1 {
2665 type Target = can_node0::RegisterBlock;
2666 #[inline(always)]
2667 fn deref(&self) -> &Self::Target {
2668 unsafe { &*Self::PTR }
2669 }
2670}
2671impl core::fmt::Debug for CAN_NODE1 {
2672 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2673 f.debug_struct("CAN_NODE1").finish()
2674 }
2675}
2676#[doc = "Controller Area Networks"]
2677pub use self::can_node0 as can_node1;
2678#[doc = "Controller Area Networks"]
2679pub struct CAN_MO0 {
2680 _marker: PhantomData<*const ()>,
2681}
2682unsafe impl Send for CAN_MO0 {}
2683impl CAN_MO0 {
2684 #[doc = r"Pointer to the register block"]
2685 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5000 as *const _;
2686 #[doc = r"Return the pointer to the register block"]
2687 #[inline(always)]
2688 pub const fn ptr() -> *const can_mo0::RegisterBlock {
2689 Self::PTR
2690 }
2691 #[doc = r" Steal an instance of this peripheral"]
2692 #[doc = r""]
2693 #[doc = r" # Safety"]
2694 #[doc = r""]
2695 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2696 #[doc = r" that may race with any existing instances, for example by only"]
2697 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2698 #[doc = r" original peripheral and using critical sections to coordinate"]
2699 #[doc = r" access between multiple new instances."]
2700 #[doc = r""]
2701 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2702 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2703 #[doc = r" no stolen instances are passed to such software."]
2704 pub unsafe fn steal() -> Self {
2705 Self { _marker: PhantomData }
2706 }
2707}
2708impl Deref for CAN_MO0 {
2709 type Target = can_mo0::RegisterBlock;
2710 #[inline(always)]
2711 fn deref(&self) -> &Self::Target {
2712 unsafe { &*Self::PTR }
2713 }
2714}
2715impl core::fmt::Debug for CAN_MO0 {
2716 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2717 f.debug_struct("CAN_MO0").finish()
2718 }
2719}
2720#[doc = "Controller Area Networks"]
2721pub mod can_mo0;
2722#[doc = "Controller Area Networks"]
2723pub struct CAN_MO1 {
2724 _marker: PhantomData<*const ()>,
2725}
2726unsafe impl Send for CAN_MO1 {}
2727impl CAN_MO1 {
2728 #[doc = r"Pointer to the register block"]
2729 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5020 as *const _;
2730 #[doc = r"Return the pointer to the register block"]
2731 #[inline(always)]
2732 pub const fn ptr() -> *const can_mo0::RegisterBlock {
2733 Self::PTR
2734 }
2735 #[doc = r" Steal an instance of this peripheral"]
2736 #[doc = r""]
2737 #[doc = r" # Safety"]
2738 #[doc = r""]
2739 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2740 #[doc = r" that may race with any existing instances, for example by only"]
2741 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2742 #[doc = r" original peripheral and using critical sections to coordinate"]
2743 #[doc = r" access between multiple new instances."]
2744 #[doc = r""]
2745 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2746 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2747 #[doc = r" no stolen instances are passed to such software."]
2748 pub unsafe fn steal() -> Self {
2749 Self { _marker: PhantomData }
2750 }
2751}
2752impl Deref for CAN_MO1 {
2753 type Target = can_mo0::RegisterBlock;
2754 #[inline(always)]
2755 fn deref(&self) -> &Self::Target {
2756 unsafe { &*Self::PTR }
2757 }
2758}
2759impl core::fmt::Debug for CAN_MO1 {
2760 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2761 f.debug_struct("CAN_MO1").finish()
2762 }
2763}
2764#[doc = "Controller Area Networks"]
2765pub use self::can_mo0 as can_mo1;
2766#[doc = "Controller Area Networks"]
2767pub struct CAN_MO2 {
2768 _marker: PhantomData<*const ()>,
2769}
2770unsafe impl Send for CAN_MO2 {}
2771impl CAN_MO2 {
2772 #[doc = r"Pointer to the register block"]
2773 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5040 as *const _;
2774 #[doc = r"Return the pointer to the register block"]
2775 #[inline(always)]
2776 pub const fn ptr() -> *const can_mo0::RegisterBlock {
2777 Self::PTR
2778 }
2779 #[doc = r" Steal an instance of this peripheral"]
2780 #[doc = r""]
2781 #[doc = r" # Safety"]
2782 #[doc = r""]
2783 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2784 #[doc = r" that may race with any existing instances, for example by only"]
2785 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2786 #[doc = r" original peripheral and using critical sections to coordinate"]
2787 #[doc = r" access between multiple new instances."]
2788 #[doc = r""]
2789 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2790 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2791 #[doc = r" no stolen instances are passed to such software."]
2792 pub unsafe fn steal() -> Self {
2793 Self { _marker: PhantomData }
2794 }
2795}
2796impl Deref for CAN_MO2 {
2797 type Target = can_mo0::RegisterBlock;
2798 #[inline(always)]
2799 fn deref(&self) -> &Self::Target {
2800 unsafe { &*Self::PTR }
2801 }
2802}
2803impl core::fmt::Debug for CAN_MO2 {
2804 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2805 f.debug_struct("CAN_MO2").finish()
2806 }
2807}
2808#[doc = "Controller Area Networks"]
2809pub use self::can_mo0 as can_mo2;
2810#[doc = "Controller Area Networks"]
2811pub struct CAN_MO3 {
2812 _marker: PhantomData<*const ()>,
2813}
2814unsafe impl Send for CAN_MO3 {}
2815impl CAN_MO3 {
2816 #[doc = r"Pointer to the register block"]
2817 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5060 as *const _;
2818 #[doc = r"Return the pointer to the register block"]
2819 #[inline(always)]
2820 pub const fn ptr() -> *const can_mo0::RegisterBlock {
2821 Self::PTR
2822 }
2823 #[doc = r" Steal an instance of this peripheral"]
2824 #[doc = r""]
2825 #[doc = r" # Safety"]
2826 #[doc = r""]
2827 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2828 #[doc = r" that may race with any existing instances, for example by only"]
2829 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2830 #[doc = r" original peripheral and using critical sections to coordinate"]
2831 #[doc = r" access between multiple new instances."]
2832 #[doc = r""]
2833 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2834 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2835 #[doc = r" no stolen instances are passed to such software."]
2836 pub unsafe fn steal() -> Self {
2837 Self { _marker: PhantomData }
2838 }
2839}
2840impl Deref for CAN_MO3 {
2841 type Target = can_mo0::RegisterBlock;
2842 #[inline(always)]
2843 fn deref(&self) -> &Self::Target {
2844 unsafe { &*Self::PTR }
2845 }
2846}
2847impl core::fmt::Debug for CAN_MO3 {
2848 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2849 f.debug_struct("CAN_MO3").finish()
2850 }
2851}
2852#[doc = "Controller Area Networks"]
2853pub use self::can_mo0 as can_mo3;
2854#[doc = "Controller Area Networks"]
2855pub struct CAN_MO4 {
2856 _marker: PhantomData<*const ()>,
2857}
2858unsafe impl Send for CAN_MO4 {}
2859impl CAN_MO4 {
2860 #[doc = r"Pointer to the register block"]
2861 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5080 as *const _;
2862 #[doc = r"Return the pointer to the register block"]
2863 #[inline(always)]
2864 pub const fn ptr() -> *const can_mo0::RegisterBlock {
2865 Self::PTR
2866 }
2867 #[doc = r" Steal an instance of this peripheral"]
2868 #[doc = r""]
2869 #[doc = r" # Safety"]
2870 #[doc = r""]
2871 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2872 #[doc = r" that may race with any existing instances, for example by only"]
2873 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2874 #[doc = r" original peripheral and using critical sections to coordinate"]
2875 #[doc = r" access between multiple new instances."]
2876 #[doc = r""]
2877 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2878 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2879 #[doc = r" no stolen instances are passed to such software."]
2880 pub unsafe fn steal() -> Self {
2881 Self { _marker: PhantomData }
2882 }
2883}
2884impl Deref for CAN_MO4 {
2885 type Target = can_mo0::RegisterBlock;
2886 #[inline(always)]
2887 fn deref(&self) -> &Self::Target {
2888 unsafe { &*Self::PTR }
2889 }
2890}
2891impl core::fmt::Debug for CAN_MO4 {
2892 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2893 f.debug_struct("CAN_MO4").finish()
2894 }
2895}
2896#[doc = "Controller Area Networks"]
2897pub use self::can_mo0 as can_mo4;
2898#[doc = "Controller Area Networks"]
2899pub struct CAN_MO5 {
2900 _marker: PhantomData<*const ()>,
2901}
2902unsafe impl Send for CAN_MO5 {}
2903impl CAN_MO5 {
2904 #[doc = r"Pointer to the register block"]
2905 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_50a0 as *const _;
2906 #[doc = r"Return the pointer to the register block"]
2907 #[inline(always)]
2908 pub const fn ptr() -> *const can_mo0::RegisterBlock {
2909 Self::PTR
2910 }
2911 #[doc = r" Steal an instance of this peripheral"]
2912 #[doc = r""]
2913 #[doc = r" # Safety"]
2914 #[doc = r""]
2915 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2916 #[doc = r" that may race with any existing instances, for example by only"]
2917 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2918 #[doc = r" original peripheral and using critical sections to coordinate"]
2919 #[doc = r" access between multiple new instances."]
2920 #[doc = r""]
2921 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2922 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2923 #[doc = r" no stolen instances are passed to such software."]
2924 pub unsafe fn steal() -> Self {
2925 Self { _marker: PhantomData }
2926 }
2927}
2928impl Deref for CAN_MO5 {
2929 type Target = can_mo0::RegisterBlock;
2930 #[inline(always)]
2931 fn deref(&self) -> &Self::Target {
2932 unsafe { &*Self::PTR }
2933 }
2934}
2935impl core::fmt::Debug for CAN_MO5 {
2936 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2937 f.debug_struct("CAN_MO5").finish()
2938 }
2939}
2940#[doc = "Controller Area Networks"]
2941pub use self::can_mo0 as can_mo5;
2942#[doc = "Controller Area Networks"]
2943pub struct CAN_MO6 {
2944 _marker: PhantomData<*const ()>,
2945}
2946unsafe impl Send for CAN_MO6 {}
2947impl CAN_MO6 {
2948 #[doc = r"Pointer to the register block"]
2949 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_50c0 as *const _;
2950 #[doc = r"Return the pointer to the register block"]
2951 #[inline(always)]
2952 pub const fn ptr() -> *const can_mo0::RegisterBlock {
2953 Self::PTR
2954 }
2955 #[doc = r" Steal an instance of this peripheral"]
2956 #[doc = r""]
2957 #[doc = r" # Safety"]
2958 #[doc = r""]
2959 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2960 #[doc = r" that may race with any existing instances, for example by only"]
2961 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2962 #[doc = r" original peripheral and using critical sections to coordinate"]
2963 #[doc = r" access between multiple new instances."]
2964 #[doc = r""]
2965 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2966 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2967 #[doc = r" no stolen instances are passed to such software."]
2968 pub unsafe fn steal() -> Self {
2969 Self { _marker: PhantomData }
2970 }
2971}
2972impl Deref for CAN_MO6 {
2973 type Target = can_mo0::RegisterBlock;
2974 #[inline(always)]
2975 fn deref(&self) -> &Self::Target {
2976 unsafe { &*Self::PTR }
2977 }
2978}
2979impl core::fmt::Debug for CAN_MO6 {
2980 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2981 f.debug_struct("CAN_MO6").finish()
2982 }
2983}
2984#[doc = "Controller Area Networks"]
2985pub use self::can_mo0 as can_mo6;
2986#[doc = "Controller Area Networks"]
2987pub struct CAN_MO7 {
2988 _marker: PhantomData<*const ()>,
2989}
2990unsafe impl Send for CAN_MO7 {}
2991impl CAN_MO7 {
2992 #[doc = r"Pointer to the register block"]
2993 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_50e0 as *const _;
2994 #[doc = r"Return the pointer to the register block"]
2995 #[inline(always)]
2996 pub const fn ptr() -> *const can_mo0::RegisterBlock {
2997 Self::PTR
2998 }
2999 #[doc = r" Steal an instance of this peripheral"]
3000 #[doc = r""]
3001 #[doc = r" # Safety"]
3002 #[doc = r""]
3003 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3004 #[doc = r" that may race with any existing instances, for example by only"]
3005 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3006 #[doc = r" original peripheral and using critical sections to coordinate"]
3007 #[doc = r" access between multiple new instances."]
3008 #[doc = r""]
3009 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3010 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3011 #[doc = r" no stolen instances are passed to such software."]
3012 pub unsafe fn steal() -> Self {
3013 Self { _marker: PhantomData }
3014 }
3015}
3016impl Deref for CAN_MO7 {
3017 type Target = can_mo0::RegisterBlock;
3018 #[inline(always)]
3019 fn deref(&self) -> &Self::Target {
3020 unsafe { &*Self::PTR }
3021 }
3022}
3023impl core::fmt::Debug for CAN_MO7 {
3024 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3025 f.debug_struct("CAN_MO7").finish()
3026 }
3027}
3028#[doc = "Controller Area Networks"]
3029pub use self::can_mo0 as can_mo7;
3030#[doc = "Controller Area Networks"]
3031pub struct CAN_MO8 {
3032 _marker: PhantomData<*const ()>,
3033}
3034unsafe impl Send for CAN_MO8 {}
3035impl CAN_MO8 {
3036 #[doc = r"Pointer to the register block"]
3037 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5100 as *const _;
3038 #[doc = r"Return the pointer to the register block"]
3039 #[inline(always)]
3040 pub const fn ptr() -> *const can_mo0::RegisterBlock {
3041 Self::PTR
3042 }
3043 #[doc = r" Steal an instance of this peripheral"]
3044 #[doc = r""]
3045 #[doc = r" # Safety"]
3046 #[doc = r""]
3047 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3048 #[doc = r" that may race with any existing instances, for example by only"]
3049 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3050 #[doc = r" original peripheral and using critical sections to coordinate"]
3051 #[doc = r" access between multiple new instances."]
3052 #[doc = r""]
3053 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3054 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3055 #[doc = r" no stolen instances are passed to such software."]
3056 pub unsafe fn steal() -> Self {
3057 Self { _marker: PhantomData }
3058 }
3059}
3060impl Deref for CAN_MO8 {
3061 type Target = can_mo0::RegisterBlock;
3062 #[inline(always)]
3063 fn deref(&self) -> &Self::Target {
3064 unsafe { &*Self::PTR }
3065 }
3066}
3067impl core::fmt::Debug for CAN_MO8 {
3068 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3069 f.debug_struct("CAN_MO8").finish()
3070 }
3071}
3072#[doc = "Controller Area Networks"]
3073pub use self::can_mo0 as can_mo8;
3074#[doc = "Controller Area Networks"]
3075pub struct CAN_MO9 {
3076 _marker: PhantomData<*const ()>,
3077}
3078unsafe impl Send for CAN_MO9 {}
3079impl CAN_MO9 {
3080 #[doc = r"Pointer to the register block"]
3081 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5120 as *const _;
3082 #[doc = r"Return the pointer to the register block"]
3083 #[inline(always)]
3084 pub const fn ptr() -> *const can_mo0::RegisterBlock {
3085 Self::PTR
3086 }
3087 #[doc = r" Steal an instance of this peripheral"]
3088 #[doc = r""]
3089 #[doc = r" # Safety"]
3090 #[doc = r""]
3091 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3092 #[doc = r" that may race with any existing instances, for example by only"]
3093 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3094 #[doc = r" original peripheral and using critical sections to coordinate"]
3095 #[doc = r" access between multiple new instances."]
3096 #[doc = r""]
3097 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3098 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3099 #[doc = r" no stolen instances are passed to such software."]
3100 pub unsafe fn steal() -> Self {
3101 Self { _marker: PhantomData }
3102 }
3103}
3104impl Deref for CAN_MO9 {
3105 type Target = can_mo0::RegisterBlock;
3106 #[inline(always)]
3107 fn deref(&self) -> &Self::Target {
3108 unsafe { &*Self::PTR }
3109 }
3110}
3111impl core::fmt::Debug for CAN_MO9 {
3112 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3113 f.debug_struct("CAN_MO9").finish()
3114 }
3115}
3116#[doc = "Controller Area Networks"]
3117pub use self::can_mo0 as can_mo9;
3118#[doc = "Controller Area Networks"]
3119pub struct CAN_MO10 {
3120 _marker: PhantomData<*const ()>,
3121}
3122unsafe impl Send for CAN_MO10 {}
3123impl CAN_MO10 {
3124 #[doc = r"Pointer to the register block"]
3125 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5140 as *const _;
3126 #[doc = r"Return the pointer to the register block"]
3127 #[inline(always)]
3128 pub const fn ptr() -> *const can_mo0::RegisterBlock {
3129 Self::PTR
3130 }
3131 #[doc = r" Steal an instance of this peripheral"]
3132 #[doc = r""]
3133 #[doc = r" # Safety"]
3134 #[doc = r""]
3135 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3136 #[doc = r" that may race with any existing instances, for example by only"]
3137 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3138 #[doc = r" original peripheral and using critical sections to coordinate"]
3139 #[doc = r" access between multiple new instances."]
3140 #[doc = r""]
3141 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3142 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3143 #[doc = r" no stolen instances are passed to such software."]
3144 pub unsafe fn steal() -> Self {
3145 Self { _marker: PhantomData }
3146 }
3147}
3148impl Deref for CAN_MO10 {
3149 type Target = can_mo0::RegisterBlock;
3150 #[inline(always)]
3151 fn deref(&self) -> &Self::Target {
3152 unsafe { &*Self::PTR }
3153 }
3154}
3155impl core::fmt::Debug for CAN_MO10 {
3156 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3157 f.debug_struct("CAN_MO10").finish()
3158 }
3159}
3160#[doc = "Controller Area Networks"]
3161pub use self::can_mo0 as can_mo10;
3162#[doc = "Controller Area Networks"]
3163pub struct CAN_MO11 {
3164 _marker: PhantomData<*const ()>,
3165}
3166unsafe impl Send for CAN_MO11 {}
3167impl CAN_MO11 {
3168 #[doc = r"Pointer to the register block"]
3169 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5160 as *const _;
3170 #[doc = r"Return the pointer to the register block"]
3171 #[inline(always)]
3172 pub const fn ptr() -> *const can_mo0::RegisterBlock {
3173 Self::PTR
3174 }
3175 #[doc = r" Steal an instance of this peripheral"]
3176 #[doc = r""]
3177 #[doc = r" # Safety"]
3178 #[doc = r""]
3179 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3180 #[doc = r" that may race with any existing instances, for example by only"]
3181 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3182 #[doc = r" original peripheral and using critical sections to coordinate"]
3183 #[doc = r" access between multiple new instances."]
3184 #[doc = r""]
3185 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3186 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3187 #[doc = r" no stolen instances are passed to such software."]
3188 pub unsafe fn steal() -> Self {
3189 Self { _marker: PhantomData }
3190 }
3191}
3192impl Deref for CAN_MO11 {
3193 type Target = can_mo0::RegisterBlock;
3194 #[inline(always)]
3195 fn deref(&self) -> &Self::Target {
3196 unsafe { &*Self::PTR }
3197 }
3198}
3199impl core::fmt::Debug for CAN_MO11 {
3200 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3201 f.debug_struct("CAN_MO11").finish()
3202 }
3203}
3204#[doc = "Controller Area Networks"]
3205pub use self::can_mo0 as can_mo11;
3206#[doc = "Controller Area Networks"]
3207pub struct CAN_MO12 {
3208 _marker: PhantomData<*const ()>,
3209}
3210unsafe impl Send for CAN_MO12 {}
3211impl CAN_MO12 {
3212 #[doc = r"Pointer to the register block"]
3213 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5180 as *const _;
3214 #[doc = r"Return the pointer to the register block"]
3215 #[inline(always)]
3216 pub const fn ptr() -> *const can_mo0::RegisterBlock {
3217 Self::PTR
3218 }
3219 #[doc = r" Steal an instance of this peripheral"]
3220 #[doc = r""]
3221 #[doc = r" # Safety"]
3222 #[doc = r""]
3223 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3224 #[doc = r" that may race with any existing instances, for example by only"]
3225 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3226 #[doc = r" original peripheral and using critical sections to coordinate"]
3227 #[doc = r" access between multiple new instances."]
3228 #[doc = r""]
3229 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3230 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3231 #[doc = r" no stolen instances are passed to such software."]
3232 pub unsafe fn steal() -> Self {
3233 Self { _marker: PhantomData }
3234 }
3235}
3236impl Deref for CAN_MO12 {
3237 type Target = can_mo0::RegisterBlock;
3238 #[inline(always)]
3239 fn deref(&self) -> &Self::Target {
3240 unsafe { &*Self::PTR }
3241 }
3242}
3243impl core::fmt::Debug for CAN_MO12 {
3244 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3245 f.debug_struct("CAN_MO12").finish()
3246 }
3247}
3248#[doc = "Controller Area Networks"]
3249pub use self::can_mo0 as can_mo12;
3250#[doc = "Controller Area Networks"]
3251pub struct CAN_MO13 {
3252 _marker: PhantomData<*const ()>,
3253}
3254unsafe impl Send for CAN_MO13 {}
3255impl CAN_MO13 {
3256 #[doc = r"Pointer to the register block"]
3257 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_51a0 as *const _;
3258 #[doc = r"Return the pointer to the register block"]
3259 #[inline(always)]
3260 pub const fn ptr() -> *const can_mo0::RegisterBlock {
3261 Self::PTR
3262 }
3263 #[doc = r" Steal an instance of this peripheral"]
3264 #[doc = r""]
3265 #[doc = r" # Safety"]
3266 #[doc = r""]
3267 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3268 #[doc = r" that may race with any existing instances, for example by only"]
3269 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3270 #[doc = r" original peripheral and using critical sections to coordinate"]
3271 #[doc = r" access between multiple new instances."]
3272 #[doc = r""]
3273 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3274 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3275 #[doc = r" no stolen instances are passed to such software."]
3276 pub unsafe fn steal() -> Self {
3277 Self { _marker: PhantomData }
3278 }
3279}
3280impl Deref for CAN_MO13 {
3281 type Target = can_mo0::RegisterBlock;
3282 #[inline(always)]
3283 fn deref(&self) -> &Self::Target {
3284 unsafe { &*Self::PTR }
3285 }
3286}
3287impl core::fmt::Debug for CAN_MO13 {
3288 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3289 f.debug_struct("CAN_MO13").finish()
3290 }
3291}
3292#[doc = "Controller Area Networks"]
3293pub use self::can_mo0 as can_mo13;
3294#[doc = "Controller Area Networks"]
3295pub struct CAN_MO14 {
3296 _marker: PhantomData<*const ()>,
3297}
3298unsafe impl Send for CAN_MO14 {}
3299impl CAN_MO14 {
3300 #[doc = r"Pointer to the register block"]
3301 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_51c0 as *const _;
3302 #[doc = r"Return the pointer to the register block"]
3303 #[inline(always)]
3304 pub const fn ptr() -> *const can_mo0::RegisterBlock {
3305 Self::PTR
3306 }
3307 #[doc = r" Steal an instance of this peripheral"]
3308 #[doc = r""]
3309 #[doc = r" # Safety"]
3310 #[doc = r""]
3311 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3312 #[doc = r" that may race with any existing instances, for example by only"]
3313 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3314 #[doc = r" original peripheral and using critical sections to coordinate"]
3315 #[doc = r" access between multiple new instances."]
3316 #[doc = r""]
3317 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3318 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3319 #[doc = r" no stolen instances are passed to such software."]
3320 pub unsafe fn steal() -> Self {
3321 Self { _marker: PhantomData }
3322 }
3323}
3324impl Deref for CAN_MO14 {
3325 type Target = can_mo0::RegisterBlock;
3326 #[inline(always)]
3327 fn deref(&self) -> &Self::Target {
3328 unsafe { &*Self::PTR }
3329 }
3330}
3331impl core::fmt::Debug for CAN_MO14 {
3332 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3333 f.debug_struct("CAN_MO14").finish()
3334 }
3335}
3336#[doc = "Controller Area Networks"]
3337pub use self::can_mo0 as can_mo14;
3338#[doc = "Controller Area Networks"]
3339pub struct CAN_MO15 {
3340 _marker: PhantomData<*const ()>,
3341}
3342unsafe impl Send for CAN_MO15 {}
3343impl CAN_MO15 {
3344 #[doc = r"Pointer to the register block"]
3345 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_51e0 as *const _;
3346 #[doc = r"Return the pointer to the register block"]
3347 #[inline(always)]
3348 pub const fn ptr() -> *const can_mo0::RegisterBlock {
3349 Self::PTR
3350 }
3351 #[doc = r" Steal an instance of this peripheral"]
3352 #[doc = r""]
3353 #[doc = r" # Safety"]
3354 #[doc = r""]
3355 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3356 #[doc = r" that may race with any existing instances, for example by only"]
3357 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3358 #[doc = r" original peripheral and using critical sections to coordinate"]
3359 #[doc = r" access between multiple new instances."]
3360 #[doc = r""]
3361 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3362 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3363 #[doc = r" no stolen instances are passed to such software."]
3364 pub unsafe fn steal() -> Self {
3365 Self { _marker: PhantomData }
3366 }
3367}
3368impl Deref for CAN_MO15 {
3369 type Target = can_mo0::RegisterBlock;
3370 #[inline(always)]
3371 fn deref(&self) -> &Self::Target {
3372 unsafe { &*Self::PTR }
3373 }
3374}
3375impl core::fmt::Debug for CAN_MO15 {
3376 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3377 f.debug_struct("CAN_MO15").finish()
3378 }
3379}
3380#[doc = "Controller Area Networks"]
3381pub use self::can_mo0 as can_mo15;
3382#[doc = "Controller Area Networks"]
3383pub struct CAN_MO16 {
3384 _marker: PhantomData<*const ()>,
3385}
3386unsafe impl Send for CAN_MO16 {}
3387impl CAN_MO16 {
3388 #[doc = r"Pointer to the register block"]
3389 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5200 as *const _;
3390 #[doc = r"Return the pointer to the register block"]
3391 #[inline(always)]
3392 pub const fn ptr() -> *const can_mo0::RegisterBlock {
3393 Self::PTR
3394 }
3395 #[doc = r" Steal an instance of this peripheral"]
3396 #[doc = r""]
3397 #[doc = r" # Safety"]
3398 #[doc = r""]
3399 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3400 #[doc = r" that may race with any existing instances, for example by only"]
3401 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3402 #[doc = r" original peripheral and using critical sections to coordinate"]
3403 #[doc = r" access between multiple new instances."]
3404 #[doc = r""]
3405 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3406 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3407 #[doc = r" no stolen instances are passed to such software."]
3408 pub unsafe fn steal() -> Self {
3409 Self { _marker: PhantomData }
3410 }
3411}
3412impl Deref for CAN_MO16 {
3413 type Target = can_mo0::RegisterBlock;
3414 #[inline(always)]
3415 fn deref(&self) -> &Self::Target {
3416 unsafe { &*Self::PTR }
3417 }
3418}
3419impl core::fmt::Debug for CAN_MO16 {
3420 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3421 f.debug_struct("CAN_MO16").finish()
3422 }
3423}
3424#[doc = "Controller Area Networks"]
3425pub use self::can_mo0 as can_mo16;
3426#[doc = "Controller Area Networks"]
3427pub struct CAN_MO17 {
3428 _marker: PhantomData<*const ()>,
3429}
3430unsafe impl Send for CAN_MO17 {}
3431impl CAN_MO17 {
3432 #[doc = r"Pointer to the register block"]
3433 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5220 as *const _;
3434 #[doc = r"Return the pointer to the register block"]
3435 #[inline(always)]
3436 pub const fn ptr() -> *const can_mo0::RegisterBlock {
3437 Self::PTR
3438 }
3439 #[doc = r" Steal an instance of this peripheral"]
3440 #[doc = r""]
3441 #[doc = r" # Safety"]
3442 #[doc = r""]
3443 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3444 #[doc = r" that may race with any existing instances, for example by only"]
3445 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3446 #[doc = r" original peripheral and using critical sections to coordinate"]
3447 #[doc = r" access between multiple new instances."]
3448 #[doc = r""]
3449 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3450 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3451 #[doc = r" no stolen instances are passed to such software."]
3452 pub unsafe fn steal() -> Self {
3453 Self { _marker: PhantomData }
3454 }
3455}
3456impl Deref for CAN_MO17 {
3457 type Target = can_mo0::RegisterBlock;
3458 #[inline(always)]
3459 fn deref(&self) -> &Self::Target {
3460 unsafe { &*Self::PTR }
3461 }
3462}
3463impl core::fmt::Debug for CAN_MO17 {
3464 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3465 f.debug_struct("CAN_MO17").finish()
3466 }
3467}
3468#[doc = "Controller Area Networks"]
3469pub use self::can_mo0 as can_mo17;
3470#[doc = "Controller Area Networks"]
3471pub struct CAN_MO18 {
3472 _marker: PhantomData<*const ()>,
3473}
3474unsafe impl Send for CAN_MO18 {}
3475impl CAN_MO18 {
3476 #[doc = r"Pointer to the register block"]
3477 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5240 as *const _;
3478 #[doc = r"Return the pointer to the register block"]
3479 #[inline(always)]
3480 pub const fn ptr() -> *const can_mo0::RegisterBlock {
3481 Self::PTR
3482 }
3483 #[doc = r" Steal an instance of this peripheral"]
3484 #[doc = r""]
3485 #[doc = r" # Safety"]
3486 #[doc = r""]
3487 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3488 #[doc = r" that may race with any existing instances, for example by only"]
3489 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3490 #[doc = r" original peripheral and using critical sections to coordinate"]
3491 #[doc = r" access between multiple new instances."]
3492 #[doc = r""]
3493 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3494 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3495 #[doc = r" no stolen instances are passed to such software."]
3496 pub unsafe fn steal() -> Self {
3497 Self { _marker: PhantomData }
3498 }
3499}
3500impl Deref for CAN_MO18 {
3501 type Target = can_mo0::RegisterBlock;
3502 #[inline(always)]
3503 fn deref(&self) -> &Self::Target {
3504 unsafe { &*Self::PTR }
3505 }
3506}
3507impl core::fmt::Debug for CAN_MO18 {
3508 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3509 f.debug_struct("CAN_MO18").finish()
3510 }
3511}
3512#[doc = "Controller Area Networks"]
3513pub use self::can_mo0 as can_mo18;
3514#[doc = "Controller Area Networks"]
3515pub struct CAN_MO19 {
3516 _marker: PhantomData<*const ()>,
3517}
3518unsafe impl Send for CAN_MO19 {}
3519impl CAN_MO19 {
3520 #[doc = r"Pointer to the register block"]
3521 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5260 as *const _;
3522 #[doc = r"Return the pointer to the register block"]
3523 #[inline(always)]
3524 pub const fn ptr() -> *const can_mo0::RegisterBlock {
3525 Self::PTR
3526 }
3527 #[doc = r" Steal an instance of this peripheral"]
3528 #[doc = r""]
3529 #[doc = r" # Safety"]
3530 #[doc = r""]
3531 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3532 #[doc = r" that may race with any existing instances, for example by only"]
3533 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3534 #[doc = r" original peripheral and using critical sections to coordinate"]
3535 #[doc = r" access between multiple new instances."]
3536 #[doc = r""]
3537 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3538 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3539 #[doc = r" no stolen instances are passed to such software."]
3540 pub unsafe fn steal() -> Self {
3541 Self { _marker: PhantomData }
3542 }
3543}
3544impl Deref for CAN_MO19 {
3545 type Target = can_mo0::RegisterBlock;
3546 #[inline(always)]
3547 fn deref(&self) -> &Self::Target {
3548 unsafe { &*Self::PTR }
3549 }
3550}
3551impl core::fmt::Debug for CAN_MO19 {
3552 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3553 f.debug_struct("CAN_MO19").finish()
3554 }
3555}
3556#[doc = "Controller Area Networks"]
3557pub use self::can_mo0 as can_mo19;
3558#[doc = "Controller Area Networks"]
3559pub struct CAN_MO20 {
3560 _marker: PhantomData<*const ()>,
3561}
3562unsafe impl Send for CAN_MO20 {}
3563impl CAN_MO20 {
3564 #[doc = r"Pointer to the register block"]
3565 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5280 as *const _;
3566 #[doc = r"Return the pointer to the register block"]
3567 #[inline(always)]
3568 pub const fn ptr() -> *const can_mo0::RegisterBlock {
3569 Self::PTR
3570 }
3571 #[doc = r" Steal an instance of this peripheral"]
3572 #[doc = r""]
3573 #[doc = r" # Safety"]
3574 #[doc = r""]
3575 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3576 #[doc = r" that may race with any existing instances, for example by only"]
3577 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3578 #[doc = r" original peripheral and using critical sections to coordinate"]
3579 #[doc = r" access between multiple new instances."]
3580 #[doc = r""]
3581 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3582 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3583 #[doc = r" no stolen instances are passed to such software."]
3584 pub unsafe fn steal() -> Self {
3585 Self { _marker: PhantomData }
3586 }
3587}
3588impl Deref for CAN_MO20 {
3589 type Target = can_mo0::RegisterBlock;
3590 #[inline(always)]
3591 fn deref(&self) -> &Self::Target {
3592 unsafe { &*Self::PTR }
3593 }
3594}
3595impl core::fmt::Debug for CAN_MO20 {
3596 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3597 f.debug_struct("CAN_MO20").finish()
3598 }
3599}
3600#[doc = "Controller Area Networks"]
3601pub use self::can_mo0 as can_mo20;
3602#[doc = "Controller Area Networks"]
3603pub struct CAN_MO21 {
3604 _marker: PhantomData<*const ()>,
3605}
3606unsafe impl Send for CAN_MO21 {}
3607impl CAN_MO21 {
3608 #[doc = r"Pointer to the register block"]
3609 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_52a0 as *const _;
3610 #[doc = r"Return the pointer to the register block"]
3611 #[inline(always)]
3612 pub const fn ptr() -> *const can_mo0::RegisterBlock {
3613 Self::PTR
3614 }
3615 #[doc = r" Steal an instance of this peripheral"]
3616 #[doc = r""]
3617 #[doc = r" # Safety"]
3618 #[doc = r""]
3619 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3620 #[doc = r" that may race with any existing instances, for example by only"]
3621 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3622 #[doc = r" original peripheral and using critical sections to coordinate"]
3623 #[doc = r" access between multiple new instances."]
3624 #[doc = r""]
3625 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3626 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3627 #[doc = r" no stolen instances are passed to such software."]
3628 pub unsafe fn steal() -> Self {
3629 Self { _marker: PhantomData }
3630 }
3631}
3632impl Deref for CAN_MO21 {
3633 type Target = can_mo0::RegisterBlock;
3634 #[inline(always)]
3635 fn deref(&self) -> &Self::Target {
3636 unsafe { &*Self::PTR }
3637 }
3638}
3639impl core::fmt::Debug for CAN_MO21 {
3640 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3641 f.debug_struct("CAN_MO21").finish()
3642 }
3643}
3644#[doc = "Controller Area Networks"]
3645pub use self::can_mo0 as can_mo21;
3646#[doc = "Controller Area Networks"]
3647pub struct CAN_MO22 {
3648 _marker: PhantomData<*const ()>,
3649}
3650unsafe impl Send for CAN_MO22 {}
3651impl CAN_MO22 {
3652 #[doc = r"Pointer to the register block"]
3653 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_52c0 as *const _;
3654 #[doc = r"Return the pointer to the register block"]
3655 #[inline(always)]
3656 pub const fn ptr() -> *const can_mo0::RegisterBlock {
3657 Self::PTR
3658 }
3659 #[doc = r" Steal an instance of this peripheral"]
3660 #[doc = r""]
3661 #[doc = r" # Safety"]
3662 #[doc = r""]
3663 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3664 #[doc = r" that may race with any existing instances, for example by only"]
3665 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3666 #[doc = r" original peripheral and using critical sections to coordinate"]
3667 #[doc = r" access between multiple new instances."]
3668 #[doc = r""]
3669 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3670 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3671 #[doc = r" no stolen instances are passed to such software."]
3672 pub unsafe fn steal() -> Self {
3673 Self { _marker: PhantomData }
3674 }
3675}
3676impl Deref for CAN_MO22 {
3677 type Target = can_mo0::RegisterBlock;
3678 #[inline(always)]
3679 fn deref(&self) -> &Self::Target {
3680 unsafe { &*Self::PTR }
3681 }
3682}
3683impl core::fmt::Debug for CAN_MO22 {
3684 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3685 f.debug_struct("CAN_MO22").finish()
3686 }
3687}
3688#[doc = "Controller Area Networks"]
3689pub use self::can_mo0 as can_mo22;
3690#[doc = "Controller Area Networks"]
3691pub struct CAN_MO23 {
3692 _marker: PhantomData<*const ()>,
3693}
3694unsafe impl Send for CAN_MO23 {}
3695impl CAN_MO23 {
3696 #[doc = r"Pointer to the register block"]
3697 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_52e0 as *const _;
3698 #[doc = r"Return the pointer to the register block"]
3699 #[inline(always)]
3700 pub const fn ptr() -> *const can_mo0::RegisterBlock {
3701 Self::PTR
3702 }
3703 #[doc = r" Steal an instance of this peripheral"]
3704 #[doc = r""]
3705 #[doc = r" # Safety"]
3706 #[doc = r""]
3707 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3708 #[doc = r" that may race with any existing instances, for example by only"]
3709 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3710 #[doc = r" original peripheral and using critical sections to coordinate"]
3711 #[doc = r" access between multiple new instances."]
3712 #[doc = r""]
3713 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3714 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3715 #[doc = r" no stolen instances are passed to such software."]
3716 pub unsafe fn steal() -> Self {
3717 Self { _marker: PhantomData }
3718 }
3719}
3720impl Deref for CAN_MO23 {
3721 type Target = can_mo0::RegisterBlock;
3722 #[inline(always)]
3723 fn deref(&self) -> &Self::Target {
3724 unsafe { &*Self::PTR }
3725 }
3726}
3727impl core::fmt::Debug for CAN_MO23 {
3728 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3729 f.debug_struct("CAN_MO23").finish()
3730 }
3731}
3732#[doc = "Controller Area Networks"]
3733pub use self::can_mo0 as can_mo23;
3734#[doc = "Controller Area Networks"]
3735pub struct CAN_MO24 {
3736 _marker: PhantomData<*const ()>,
3737}
3738unsafe impl Send for CAN_MO24 {}
3739impl CAN_MO24 {
3740 #[doc = r"Pointer to the register block"]
3741 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5300 as *const _;
3742 #[doc = r"Return the pointer to the register block"]
3743 #[inline(always)]
3744 pub const fn ptr() -> *const can_mo0::RegisterBlock {
3745 Self::PTR
3746 }
3747 #[doc = r" Steal an instance of this peripheral"]
3748 #[doc = r""]
3749 #[doc = r" # Safety"]
3750 #[doc = r""]
3751 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3752 #[doc = r" that may race with any existing instances, for example by only"]
3753 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3754 #[doc = r" original peripheral and using critical sections to coordinate"]
3755 #[doc = r" access between multiple new instances."]
3756 #[doc = r""]
3757 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3758 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3759 #[doc = r" no stolen instances are passed to such software."]
3760 pub unsafe fn steal() -> Self {
3761 Self { _marker: PhantomData }
3762 }
3763}
3764impl Deref for CAN_MO24 {
3765 type Target = can_mo0::RegisterBlock;
3766 #[inline(always)]
3767 fn deref(&self) -> &Self::Target {
3768 unsafe { &*Self::PTR }
3769 }
3770}
3771impl core::fmt::Debug for CAN_MO24 {
3772 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3773 f.debug_struct("CAN_MO24").finish()
3774 }
3775}
3776#[doc = "Controller Area Networks"]
3777pub use self::can_mo0 as can_mo24;
3778#[doc = "Controller Area Networks"]
3779pub struct CAN_MO25 {
3780 _marker: PhantomData<*const ()>,
3781}
3782unsafe impl Send for CAN_MO25 {}
3783impl CAN_MO25 {
3784 #[doc = r"Pointer to the register block"]
3785 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5320 as *const _;
3786 #[doc = r"Return the pointer to the register block"]
3787 #[inline(always)]
3788 pub const fn ptr() -> *const can_mo0::RegisterBlock {
3789 Self::PTR
3790 }
3791 #[doc = r" Steal an instance of this peripheral"]
3792 #[doc = r""]
3793 #[doc = r" # Safety"]
3794 #[doc = r""]
3795 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3796 #[doc = r" that may race with any existing instances, for example by only"]
3797 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3798 #[doc = r" original peripheral and using critical sections to coordinate"]
3799 #[doc = r" access between multiple new instances."]
3800 #[doc = r""]
3801 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3802 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3803 #[doc = r" no stolen instances are passed to such software."]
3804 pub unsafe fn steal() -> Self {
3805 Self { _marker: PhantomData }
3806 }
3807}
3808impl Deref for CAN_MO25 {
3809 type Target = can_mo0::RegisterBlock;
3810 #[inline(always)]
3811 fn deref(&self) -> &Self::Target {
3812 unsafe { &*Self::PTR }
3813 }
3814}
3815impl core::fmt::Debug for CAN_MO25 {
3816 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3817 f.debug_struct("CAN_MO25").finish()
3818 }
3819}
3820#[doc = "Controller Area Networks"]
3821pub use self::can_mo0 as can_mo25;
3822#[doc = "Controller Area Networks"]
3823pub struct CAN_MO26 {
3824 _marker: PhantomData<*const ()>,
3825}
3826unsafe impl Send for CAN_MO26 {}
3827impl CAN_MO26 {
3828 #[doc = r"Pointer to the register block"]
3829 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5340 as *const _;
3830 #[doc = r"Return the pointer to the register block"]
3831 #[inline(always)]
3832 pub const fn ptr() -> *const can_mo0::RegisterBlock {
3833 Self::PTR
3834 }
3835 #[doc = r" Steal an instance of this peripheral"]
3836 #[doc = r""]
3837 #[doc = r" # Safety"]
3838 #[doc = r""]
3839 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3840 #[doc = r" that may race with any existing instances, for example by only"]
3841 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3842 #[doc = r" original peripheral and using critical sections to coordinate"]
3843 #[doc = r" access between multiple new instances."]
3844 #[doc = r""]
3845 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3846 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3847 #[doc = r" no stolen instances are passed to such software."]
3848 pub unsafe fn steal() -> Self {
3849 Self { _marker: PhantomData }
3850 }
3851}
3852impl Deref for CAN_MO26 {
3853 type Target = can_mo0::RegisterBlock;
3854 #[inline(always)]
3855 fn deref(&self) -> &Self::Target {
3856 unsafe { &*Self::PTR }
3857 }
3858}
3859impl core::fmt::Debug for CAN_MO26 {
3860 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3861 f.debug_struct("CAN_MO26").finish()
3862 }
3863}
3864#[doc = "Controller Area Networks"]
3865pub use self::can_mo0 as can_mo26;
3866#[doc = "Controller Area Networks"]
3867pub struct CAN_MO27 {
3868 _marker: PhantomData<*const ()>,
3869}
3870unsafe impl Send for CAN_MO27 {}
3871impl CAN_MO27 {
3872 #[doc = r"Pointer to the register block"]
3873 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5360 as *const _;
3874 #[doc = r"Return the pointer to the register block"]
3875 #[inline(always)]
3876 pub const fn ptr() -> *const can_mo0::RegisterBlock {
3877 Self::PTR
3878 }
3879 #[doc = r" Steal an instance of this peripheral"]
3880 #[doc = r""]
3881 #[doc = r" # Safety"]
3882 #[doc = r""]
3883 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3884 #[doc = r" that may race with any existing instances, for example by only"]
3885 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3886 #[doc = r" original peripheral and using critical sections to coordinate"]
3887 #[doc = r" access between multiple new instances."]
3888 #[doc = r""]
3889 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3890 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3891 #[doc = r" no stolen instances are passed to such software."]
3892 pub unsafe fn steal() -> Self {
3893 Self { _marker: PhantomData }
3894 }
3895}
3896impl Deref for CAN_MO27 {
3897 type Target = can_mo0::RegisterBlock;
3898 #[inline(always)]
3899 fn deref(&self) -> &Self::Target {
3900 unsafe { &*Self::PTR }
3901 }
3902}
3903impl core::fmt::Debug for CAN_MO27 {
3904 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3905 f.debug_struct("CAN_MO27").finish()
3906 }
3907}
3908#[doc = "Controller Area Networks"]
3909pub use self::can_mo0 as can_mo27;
3910#[doc = "Controller Area Networks"]
3911pub struct CAN_MO28 {
3912 _marker: PhantomData<*const ()>,
3913}
3914unsafe impl Send for CAN_MO28 {}
3915impl CAN_MO28 {
3916 #[doc = r"Pointer to the register block"]
3917 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5380 as *const _;
3918 #[doc = r"Return the pointer to the register block"]
3919 #[inline(always)]
3920 pub const fn ptr() -> *const can_mo0::RegisterBlock {
3921 Self::PTR
3922 }
3923 #[doc = r" Steal an instance of this peripheral"]
3924 #[doc = r""]
3925 #[doc = r" # Safety"]
3926 #[doc = r""]
3927 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3928 #[doc = r" that may race with any existing instances, for example by only"]
3929 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3930 #[doc = r" original peripheral and using critical sections to coordinate"]
3931 #[doc = r" access between multiple new instances."]
3932 #[doc = r""]
3933 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3934 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3935 #[doc = r" no stolen instances are passed to such software."]
3936 pub unsafe fn steal() -> Self {
3937 Self { _marker: PhantomData }
3938 }
3939}
3940impl Deref for CAN_MO28 {
3941 type Target = can_mo0::RegisterBlock;
3942 #[inline(always)]
3943 fn deref(&self) -> &Self::Target {
3944 unsafe { &*Self::PTR }
3945 }
3946}
3947impl core::fmt::Debug for CAN_MO28 {
3948 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3949 f.debug_struct("CAN_MO28").finish()
3950 }
3951}
3952#[doc = "Controller Area Networks"]
3953pub use self::can_mo0 as can_mo28;
3954#[doc = "Controller Area Networks"]
3955pub struct CAN_MO29 {
3956 _marker: PhantomData<*const ()>,
3957}
3958unsafe impl Send for CAN_MO29 {}
3959impl CAN_MO29 {
3960 #[doc = r"Pointer to the register block"]
3961 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_53a0 as *const _;
3962 #[doc = r"Return the pointer to the register block"]
3963 #[inline(always)]
3964 pub const fn ptr() -> *const can_mo0::RegisterBlock {
3965 Self::PTR
3966 }
3967 #[doc = r" Steal an instance of this peripheral"]
3968 #[doc = r""]
3969 #[doc = r" # Safety"]
3970 #[doc = r""]
3971 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3972 #[doc = r" that may race with any existing instances, for example by only"]
3973 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3974 #[doc = r" original peripheral and using critical sections to coordinate"]
3975 #[doc = r" access between multiple new instances."]
3976 #[doc = r""]
3977 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3978 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3979 #[doc = r" no stolen instances are passed to such software."]
3980 pub unsafe fn steal() -> Self {
3981 Self { _marker: PhantomData }
3982 }
3983}
3984impl Deref for CAN_MO29 {
3985 type Target = can_mo0::RegisterBlock;
3986 #[inline(always)]
3987 fn deref(&self) -> &Self::Target {
3988 unsafe { &*Self::PTR }
3989 }
3990}
3991impl core::fmt::Debug for CAN_MO29 {
3992 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3993 f.debug_struct("CAN_MO29").finish()
3994 }
3995}
3996#[doc = "Controller Area Networks"]
3997pub use self::can_mo0 as can_mo29;
3998#[doc = "Controller Area Networks"]
3999pub struct CAN_MO30 {
4000 _marker: PhantomData<*const ()>,
4001}
4002unsafe impl Send for CAN_MO30 {}
4003impl CAN_MO30 {
4004 #[doc = r"Pointer to the register block"]
4005 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_53c0 as *const _;
4006 #[doc = r"Return the pointer to the register block"]
4007 #[inline(always)]
4008 pub const fn ptr() -> *const can_mo0::RegisterBlock {
4009 Self::PTR
4010 }
4011 #[doc = r" Steal an instance of this peripheral"]
4012 #[doc = r""]
4013 #[doc = r" # Safety"]
4014 #[doc = r""]
4015 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4016 #[doc = r" that may race with any existing instances, for example by only"]
4017 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4018 #[doc = r" original peripheral and using critical sections to coordinate"]
4019 #[doc = r" access between multiple new instances."]
4020 #[doc = r""]
4021 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4022 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4023 #[doc = r" no stolen instances are passed to such software."]
4024 pub unsafe fn steal() -> Self {
4025 Self { _marker: PhantomData }
4026 }
4027}
4028impl Deref for CAN_MO30 {
4029 type Target = can_mo0::RegisterBlock;
4030 #[inline(always)]
4031 fn deref(&self) -> &Self::Target {
4032 unsafe { &*Self::PTR }
4033 }
4034}
4035impl core::fmt::Debug for CAN_MO30 {
4036 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4037 f.debug_struct("CAN_MO30").finish()
4038 }
4039}
4040#[doc = "Controller Area Networks"]
4041pub use self::can_mo0 as can_mo30;
4042#[doc = "Controller Area Networks"]
4043pub struct CAN_MO31 {
4044 _marker: PhantomData<*const ()>,
4045}
4046unsafe impl Send for CAN_MO31 {}
4047impl CAN_MO31 {
4048 #[doc = r"Pointer to the register block"]
4049 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_53e0 as *const _;
4050 #[doc = r"Return the pointer to the register block"]
4051 #[inline(always)]
4052 pub const fn ptr() -> *const can_mo0::RegisterBlock {
4053 Self::PTR
4054 }
4055 #[doc = r" Steal an instance of this peripheral"]
4056 #[doc = r""]
4057 #[doc = r" # Safety"]
4058 #[doc = r""]
4059 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4060 #[doc = r" that may race with any existing instances, for example by only"]
4061 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4062 #[doc = r" original peripheral and using critical sections to coordinate"]
4063 #[doc = r" access between multiple new instances."]
4064 #[doc = r""]
4065 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4066 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4067 #[doc = r" no stolen instances are passed to such software."]
4068 pub unsafe fn steal() -> Self {
4069 Self { _marker: PhantomData }
4070 }
4071}
4072impl Deref for CAN_MO31 {
4073 type Target = can_mo0::RegisterBlock;
4074 #[inline(always)]
4075 fn deref(&self) -> &Self::Target {
4076 unsafe { &*Self::PTR }
4077 }
4078}
4079impl core::fmt::Debug for CAN_MO31 {
4080 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4081 f.debug_struct("CAN_MO31").finish()
4082 }
4083}
4084#[doc = "Controller Area Networks"]
4085pub use self::can_mo0 as can_mo31;
4086#[doc = "Controller Area Networks"]
4087pub struct CAN_MO32 {
4088 _marker: PhantomData<*const ()>,
4089}
4090unsafe impl Send for CAN_MO32 {}
4091impl CAN_MO32 {
4092 #[doc = r"Pointer to the register block"]
4093 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5400 as *const _;
4094 #[doc = r"Return the pointer to the register block"]
4095 #[inline(always)]
4096 pub const fn ptr() -> *const can_mo0::RegisterBlock {
4097 Self::PTR
4098 }
4099 #[doc = r" Steal an instance of this peripheral"]
4100 #[doc = r""]
4101 #[doc = r" # Safety"]
4102 #[doc = r""]
4103 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4104 #[doc = r" that may race with any existing instances, for example by only"]
4105 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4106 #[doc = r" original peripheral and using critical sections to coordinate"]
4107 #[doc = r" access between multiple new instances."]
4108 #[doc = r""]
4109 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4110 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4111 #[doc = r" no stolen instances are passed to such software."]
4112 pub unsafe fn steal() -> Self {
4113 Self { _marker: PhantomData }
4114 }
4115}
4116impl Deref for CAN_MO32 {
4117 type Target = can_mo0::RegisterBlock;
4118 #[inline(always)]
4119 fn deref(&self) -> &Self::Target {
4120 unsafe { &*Self::PTR }
4121 }
4122}
4123impl core::fmt::Debug for CAN_MO32 {
4124 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4125 f.debug_struct("CAN_MO32").finish()
4126 }
4127}
4128#[doc = "Controller Area Networks"]
4129pub use self::can_mo0 as can_mo32;
4130#[doc = "Controller Area Networks"]
4131pub struct CAN_MO33 {
4132 _marker: PhantomData<*const ()>,
4133}
4134unsafe impl Send for CAN_MO33 {}
4135impl CAN_MO33 {
4136 #[doc = r"Pointer to the register block"]
4137 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5420 as *const _;
4138 #[doc = r"Return the pointer to the register block"]
4139 #[inline(always)]
4140 pub const fn ptr() -> *const can_mo0::RegisterBlock {
4141 Self::PTR
4142 }
4143 #[doc = r" Steal an instance of this peripheral"]
4144 #[doc = r""]
4145 #[doc = r" # Safety"]
4146 #[doc = r""]
4147 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4148 #[doc = r" that may race with any existing instances, for example by only"]
4149 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4150 #[doc = r" original peripheral and using critical sections to coordinate"]
4151 #[doc = r" access between multiple new instances."]
4152 #[doc = r""]
4153 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4154 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4155 #[doc = r" no stolen instances are passed to such software."]
4156 pub unsafe fn steal() -> Self {
4157 Self { _marker: PhantomData }
4158 }
4159}
4160impl Deref for CAN_MO33 {
4161 type Target = can_mo0::RegisterBlock;
4162 #[inline(always)]
4163 fn deref(&self) -> &Self::Target {
4164 unsafe { &*Self::PTR }
4165 }
4166}
4167impl core::fmt::Debug for CAN_MO33 {
4168 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4169 f.debug_struct("CAN_MO33").finish()
4170 }
4171}
4172#[doc = "Controller Area Networks"]
4173pub use self::can_mo0 as can_mo33;
4174#[doc = "Controller Area Networks"]
4175pub struct CAN_MO34 {
4176 _marker: PhantomData<*const ()>,
4177}
4178unsafe impl Send for CAN_MO34 {}
4179impl CAN_MO34 {
4180 #[doc = r"Pointer to the register block"]
4181 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5440 as *const _;
4182 #[doc = r"Return the pointer to the register block"]
4183 #[inline(always)]
4184 pub const fn ptr() -> *const can_mo0::RegisterBlock {
4185 Self::PTR
4186 }
4187 #[doc = r" Steal an instance of this peripheral"]
4188 #[doc = r""]
4189 #[doc = r" # Safety"]
4190 #[doc = r""]
4191 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4192 #[doc = r" that may race with any existing instances, for example by only"]
4193 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4194 #[doc = r" original peripheral and using critical sections to coordinate"]
4195 #[doc = r" access between multiple new instances."]
4196 #[doc = r""]
4197 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4198 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4199 #[doc = r" no stolen instances are passed to such software."]
4200 pub unsafe fn steal() -> Self {
4201 Self { _marker: PhantomData }
4202 }
4203}
4204impl Deref for CAN_MO34 {
4205 type Target = can_mo0::RegisterBlock;
4206 #[inline(always)]
4207 fn deref(&self) -> &Self::Target {
4208 unsafe { &*Self::PTR }
4209 }
4210}
4211impl core::fmt::Debug for CAN_MO34 {
4212 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4213 f.debug_struct("CAN_MO34").finish()
4214 }
4215}
4216#[doc = "Controller Area Networks"]
4217pub use self::can_mo0 as can_mo34;
4218#[doc = "Controller Area Networks"]
4219pub struct CAN_MO35 {
4220 _marker: PhantomData<*const ()>,
4221}
4222unsafe impl Send for CAN_MO35 {}
4223impl CAN_MO35 {
4224 #[doc = r"Pointer to the register block"]
4225 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5460 as *const _;
4226 #[doc = r"Return the pointer to the register block"]
4227 #[inline(always)]
4228 pub const fn ptr() -> *const can_mo0::RegisterBlock {
4229 Self::PTR
4230 }
4231 #[doc = r" Steal an instance of this peripheral"]
4232 #[doc = r""]
4233 #[doc = r" # Safety"]
4234 #[doc = r""]
4235 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4236 #[doc = r" that may race with any existing instances, for example by only"]
4237 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4238 #[doc = r" original peripheral and using critical sections to coordinate"]
4239 #[doc = r" access between multiple new instances."]
4240 #[doc = r""]
4241 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4242 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4243 #[doc = r" no stolen instances are passed to such software."]
4244 pub unsafe fn steal() -> Self {
4245 Self { _marker: PhantomData }
4246 }
4247}
4248impl Deref for CAN_MO35 {
4249 type Target = can_mo0::RegisterBlock;
4250 #[inline(always)]
4251 fn deref(&self) -> &Self::Target {
4252 unsafe { &*Self::PTR }
4253 }
4254}
4255impl core::fmt::Debug for CAN_MO35 {
4256 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4257 f.debug_struct("CAN_MO35").finish()
4258 }
4259}
4260#[doc = "Controller Area Networks"]
4261pub use self::can_mo0 as can_mo35;
4262#[doc = "Controller Area Networks"]
4263pub struct CAN_MO36 {
4264 _marker: PhantomData<*const ()>,
4265}
4266unsafe impl Send for CAN_MO36 {}
4267impl CAN_MO36 {
4268 #[doc = r"Pointer to the register block"]
4269 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5480 as *const _;
4270 #[doc = r"Return the pointer to the register block"]
4271 #[inline(always)]
4272 pub const fn ptr() -> *const can_mo0::RegisterBlock {
4273 Self::PTR
4274 }
4275 #[doc = r" Steal an instance of this peripheral"]
4276 #[doc = r""]
4277 #[doc = r" # Safety"]
4278 #[doc = r""]
4279 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4280 #[doc = r" that may race with any existing instances, for example by only"]
4281 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4282 #[doc = r" original peripheral and using critical sections to coordinate"]
4283 #[doc = r" access between multiple new instances."]
4284 #[doc = r""]
4285 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4286 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4287 #[doc = r" no stolen instances are passed to such software."]
4288 pub unsafe fn steal() -> Self {
4289 Self { _marker: PhantomData }
4290 }
4291}
4292impl Deref for CAN_MO36 {
4293 type Target = can_mo0::RegisterBlock;
4294 #[inline(always)]
4295 fn deref(&self) -> &Self::Target {
4296 unsafe { &*Self::PTR }
4297 }
4298}
4299impl core::fmt::Debug for CAN_MO36 {
4300 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4301 f.debug_struct("CAN_MO36").finish()
4302 }
4303}
4304#[doc = "Controller Area Networks"]
4305pub use self::can_mo0 as can_mo36;
4306#[doc = "Controller Area Networks"]
4307pub struct CAN_MO37 {
4308 _marker: PhantomData<*const ()>,
4309}
4310unsafe impl Send for CAN_MO37 {}
4311impl CAN_MO37 {
4312 #[doc = r"Pointer to the register block"]
4313 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_54a0 as *const _;
4314 #[doc = r"Return the pointer to the register block"]
4315 #[inline(always)]
4316 pub const fn ptr() -> *const can_mo0::RegisterBlock {
4317 Self::PTR
4318 }
4319 #[doc = r" Steal an instance of this peripheral"]
4320 #[doc = r""]
4321 #[doc = r" # Safety"]
4322 #[doc = r""]
4323 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4324 #[doc = r" that may race with any existing instances, for example by only"]
4325 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4326 #[doc = r" original peripheral and using critical sections to coordinate"]
4327 #[doc = r" access between multiple new instances."]
4328 #[doc = r""]
4329 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4330 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4331 #[doc = r" no stolen instances are passed to such software."]
4332 pub unsafe fn steal() -> Self {
4333 Self { _marker: PhantomData }
4334 }
4335}
4336impl Deref for CAN_MO37 {
4337 type Target = can_mo0::RegisterBlock;
4338 #[inline(always)]
4339 fn deref(&self) -> &Self::Target {
4340 unsafe { &*Self::PTR }
4341 }
4342}
4343impl core::fmt::Debug for CAN_MO37 {
4344 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4345 f.debug_struct("CAN_MO37").finish()
4346 }
4347}
4348#[doc = "Controller Area Networks"]
4349pub use self::can_mo0 as can_mo37;
4350#[doc = "Controller Area Networks"]
4351pub struct CAN_MO38 {
4352 _marker: PhantomData<*const ()>,
4353}
4354unsafe impl Send for CAN_MO38 {}
4355impl CAN_MO38 {
4356 #[doc = r"Pointer to the register block"]
4357 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_54c0 as *const _;
4358 #[doc = r"Return the pointer to the register block"]
4359 #[inline(always)]
4360 pub const fn ptr() -> *const can_mo0::RegisterBlock {
4361 Self::PTR
4362 }
4363 #[doc = r" Steal an instance of this peripheral"]
4364 #[doc = r""]
4365 #[doc = r" # Safety"]
4366 #[doc = r""]
4367 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4368 #[doc = r" that may race with any existing instances, for example by only"]
4369 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4370 #[doc = r" original peripheral and using critical sections to coordinate"]
4371 #[doc = r" access between multiple new instances."]
4372 #[doc = r""]
4373 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4374 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4375 #[doc = r" no stolen instances are passed to such software."]
4376 pub unsafe fn steal() -> Self {
4377 Self { _marker: PhantomData }
4378 }
4379}
4380impl Deref for CAN_MO38 {
4381 type Target = can_mo0::RegisterBlock;
4382 #[inline(always)]
4383 fn deref(&self) -> &Self::Target {
4384 unsafe { &*Self::PTR }
4385 }
4386}
4387impl core::fmt::Debug for CAN_MO38 {
4388 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4389 f.debug_struct("CAN_MO38").finish()
4390 }
4391}
4392#[doc = "Controller Area Networks"]
4393pub use self::can_mo0 as can_mo38;
4394#[doc = "Controller Area Networks"]
4395pub struct CAN_MO39 {
4396 _marker: PhantomData<*const ()>,
4397}
4398unsafe impl Send for CAN_MO39 {}
4399impl CAN_MO39 {
4400 #[doc = r"Pointer to the register block"]
4401 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_54e0 as *const _;
4402 #[doc = r"Return the pointer to the register block"]
4403 #[inline(always)]
4404 pub const fn ptr() -> *const can_mo0::RegisterBlock {
4405 Self::PTR
4406 }
4407 #[doc = r" Steal an instance of this peripheral"]
4408 #[doc = r""]
4409 #[doc = r" # Safety"]
4410 #[doc = r""]
4411 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4412 #[doc = r" that may race with any existing instances, for example by only"]
4413 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4414 #[doc = r" original peripheral and using critical sections to coordinate"]
4415 #[doc = r" access between multiple new instances."]
4416 #[doc = r""]
4417 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4418 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4419 #[doc = r" no stolen instances are passed to such software."]
4420 pub unsafe fn steal() -> Self {
4421 Self { _marker: PhantomData }
4422 }
4423}
4424impl Deref for CAN_MO39 {
4425 type Target = can_mo0::RegisterBlock;
4426 #[inline(always)]
4427 fn deref(&self) -> &Self::Target {
4428 unsafe { &*Self::PTR }
4429 }
4430}
4431impl core::fmt::Debug for CAN_MO39 {
4432 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4433 f.debug_struct("CAN_MO39").finish()
4434 }
4435}
4436#[doc = "Controller Area Networks"]
4437pub use self::can_mo0 as can_mo39;
4438#[doc = "Controller Area Networks"]
4439pub struct CAN_MO40 {
4440 _marker: PhantomData<*const ()>,
4441}
4442unsafe impl Send for CAN_MO40 {}
4443impl CAN_MO40 {
4444 #[doc = r"Pointer to the register block"]
4445 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5500 as *const _;
4446 #[doc = r"Return the pointer to the register block"]
4447 #[inline(always)]
4448 pub const fn ptr() -> *const can_mo0::RegisterBlock {
4449 Self::PTR
4450 }
4451 #[doc = r" Steal an instance of this peripheral"]
4452 #[doc = r""]
4453 #[doc = r" # Safety"]
4454 #[doc = r""]
4455 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4456 #[doc = r" that may race with any existing instances, for example by only"]
4457 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4458 #[doc = r" original peripheral and using critical sections to coordinate"]
4459 #[doc = r" access between multiple new instances."]
4460 #[doc = r""]
4461 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4462 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4463 #[doc = r" no stolen instances are passed to such software."]
4464 pub unsafe fn steal() -> Self {
4465 Self { _marker: PhantomData }
4466 }
4467}
4468impl Deref for CAN_MO40 {
4469 type Target = can_mo0::RegisterBlock;
4470 #[inline(always)]
4471 fn deref(&self) -> &Self::Target {
4472 unsafe { &*Self::PTR }
4473 }
4474}
4475impl core::fmt::Debug for CAN_MO40 {
4476 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4477 f.debug_struct("CAN_MO40").finish()
4478 }
4479}
4480#[doc = "Controller Area Networks"]
4481pub use self::can_mo0 as can_mo40;
4482#[doc = "Controller Area Networks"]
4483pub struct CAN_MO41 {
4484 _marker: PhantomData<*const ()>,
4485}
4486unsafe impl Send for CAN_MO41 {}
4487impl CAN_MO41 {
4488 #[doc = r"Pointer to the register block"]
4489 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5520 as *const _;
4490 #[doc = r"Return the pointer to the register block"]
4491 #[inline(always)]
4492 pub const fn ptr() -> *const can_mo0::RegisterBlock {
4493 Self::PTR
4494 }
4495 #[doc = r" Steal an instance of this peripheral"]
4496 #[doc = r""]
4497 #[doc = r" # Safety"]
4498 #[doc = r""]
4499 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4500 #[doc = r" that may race with any existing instances, for example by only"]
4501 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4502 #[doc = r" original peripheral and using critical sections to coordinate"]
4503 #[doc = r" access between multiple new instances."]
4504 #[doc = r""]
4505 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4506 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4507 #[doc = r" no stolen instances are passed to such software."]
4508 pub unsafe fn steal() -> Self {
4509 Self { _marker: PhantomData }
4510 }
4511}
4512impl Deref for CAN_MO41 {
4513 type Target = can_mo0::RegisterBlock;
4514 #[inline(always)]
4515 fn deref(&self) -> &Self::Target {
4516 unsafe { &*Self::PTR }
4517 }
4518}
4519impl core::fmt::Debug for CAN_MO41 {
4520 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4521 f.debug_struct("CAN_MO41").finish()
4522 }
4523}
4524#[doc = "Controller Area Networks"]
4525pub use self::can_mo0 as can_mo41;
4526#[doc = "Controller Area Networks"]
4527pub struct CAN_MO42 {
4528 _marker: PhantomData<*const ()>,
4529}
4530unsafe impl Send for CAN_MO42 {}
4531impl CAN_MO42 {
4532 #[doc = r"Pointer to the register block"]
4533 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5540 as *const _;
4534 #[doc = r"Return the pointer to the register block"]
4535 #[inline(always)]
4536 pub const fn ptr() -> *const can_mo0::RegisterBlock {
4537 Self::PTR
4538 }
4539 #[doc = r" Steal an instance of this peripheral"]
4540 #[doc = r""]
4541 #[doc = r" # Safety"]
4542 #[doc = r""]
4543 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4544 #[doc = r" that may race with any existing instances, for example by only"]
4545 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4546 #[doc = r" original peripheral and using critical sections to coordinate"]
4547 #[doc = r" access between multiple new instances."]
4548 #[doc = r""]
4549 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4550 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4551 #[doc = r" no stolen instances are passed to such software."]
4552 pub unsafe fn steal() -> Self {
4553 Self { _marker: PhantomData }
4554 }
4555}
4556impl Deref for CAN_MO42 {
4557 type Target = can_mo0::RegisterBlock;
4558 #[inline(always)]
4559 fn deref(&self) -> &Self::Target {
4560 unsafe { &*Self::PTR }
4561 }
4562}
4563impl core::fmt::Debug for CAN_MO42 {
4564 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4565 f.debug_struct("CAN_MO42").finish()
4566 }
4567}
4568#[doc = "Controller Area Networks"]
4569pub use self::can_mo0 as can_mo42;
4570#[doc = "Controller Area Networks"]
4571pub struct CAN_MO43 {
4572 _marker: PhantomData<*const ()>,
4573}
4574unsafe impl Send for CAN_MO43 {}
4575impl CAN_MO43 {
4576 #[doc = r"Pointer to the register block"]
4577 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5560 as *const _;
4578 #[doc = r"Return the pointer to the register block"]
4579 #[inline(always)]
4580 pub const fn ptr() -> *const can_mo0::RegisterBlock {
4581 Self::PTR
4582 }
4583 #[doc = r" Steal an instance of this peripheral"]
4584 #[doc = r""]
4585 #[doc = r" # Safety"]
4586 #[doc = r""]
4587 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4588 #[doc = r" that may race with any existing instances, for example by only"]
4589 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4590 #[doc = r" original peripheral and using critical sections to coordinate"]
4591 #[doc = r" access between multiple new instances."]
4592 #[doc = r""]
4593 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4594 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4595 #[doc = r" no stolen instances are passed to such software."]
4596 pub unsafe fn steal() -> Self {
4597 Self { _marker: PhantomData }
4598 }
4599}
4600impl Deref for CAN_MO43 {
4601 type Target = can_mo0::RegisterBlock;
4602 #[inline(always)]
4603 fn deref(&self) -> &Self::Target {
4604 unsafe { &*Self::PTR }
4605 }
4606}
4607impl core::fmt::Debug for CAN_MO43 {
4608 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4609 f.debug_struct("CAN_MO43").finish()
4610 }
4611}
4612#[doc = "Controller Area Networks"]
4613pub use self::can_mo0 as can_mo43;
4614#[doc = "Controller Area Networks"]
4615pub struct CAN_MO44 {
4616 _marker: PhantomData<*const ()>,
4617}
4618unsafe impl Send for CAN_MO44 {}
4619impl CAN_MO44 {
4620 #[doc = r"Pointer to the register block"]
4621 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5580 as *const _;
4622 #[doc = r"Return the pointer to the register block"]
4623 #[inline(always)]
4624 pub const fn ptr() -> *const can_mo0::RegisterBlock {
4625 Self::PTR
4626 }
4627 #[doc = r" Steal an instance of this peripheral"]
4628 #[doc = r""]
4629 #[doc = r" # Safety"]
4630 #[doc = r""]
4631 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4632 #[doc = r" that may race with any existing instances, for example by only"]
4633 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4634 #[doc = r" original peripheral and using critical sections to coordinate"]
4635 #[doc = r" access between multiple new instances."]
4636 #[doc = r""]
4637 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4638 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4639 #[doc = r" no stolen instances are passed to such software."]
4640 pub unsafe fn steal() -> Self {
4641 Self { _marker: PhantomData }
4642 }
4643}
4644impl Deref for CAN_MO44 {
4645 type Target = can_mo0::RegisterBlock;
4646 #[inline(always)]
4647 fn deref(&self) -> &Self::Target {
4648 unsafe { &*Self::PTR }
4649 }
4650}
4651impl core::fmt::Debug for CAN_MO44 {
4652 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4653 f.debug_struct("CAN_MO44").finish()
4654 }
4655}
4656#[doc = "Controller Area Networks"]
4657pub use self::can_mo0 as can_mo44;
4658#[doc = "Controller Area Networks"]
4659pub struct CAN_MO45 {
4660 _marker: PhantomData<*const ()>,
4661}
4662unsafe impl Send for CAN_MO45 {}
4663impl CAN_MO45 {
4664 #[doc = r"Pointer to the register block"]
4665 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_55a0 as *const _;
4666 #[doc = r"Return the pointer to the register block"]
4667 #[inline(always)]
4668 pub const fn ptr() -> *const can_mo0::RegisterBlock {
4669 Self::PTR
4670 }
4671 #[doc = r" Steal an instance of this peripheral"]
4672 #[doc = r""]
4673 #[doc = r" # Safety"]
4674 #[doc = r""]
4675 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4676 #[doc = r" that may race with any existing instances, for example by only"]
4677 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4678 #[doc = r" original peripheral and using critical sections to coordinate"]
4679 #[doc = r" access between multiple new instances."]
4680 #[doc = r""]
4681 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4682 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4683 #[doc = r" no stolen instances are passed to such software."]
4684 pub unsafe fn steal() -> Self {
4685 Self { _marker: PhantomData }
4686 }
4687}
4688impl Deref for CAN_MO45 {
4689 type Target = can_mo0::RegisterBlock;
4690 #[inline(always)]
4691 fn deref(&self) -> &Self::Target {
4692 unsafe { &*Self::PTR }
4693 }
4694}
4695impl core::fmt::Debug for CAN_MO45 {
4696 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4697 f.debug_struct("CAN_MO45").finish()
4698 }
4699}
4700#[doc = "Controller Area Networks"]
4701pub use self::can_mo0 as can_mo45;
4702#[doc = "Controller Area Networks"]
4703pub struct CAN_MO46 {
4704 _marker: PhantomData<*const ()>,
4705}
4706unsafe impl Send for CAN_MO46 {}
4707impl CAN_MO46 {
4708 #[doc = r"Pointer to the register block"]
4709 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_55c0 as *const _;
4710 #[doc = r"Return the pointer to the register block"]
4711 #[inline(always)]
4712 pub const fn ptr() -> *const can_mo0::RegisterBlock {
4713 Self::PTR
4714 }
4715 #[doc = r" Steal an instance of this peripheral"]
4716 #[doc = r""]
4717 #[doc = r" # Safety"]
4718 #[doc = r""]
4719 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4720 #[doc = r" that may race with any existing instances, for example by only"]
4721 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4722 #[doc = r" original peripheral and using critical sections to coordinate"]
4723 #[doc = r" access between multiple new instances."]
4724 #[doc = r""]
4725 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4726 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4727 #[doc = r" no stolen instances are passed to such software."]
4728 pub unsafe fn steal() -> Self {
4729 Self { _marker: PhantomData }
4730 }
4731}
4732impl Deref for CAN_MO46 {
4733 type Target = can_mo0::RegisterBlock;
4734 #[inline(always)]
4735 fn deref(&self) -> &Self::Target {
4736 unsafe { &*Self::PTR }
4737 }
4738}
4739impl core::fmt::Debug for CAN_MO46 {
4740 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4741 f.debug_struct("CAN_MO46").finish()
4742 }
4743}
4744#[doc = "Controller Area Networks"]
4745pub use self::can_mo0 as can_mo46;
4746#[doc = "Controller Area Networks"]
4747pub struct CAN_MO47 {
4748 _marker: PhantomData<*const ()>,
4749}
4750unsafe impl Send for CAN_MO47 {}
4751impl CAN_MO47 {
4752 #[doc = r"Pointer to the register block"]
4753 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_55e0 as *const _;
4754 #[doc = r"Return the pointer to the register block"]
4755 #[inline(always)]
4756 pub const fn ptr() -> *const can_mo0::RegisterBlock {
4757 Self::PTR
4758 }
4759 #[doc = r" Steal an instance of this peripheral"]
4760 #[doc = r""]
4761 #[doc = r" # Safety"]
4762 #[doc = r""]
4763 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4764 #[doc = r" that may race with any existing instances, for example by only"]
4765 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4766 #[doc = r" original peripheral and using critical sections to coordinate"]
4767 #[doc = r" access between multiple new instances."]
4768 #[doc = r""]
4769 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4770 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4771 #[doc = r" no stolen instances are passed to such software."]
4772 pub unsafe fn steal() -> Self {
4773 Self { _marker: PhantomData }
4774 }
4775}
4776impl Deref for CAN_MO47 {
4777 type Target = can_mo0::RegisterBlock;
4778 #[inline(always)]
4779 fn deref(&self) -> &Self::Target {
4780 unsafe { &*Self::PTR }
4781 }
4782}
4783impl core::fmt::Debug for CAN_MO47 {
4784 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4785 f.debug_struct("CAN_MO47").finish()
4786 }
4787}
4788#[doc = "Controller Area Networks"]
4789pub use self::can_mo0 as can_mo47;
4790#[doc = "Controller Area Networks"]
4791pub struct CAN_MO48 {
4792 _marker: PhantomData<*const ()>,
4793}
4794unsafe impl Send for CAN_MO48 {}
4795impl CAN_MO48 {
4796 #[doc = r"Pointer to the register block"]
4797 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5600 as *const _;
4798 #[doc = r"Return the pointer to the register block"]
4799 #[inline(always)]
4800 pub const fn ptr() -> *const can_mo0::RegisterBlock {
4801 Self::PTR
4802 }
4803 #[doc = r" Steal an instance of this peripheral"]
4804 #[doc = r""]
4805 #[doc = r" # Safety"]
4806 #[doc = r""]
4807 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4808 #[doc = r" that may race with any existing instances, for example by only"]
4809 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4810 #[doc = r" original peripheral and using critical sections to coordinate"]
4811 #[doc = r" access between multiple new instances."]
4812 #[doc = r""]
4813 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4814 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4815 #[doc = r" no stolen instances are passed to such software."]
4816 pub unsafe fn steal() -> Self {
4817 Self { _marker: PhantomData }
4818 }
4819}
4820impl Deref for CAN_MO48 {
4821 type Target = can_mo0::RegisterBlock;
4822 #[inline(always)]
4823 fn deref(&self) -> &Self::Target {
4824 unsafe { &*Self::PTR }
4825 }
4826}
4827impl core::fmt::Debug for CAN_MO48 {
4828 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4829 f.debug_struct("CAN_MO48").finish()
4830 }
4831}
4832#[doc = "Controller Area Networks"]
4833pub use self::can_mo0 as can_mo48;
4834#[doc = "Controller Area Networks"]
4835pub struct CAN_MO49 {
4836 _marker: PhantomData<*const ()>,
4837}
4838unsafe impl Send for CAN_MO49 {}
4839impl CAN_MO49 {
4840 #[doc = r"Pointer to the register block"]
4841 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5620 as *const _;
4842 #[doc = r"Return the pointer to the register block"]
4843 #[inline(always)]
4844 pub const fn ptr() -> *const can_mo0::RegisterBlock {
4845 Self::PTR
4846 }
4847 #[doc = r" Steal an instance of this peripheral"]
4848 #[doc = r""]
4849 #[doc = r" # Safety"]
4850 #[doc = r""]
4851 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4852 #[doc = r" that may race with any existing instances, for example by only"]
4853 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4854 #[doc = r" original peripheral and using critical sections to coordinate"]
4855 #[doc = r" access between multiple new instances."]
4856 #[doc = r""]
4857 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4858 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4859 #[doc = r" no stolen instances are passed to such software."]
4860 pub unsafe fn steal() -> Self {
4861 Self { _marker: PhantomData }
4862 }
4863}
4864impl Deref for CAN_MO49 {
4865 type Target = can_mo0::RegisterBlock;
4866 #[inline(always)]
4867 fn deref(&self) -> &Self::Target {
4868 unsafe { &*Self::PTR }
4869 }
4870}
4871impl core::fmt::Debug for CAN_MO49 {
4872 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4873 f.debug_struct("CAN_MO49").finish()
4874 }
4875}
4876#[doc = "Controller Area Networks"]
4877pub use self::can_mo0 as can_mo49;
4878#[doc = "Controller Area Networks"]
4879pub struct CAN_MO50 {
4880 _marker: PhantomData<*const ()>,
4881}
4882unsafe impl Send for CAN_MO50 {}
4883impl CAN_MO50 {
4884 #[doc = r"Pointer to the register block"]
4885 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5640 as *const _;
4886 #[doc = r"Return the pointer to the register block"]
4887 #[inline(always)]
4888 pub const fn ptr() -> *const can_mo0::RegisterBlock {
4889 Self::PTR
4890 }
4891 #[doc = r" Steal an instance of this peripheral"]
4892 #[doc = r""]
4893 #[doc = r" # Safety"]
4894 #[doc = r""]
4895 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4896 #[doc = r" that may race with any existing instances, for example by only"]
4897 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4898 #[doc = r" original peripheral and using critical sections to coordinate"]
4899 #[doc = r" access between multiple new instances."]
4900 #[doc = r""]
4901 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4902 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4903 #[doc = r" no stolen instances are passed to such software."]
4904 pub unsafe fn steal() -> Self {
4905 Self { _marker: PhantomData }
4906 }
4907}
4908impl Deref for CAN_MO50 {
4909 type Target = can_mo0::RegisterBlock;
4910 #[inline(always)]
4911 fn deref(&self) -> &Self::Target {
4912 unsafe { &*Self::PTR }
4913 }
4914}
4915impl core::fmt::Debug for CAN_MO50 {
4916 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4917 f.debug_struct("CAN_MO50").finish()
4918 }
4919}
4920#[doc = "Controller Area Networks"]
4921pub use self::can_mo0 as can_mo50;
4922#[doc = "Controller Area Networks"]
4923pub struct CAN_MO51 {
4924 _marker: PhantomData<*const ()>,
4925}
4926unsafe impl Send for CAN_MO51 {}
4927impl CAN_MO51 {
4928 #[doc = r"Pointer to the register block"]
4929 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5660 as *const _;
4930 #[doc = r"Return the pointer to the register block"]
4931 #[inline(always)]
4932 pub const fn ptr() -> *const can_mo0::RegisterBlock {
4933 Self::PTR
4934 }
4935 #[doc = r" Steal an instance of this peripheral"]
4936 #[doc = r""]
4937 #[doc = r" # Safety"]
4938 #[doc = r""]
4939 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4940 #[doc = r" that may race with any existing instances, for example by only"]
4941 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4942 #[doc = r" original peripheral and using critical sections to coordinate"]
4943 #[doc = r" access between multiple new instances."]
4944 #[doc = r""]
4945 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4946 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4947 #[doc = r" no stolen instances are passed to such software."]
4948 pub unsafe fn steal() -> Self {
4949 Self { _marker: PhantomData }
4950 }
4951}
4952impl Deref for CAN_MO51 {
4953 type Target = can_mo0::RegisterBlock;
4954 #[inline(always)]
4955 fn deref(&self) -> &Self::Target {
4956 unsafe { &*Self::PTR }
4957 }
4958}
4959impl core::fmt::Debug for CAN_MO51 {
4960 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4961 f.debug_struct("CAN_MO51").finish()
4962 }
4963}
4964#[doc = "Controller Area Networks"]
4965pub use self::can_mo0 as can_mo51;
4966#[doc = "Controller Area Networks"]
4967pub struct CAN_MO52 {
4968 _marker: PhantomData<*const ()>,
4969}
4970unsafe impl Send for CAN_MO52 {}
4971impl CAN_MO52 {
4972 #[doc = r"Pointer to the register block"]
4973 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5680 as *const _;
4974 #[doc = r"Return the pointer to the register block"]
4975 #[inline(always)]
4976 pub const fn ptr() -> *const can_mo0::RegisterBlock {
4977 Self::PTR
4978 }
4979 #[doc = r" Steal an instance of this peripheral"]
4980 #[doc = r""]
4981 #[doc = r" # Safety"]
4982 #[doc = r""]
4983 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4984 #[doc = r" that may race with any existing instances, for example by only"]
4985 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4986 #[doc = r" original peripheral and using critical sections to coordinate"]
4987 #[doc = r" access between multiple new instances."]
4988 #[doc = r""]
4989 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4990 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4991 #[doc = r" no stolen instances are passed to such software."]
4992 pub unsafe fn steal() -> Self {
4993 Self { _marker: PhantomData }
4994 }
4995}
4996impl Deref for CAN_MO52 {
4997 type Target = can_mo0::RegisterBlock;
4998 #[inline(always)]
4999 fn deref(&self) -> &Self::Target {
5000 unsafe { &*Self::PTR }
5001 }
5002}
5003impl core::fmt::Debug for CAN_MO52 {
5004 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5005 f.debug_struct("CAN_MO52").finish()
5006 }
5007}
5008#[doc = "Controller Area Networks"]
5009pub use self::can_mo0 as can_mo52;
5010#[doc = "Controller Area Networks"]
5011pub struct CAN_MO53 {
5012 _marker: PhantomData<*const ()>,
5013}
5014unsafe impl Send for CAN_MO53 {}
5015impl CAN_MO53 {
5016 #[doc = r"Pointer to the register block"]
5017 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_56a0 as *const _;
5018 #[doc = r"Return the pointer to the register block"]
5019 #[inline(always)]
5020 pub const fn ptr() -> *const can_mo0::RegisterBlock {
5021 Self::PTR
5022 }
5023 #[doc = r" Steal an instance of this peripheral"]
5024 #[doc = r""]
5025 #[doc = r" # Safety"]
5026 #[doc = r""]
5027 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5028 #[doc = r" that may race with any existing instances, for example by only"]
5029 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5030 #[doc = r" original peripheral and using critical sections to coordinate"]
5031 #[doc = r" access between multiple new instances."]
5032 #[doc = r""]
5033 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5034 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5035 #[doc = r" no stolen instances are passed to such software."]
5036 pub unsafe fn steal() -> Self {
5037 Self { _marker: PhantomData }
5038 }
5039}
5040impl Deref for CAN_MO53 {
5041 type Target = can_mo0::RegisterBlock;
5042 #[inline(always)]
5043 fn deref(&self) -> &Self::Target {
5044 unsafe { &*Self::PTR }
5045 }
5046}
5047impl core::fmt::Debug for CAN_MO53 {
5048 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5049 f.debug_struct("CAN_MO53").finish()
5050 }
5051}
5052#[doc = "Controller Area Networks"]
5053pub use self::can_mo0 as can_mo53;
5054#[doc = "Controller Area Networks"]
5055pub struct CAN_MO54 {
5056 _marker: PhantomData<*const ()>,
5057}
5058unsafe impl Send for CAN_MO54 {}
5059impl CAN_MO54 {
5060 #[doc = r"Pointer to the register block"]
5061 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_56c0 as *const _;
5062 #[doc = r"Return the pointer to the register block"]
5063 #[inline(always)]
5064 pub const fn ptr() -> *const can_mo0::RegisterBlock {
5065 Self::PTR
5066 }
5067 #[doc = r" Steal an instance of this peripheral"]
5068 #[doc = r""]
5069 #[doc = r" # Safety"]
5070 #[doc = r""]
5071 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5072 #[doc = r" that may race with any existing instances, for example by only"]
5073 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5074 #[doc = r" original peripheral and using critical sections to coordinate"]
5075 #[doc = r" access between multiple new instances."]
5076 #[doc = r""]
5077 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5078 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5079 #[doc = r" no stolen instances are passed to such software."]
5080 pub unsafe fn steal() -> Self {
5081 Self { _marker: PhantomData }
5082 }
5083}
5084impl Deref for CAN_MO54 {
5085 type Target = can_mo0::RegisterBlock;
5086 #[inline(always)]
5087 fn deref(&self) -> &Self::Target {
5088 unsafe { &*Self::PTR }
5089 }
5090}
5091impl core::fmt::Debug for CAN_MO54 {
5092 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5093 f.debug_struct("CAN_MO54").finish()
5094 }
5095}
5096#[doc = "Controller Area Networks"]
5097pub use self::can_mo0 as can_mo54;
5098#[doc = "Controller Area Networks"]
5099pub struct CAN_MO55 {
5100 _marker: PhantomData<*const ()>,
5101}
5102unsafe impl Send for CAN_MO55 {}
5103impl CAN_MO55 {
5104 #[doc = r"Pointer to the register block"]
5105 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_56e0 as *const _;
5106 #[doc = r"Return the pointer to the register block"]
5107 #[inline(always)]
5108 pub const fn ptr() -> *const can_mo0::RegisterBlock {
5109 Self::PTR
5110 }
5111 #[doc = r" Steal an instance of this peripheral"]
5112 #[doc = r""]
5113 #[doc = r" # Safety"]
5114 #[doc = r""]
5115 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5116 #[doc = r" that may race with any existing instances, for example by only"]
5117 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5118 #[doc = r" original peripheral and using critical sections to coordinate"]
5119 #[doc = r" access between multiple new instances."]
5120 #[doc = r""]
5121 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5122 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5123 #[doc = r" no stolen instances are passed to such software."]
5124 pub unsafe fn steal() -> Self {
5125 Self { _marker: PhantomData }
5126 }
5127}
5128impl Deref for CAN_MO55 {
5129 type Target = can_mo0::RegisterBlock;
5130 #[inline(always)]
5131 fn deref(&self) -> &Self::Target {
5132 unsafe { &*Self::PTR }
5133 }
5134}
5135impl core::fmt::Debug for CAN_MO55 {
5136 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5137 f.debug_struct("CAN_MO55").finish()
5138 }
5139}
5140#[doc = "Controller Area Networks"]
5141pub use self::can_mo0 as can_mo55;
5142#[doc = "Controller Area Networks"]
5143pub struct CAN_MO56 {
5144 _marker: PhantomData<*const ()>,
5145}
5146unsafe impl Send for CAN_MO56 {}
5147impl CAN_MO56 {
5148 #[doc = r"Pointer to the register block"]
5149 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5700 as *const _;
5150 #[doc = r"Return the pointer to the register block"]
5151 #[inline(always)]
5152 pub const fn ptr() -> *const can_mo0::RegisterBlock {
5153 Self::PTR
5154 }
5155 #[doc = r" Steal an instance of this peripheral"]
5156 #[doc = r""]
5157 #[doc = r" # Safety"]
5158 #[doc = r""]
5159 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5160 #[doc = r" that may race with any existing instances, for example by only"]
5161 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5162 #[doc = r" original peripheral and using critical sections to coordinate"]
5163 #[doc = r" access between multiple new instances."]
5164 #[doc = r""]
5165 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5166 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5167 #[doc = r" no stolen instances are passed to such software."]
5168 pub unsafe fn steal() -> Self {
5169 Self { _marker: PhantomData }
5170 }
5171}
5172impl Deref for CAN_MO56 {
5173 type Target = can_mo0::RegisterBlock;
5174 #[inline(always)]
5175 fn deref(&self) -> &Self::Target {
5176 unsafe { &*Self::PTR }
5177 }
5178}
5179impl core::fmt::Debug for CAN_MO56 {
5180 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5181 f.debug_struct("CAN_MO56").finish()
5182 }
5183}
5184#[doc = "Controller Area Networks"]
5185pub use self::can_mo0 as can_mo56;
5186#[doc = "Controller Area Networks"]
5187pub struct CAN_MO57 {
5188 _marker: PhantomData<*const ()>,
5189}
5190unsafe impl Send for CAN_MO57 {}
5191impl CAN_MO57 {
5192 #[doc = r"Pointer to the register block"]
5193 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5720 as *const _;
5194 #[doc = r"Return the pointer to the register block"]
5195 #[inline(always)]
5196 pub const fn ptr() -> *const can_mo0::RegisterBlock {
5197 Self::PTR
5198 }
5199 #[doc = r" Steal an instance of this peripheral"]
5200 #[doc = r""]
5201 #[doc = r" # Safety"]
5202 #[doc = r""]
5203 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5204 #[doc = r" that may race with any existing instances, for example by only"]
5205 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5206 #[doc = r" original peripheral and using critical sections to coordinate"]
5207 #[doc = r" access between multiple new instances."]
5208 #[doc = r""]
5209 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5210 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5211 #[doc = r" no stolen instances are passed to such software."]
5212 pub unsafe fn steal() -> Self {
5213 Self { _marker: PhantomData }
5214 }
5215}
5216impl Deref for CAN_MO57 {
5217 type Target = can_mo0::RegisterBlock;
5218 #[inline(always)]
5219 fn deref(&self) -> &Self::Target {
5220 unsafe { &*Self::PTR }
5221 }
5222}
5223impl core::fmt::Debug for CAN_MO57 {
5224 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5225 f.debug_struct("CAN_MO57").finish()
5226 }
5227}
5228#[doc = "Controller Area Networks"]
5229pub use self::can_mo0 as can_mo57;
5230#[doc = "Controller Area Networks"]
5231pub struct CAN_MO58 {
5232 _marker: PhantomData<*const ()>,
5233}
5234unsafe impl Send for CAN_MO58 {}
5235impl CAN_MO58 {
5236 #[doc = r"Pointer to the register block"]
5237 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5740 as *const _;
5238 #[doc = r"Return the pointer to the register block"]
5239 #[inline(always)]
5240 pub const fn ptr() -> *const can_mo0::RegisterBlock {
5241 Self::PTR
5242 }
5243 #[doc = r" Steal an instance of this peripheral"]
5244 #[doc = r""]
5245 #[doc = r" # Safety"]
5246 #[doc = r""]
5247 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5248 #[doc = r" that may race with any existing instances, for example by only"]
5249 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5250 #[doc = r" original peripheral and using critical sections to coordinate"]
5251 #[doc = r" access between multiple new instances."]
5252 #[doc = r""]
5253 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5254 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5255 #[doc = r" no stolen instances are passed to such software."]
5256 pub unsafe fn steal() -> Self {
5257 Self { _marker: PhantomData }
5258 }
5259}
5260impl Deref for CAN_MO58 {
5261 type Target = can_mo0::RegisterBlock;
5262 #[inline(always)]
5263 fn deref(&self) -> &Self::Target {
5264 unsafe { &*Self::PTR }
5265 }
5266}
5267impl core::fmt::Debug for CAN_MO58 {
5268 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5269 f.debug_struct("CAN_MO58").finish()
5270 }
5271}
5272#[doc = "Controller Area Networks"]
5273pub use self::can_mo0 as can_mo58;
5274#[doc = "Controller Area Networks"]
5275pub struct CAN_MO59 {
5276 _marker: PhantomData<*const ()>,
5277}
5278unsafe impl Send for CAN_MO59 {}
5279impl CAN_MO59 {
5280 #[doc = r"Pointer to the register block"]
5281 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5760 as *const _;
5282 #[doc = r"Return the pointer to the register block"]
5283 #[inline(always)]
5284 pub const fn ptr() -> *const can_mo0::RegisterBlock {
5285 Self::PTR
5286 }
5287 #[doc = r" Steal an instance of this peripheral"]
5288 #[doc = r""]
5289 #[doc = r" # Safety"]
5290 #[doc = r""]
5291 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5292 #[doc = r" that may race with any existing instances, for example by only"]
5293 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5294 #[doc = r" original peripheral and using critical sections to coordinate"]
5295 #[doc = r" access between multiple new instances."]
5296 #[doc = r""]
5297 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5298 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5299 #[doc = r" no stolen instances are passed to such software."]
5300 pub unsafe fn steal() -> Self {
5301 Self { _marker: PhantomData }
5302 }
5303}
5304impl Deref for CAN_MO59 {
5305 type Target = can_mo0::RegisterBlock;
5306 #[inline(always)]
5307 fn deref(&self) -> &Self::Target {
5308 unsafe { &*Self::PTR }
5309 }
5310}
5311impl core::fmt::Debug for CAN_MO59 {
5312 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5313 f.debug_struct("CAN_MO59").finish()
5314 }
5315}
5316#[doc = "Controller Area Networks"]
5317pub use self::can_mo0 as can_mo59;
5318#[doc = "Controller Area Networks"]
5319pub struct CAN_MO60 {
5320 _marker: PhantomData<*const ()>,
5321}
5322unsafe impl Send for CAN_MO60 {}
5323impl CAN_MO60 {
5324 #[doc = r"Pointer to the register block"]
5325 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5780 as *const _;
5326 #[doc = r"Return the pointer to the register block"]
5327 #[inline(always)]
5328 pub const fn ptr() -> *const can_mo0::RegisterBlock {
5329 Self::PTR
5330 }
5331 #[doc = r" Steal an instance of this peripheral"]
5332 #[doc = r""]
5333 #[doc = r" # Safety"]
5334 #[doc = r""]
5335 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5336 #[doc = r" that may race with any existing instances, for example by only"]
5337 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5338 #[doc = r" original peripheral and using critical sections to coordinate"]
5339 #[doc = r" access between multiple new instances."]
5340 #[doc = r""]
5341 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5342 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5343 #[doc = r" no stolen instances are passed to such software."]
5344 pub unsafe fn steal() -> Self {
5345 Self { _marker: PhantomData }
5346 }
5347}
5348impl Deref for CAN_MO60 {
5349 type Target = can_mo0::RegisterBlock;
5350 #[inline(always)]
5351 fn deref(&self) -> &Self::Target {
5352 unsafe { &*Self::PTR }
5353 }
5354}
5355impl core::fmt::Debug for CAN_MO60 {
5356 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5357 f.debug_struct("CAN_MO60").finish()
5358 }
5359}
5360#[doc = "Controller Area Networks"]
5361pub use self::can_mo0 as can_mo60;
5362#[doc = "Controller Area Networks"]
5363pub struct CAN_MO61 {
5364 _marker: PhantomData<*const ()>,
5365}
5366unsafe impl Send for CAN_MO61 {}
5367impl CAN_MO61 {
5368 #[doc = r"Pointer to the register block"]
5369 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_57a0 as *const _;
5370 #[doc = r"Return the pointer to the register block"]
5371 #[inline(always)]
5372 pub const fn ptr() -> *const can_mo0::RegisterBlock {
5373 Self::PTR
5374 }
5375 #[doc = r" Steal an instance of this peripheral"]
5376 #[doc = r""]
5377 #[doc = r" # Safety"]
5378 #[doc = r""]
5379 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5380 #[doc = r" that may race with any existing instances, for example by only"]
5381 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5382 #[doc = r" original peripheral and using critical sections to coordinate"]
5383 #[doc = r" access between multiple new instances."]
5384 #[doc = r""]
5385 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5386 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5387 #[doc = r" no stolen instances are passed to such software."]
5388 pub unsafe fn steal() -> Self {
5389 Self { _marker: PhantomData }
5390 }
5391}
5392impl Deref for CAN_MO61 {
5393 type Target = can_mo0::RegisterBlock;
5394 #[inline(always)]
5395 fn deref(&self) -> &Self::Target {
5396 unsafe { &*Self::PTR }
5397 }
5398}
5399impl core::fmt::Debug for CAN_MO61 {
5400 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5401 f.debug_struct("CAN_MO61").finish()
5402 }
5403}
5404#[doc = "Controller Area Networks"]
5405pub use self::can_mo0 as can_mo61;
5406#[doc = "Controller Area Networks"]
5407pub struct CAN_MO62 {
5408 _marker: PhantomData<*const ()>,
5409}
5410unsafe impl Send for CAN_MO62 {}
5411impl CAN_MO62 {
5412 #[doc = r"Pointer to the register block"]
5413 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_57c0 as *const _;
5414 #[doc = r"Return the pointer to the register block"]
5415 #[inline(always)]
5416 pub const fn ptr() -> *const can_mo0::RegisterBlock {
5417 Self::PTR
5418 }
5419 #[doc = r" Steal an instance of this peripheral"]
5420 #[doc = r""]
5421 #[doc = r" # Safety"]
5422 #[doc = r""]
5423 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5424 #[doc = r" that may race with any existing instances, for example by only"]
5425 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5426 #[doc = r" original peripheral and using critical sections to coordinate"]
5427 #[doc = r" access between multiple new instances."]
5428 #[doc = r""]
5429 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5430 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5431 #[doc = r" no stolen instances are passed to such software."]
5432 pub unsafe fn steal() -> Self {
5433 Self { _marker: PhantomData }
5434 }
5435}
5436impl Deref for CAN_MO62 {
5437 type Target = can_mo0::RegisterBlock;
5438 #[inline(always)]
5439 fn deref(&self) -> &Self::Target {
5440 unsafe { &*Self::PTR }
5441 }
5442}
5443impl core::fmt::Debug for CAN_MO62 {
5444 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5445 f.debug_struct("CAN_MO62").finish()
5446 }
5447}
5448#[doc = "Controller Area Networks"]
5449pub use self::can_mo0 as can_mo62;
5450#[doc = "Controller Area Networks"]
5451pub struct CAN_MO63 {
5452 _marker: PhantomData<*const ()>,
5453}
5454unsafe impl Send for CAN_MO63 {}
5455impl CAN_MO63 {
5456 #[doc = r"Pointer to the register block"]
5457 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_57e0 as *const _;
5458 #[doc = r"Return the pointer to the register block"]
5459 #[inline(always)]
5460 pub const fn ptr() -> *const can_mo0::RegisterBlock {
5461 Self::PTR
5462 }
5463 #[doc = r" Steal an instance of this peripheral"]
5464 #[doc = r""]
5465 #[doc = r" # Safety"]
5466 #[doc = r""]
5467 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5468 #[doc = r" that may race with any existing instances, for example by only"]
5469 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5470 #[doc = r" original peripheral and using critical sections to coordinate"]
5471 #[doc = r" access between multiple new instances."]
5472 #[doc = r""]
5473 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5474 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5475 #[doc = r" no stolen instances are passed to such software."]
5476 pub unsafe fn steal() -> Self {
5477 Self { _marker: PhantomData }
5478 }
5479}
5480impl Deref for CAN_MO63 {
5481 type Target = can_mo0::RegisterBlock;
5482 #[inline(always)]
5483 fn deref(&self) -> &Self::Target {
5484 unsafe { &*Self::PTR }
5485 }
5486}
5487impl core::fmt::Debug for CAN_MO63 {
5488 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5489 f.debug_struct("CAN_MO63").finish()
5490 }
5491}
5492#[doc = "Controller Area Networks"]
5493pub use self::can_mo0 as can_mo63;
5494#[doc = "Analog to Digital Converter"]
5495pub struct VADC {
5496 _marker: PhantomData<*const ()>,
5497}
5498unsafe impl Send for VADC {}
5499impl VADC {
5500 #[doc = r"Pointer to the register block"]
5501 pub const PTR: *const vadc::RegisterBlock = 0x4000_4000 as *const _;
5502 #[doc = r"Return the pointer to the register block"]
5503 #[inline(always)]
5504 pub const fn ptr() -> *const vadc::RegisterBlock {
5505 Self::PTR
5506 }
5507 #[doc = r" Steal an instance of this peripheral"]
5508 #[doc = r""]
5509 #[doc = r" # Safety"]
5510 #[doc = r""]
5511 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5512 #[doc = r" that may race with any existing instances, for example by only"]
5513 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5514 #[doc = r" original peripheral and using critical sections to coordinate"]
5515 #[doc = r" access between multiple new instances."]
5516 #[doc = r""]
5517 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5518 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5519 #[doc = r" no stolen instances are passed to such software."]
5520 pub unsafe fn steal() -> Self {
5521 Self { _marker: PhantomData }
5522 }
5523}
5524impl Deref for VADC {
5525 type Target = vadc::RegisterBlock;
5526 #[inline(always)]
5527 fn deref(&self) -> &Self::Target {
5528 unsafe { &*Self::PTR }
5529 }
5530}
5531impl core::fmt::Debug for VADC {
5532 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5533 f.debug_struct("VADC").finish()
5534 }
5535}
5536#[doc = "Analog to Digital Converter"]
5537pub mod vadc;
5538#[doc = "Analog to Digital Converter"]
5539pub struct VADC_G0 {
5540 _marker: PhantomData<*const ()>,
5541}
5542unsafe impl Send for VADC_G0 {}
5543impl VADC_G0 {
5544 #[doc = r"Pointer to the register block"]
5545 pub const PTR: *const vadc_g0::RegisterBlock = 0x4000_4400 as *const _;
5546 #[doc = r"Return the pointer to the register block"]
5547 #[inline(always)]
5548 pub const fn ptr() -> *const vadc_g0::RegisterBlock {
5549 Self::PTR
5550 }
5551 #[doc = r" Steal an instance of this peripheral"]
5552 #[doc = r""]
5553 #[doc = r" # Safety"]
5554 #[doc = r""]
5555 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5556 #[doc = r" that may race with any existing instances, for example by only"]
5557 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5558 #[doc = r" original peripheral and using critical sections to coordinate"]
5559 #[doc = r" access between multiple new instances."]
5560 #[doc = r""]
5561 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5562 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5563 #[doc = r" no stolen instances are passed to such software."]
5564 pub unsafe fn steal() -> Self {
5565 Self { _marker: PhantomData }
5566 }
5567}
5568impl Deref for VADC_G0 {
5569 type Target = vadc_g0::RegisterBlock;
5570 #[inline(always)]
5571 fn deref(&self) -> &Self::Target {
5572 unsafe { &*Self::PTR }
5573 }
5574}
5575impl core::fmt::Debug for VADC_G0 {
5576 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5577 f.debug_struct("VADC_G0").finish()
5578 }
5579}
5580#[doc = "Analog to Digital Converter"]
5581pub mod vadc_g0;
5582#[doc = "Analog to Digital Converter"]
5583pub struct VADC_G1 {
5584 _marker: PhantomData<*const ()>,
5585}
5586unsafe impl Send for VADC_G1 {}
5587impl VADC_G1 {
5588 #[doc = r"Pointer to the register block"]
5589 pub const PTR: *const vadc_g0::RegisterBlock = 0x4000_4800 as *const _;
5590 #[doc = r"Return the pointer to the register block"]
5591 #[inline(always)]
5592 pub const fn ptr() -> *const vadc_g0::RegisterBlock {
5593 Self::PTR
5594 }
5595 #[doc = r" Steal an instance of this peripheral"]
5596 #[doc = r""]
5597 #[doc = r" # Safety"]
5598 #[doc = r""]
5599 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5600 #[doc = r" that may race with any existing instances, for example by only"]
5601 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5602 #[doc = r" original peripheral and using critical sections to coordinate"]
5603 #[doc = r" access between multiple new instances."]
5604 #[doc = r""]
5605 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5606 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5607 #[doc = r" no stolen instances are passed to such software."]
5608 pub unsafe fn steal() -> Self {
5609 Self { _marker: PhantomData }
5610 }
5611}
5612impl Deref for VADC_G1 {
5613 type Target = vadc_g0::RegisterBlock;
5614 #[inline(always)]
5615 fn deref(&self) -> &Self::Target {
5616 unsafe { &*Self::PTR }
5617 }
5618}
5619impl core::fmt::Debug for VADC_G1 {
5620 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5621 f.debug_struct("VADC_G1").finish()
5622 }
5623}
5624#[doc = "Analog to Digital Converter"]
5625pub use self::vadc_g0 as vadc_g1;
5626#[doc = "Digital to Analog Converter"]
5627pub struct DAC {
5628 _marker: PhantomData<*const ()>,
5629}
5630unsafe impl Send for DAC {}
5631impl DAC {
5632 #[doc = r"Pointer to the register block"]
5633 pub const PTR: *const dac::RegisterBlock = 0x4801_8000 as *const _;
5634 #[doc = r"Return the pointer to the register block"]
5635 #[inline(always)]
5636 pub const fn ptr() -> *const dac::RegisterBlock {
5637 Self::PTR
5638 }
5639 #[doc = r" Steal an instance of this peripheral"]
5640 #[doc = r""]
5641 #[doc = r" # Safety"]
5642 #[doc = r""]
5643 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5644 #[doc = r" that may race with any existing instances, for example by only"]
5645 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5646 #[doc = r" original peripheral and using critical sections to coordinate"]
5647 #[doc = r" access between multiple new instances."]
5648 #[doc = r""]
5649 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5650 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5651 #[doc = r" no stolen instances are passed to such software."]
5652 pub unsafe fn steal() -> Self {
5653 Self { _marker: PhantomData }
5654 }
5655}
5656impl Deref for DAC {
5657 type Target = dac::RegisterBlock;
5658 #[inline(always)]
5659 fn deref(&self) -> &Self::Target {
5660 unsafe { &*Self::PTR }
5661 }
5662}
5663impl core::fmt::Debug for DAC {
5664 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5665 f.debug_struct("DAC").finish()
5666 }
5667}
5668#[doc = "Digital to Analog Converter"]
5669pub mod dac;
5670#[doc = "Capture Compare Unit 4 - Unit 0"]
5671pub struct CCU40 {
5672 _marker: PhantomData<*const ()>,
5673}
5674unsafe impl Send for CCU40 {}
5675impl CCU40 {
5676 #[doc = r"Pointer to the register block"]
5677 pub const PTR: *const ccu40::RegisterBlock = 0x4000_c000 as *const _;
5678 #[doc = r"Return the pointer to the register block"]
5679 #[inline(always)]
5680 pub const fn ptr() -> *const ccu40::RegisterBlock {
5681 Self::PTR
5682 }
5683 #[doc = r" Steal an instance of this peripheral"]
5684 #[doc = r""]
5685 #[doc = r" # Safety"]
5686 #[doc = r""]
5687 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5688 #[doc = r" that may race with any existing instances, for example by only"]
5689 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5690 #[doc = r" original peripheral and using critical sections to coordinate"]
5691 #[doc = r" access between multiple new instances."]
5692 #[doc = r""]
5693 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5694 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5695 #[doc = r" no stolen instances are passed to such software."]
5696 pub unsafe fn steal() -> Self {
5697 Self { _marker: PhantomData }
5698 }
5699}
5700impl Deref for CCU40 {
5701 type Target = ccu40::RegisterBlock;
5702 #[inline(always)]
5703 fn deref(&self) -> &Self::Target {
5704 unsafe { &*Self::PTR }
5705 }
5706}
5707impl core::fmt::Debug for CCU40 {
5708 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5709 f.debug_struct("CCU40").finish()
5710 }
5711}
5712#[doc = "Capture Compare Unit 4 - Unit 0"]
5713pub mod ccu40;
5714#[doc = "Capture Compare Unit 4 - Unit 1"]
5715pub struct CCU41 {
5716 _marker: PhantomData<*const ()>,
5717}
5718unsafe impl Send for CCU41 {}
5719impl CCU41 {
5720 #[doc = r"Pointer to the register block"]
5721 pub const PTR: *const ccu40::RegisterBlock = 0x4001_0000 as *const _;
5722 #[doc = r"Return the pointer to the register block"]
5723 #[inline(always)]
5724 pub const fn ptr() -> *const ccu40::RegisterBlock {
5725 Self::PTR
5726 }
5727 #[doc = r" Steal an instance of this peripheral"]
5728 #[doc = r""]
5729 #[doc = r" # Safety"]
5730 #[doc = r""]
5731 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5732 #[doc = r" that may race with any existing instances, for example by only"]
5733 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5734 #[doc = r" original peripheral and using critical sections to coordinate"]
5735 #[doc = r" access between multiple new instances."]
5736 #[doc = r""]
5737 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5738 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5739 #[doc = r" no stolen instances are passed to such software."]
5740 pub unsafe fn steal() -> Self {
5741 Self { _marker: PhantomData }
5742 }
5743}
5744impl Deref for CCU41 {
5745 type Target = ccu40::RegisterBlock;
5746 #[inline(always)]
5747 fn deref(&self) -> &Self::Target {
5748 unsafe { &*Self::PTR }
5749 }
5750}
5751impl core::fmt::Debug for CCU41 {
5752 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5753 f.debug_struct("CCU41").finish()
5754 }
5755}
5756#[doc = "Capture Compare Unit 4 - Unit 1"]
5757pub use self::ccu40 as ccu41;
5758#[doc = "Capture Compare Unit 4 - Unit 0"]
5759pub struct CCU40_CC40 {
5760 _marker: PhantomData<*const ()>,
5761}
5762unsafe impl Send for CCU40_CC40 {}
5763impl CCU40_CC40 {
5764 #[doc = r"Pointer to the register block"]
5765 pub const PTR: *const ccu40_cc40::RegisterBlock = 0x4000_c100 as *const _;
5766 #[doc = r"Return the pointer to the register block"]
5767 #[inline(always)]
5768 pub const fn ptr() -> *const ccu40_cc40::RegisterBlock {
5769 Self::PTR
5770 }
5771 #[doc = r" Steal an instance of this peripheral"]
5772 #[doc = r""]
5773 #[doc = r" # Safety"]
5774 #[doc = r""]
5775 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5776 #[doc = r" that may race with any existing instances, for example by only"]
5777 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5778 #[doc = r" original peripheral and using critical sections to coordinate"]
5779 #[doc = r" access between multiple new instances."]
5780 #[doc = r""]
5781 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5782 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5783 #[doc = r" no stolen instances are passed to such software."]
5784 pub unsafe fn steal() -> Self {
5785 Self { _marker: PhantomData }
5786 }
5787}
5788impl Deref for CCU40_CC40 {
5789 type Target = ccu40_cc40::RegisterBlock;
5790 #[inline(always)]
5791 fn deref(&self) -> &Self::Target {
5792 unsafe { &*Self::PTR }
5793 }
5794}
5795impl core::fmt::Debug for CCU40_CC40 {
5796 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5797 f.debug_struct("CCU40_CC40").finish()
5798 }
5799}
5800#[doc = "Capture Compare Unit 4 - Unit 0"]
5801pub mod ccu40_cc40;
5802#[doc = "Capture Compare Unit 4 - Unit 0"]
5803pub struct CCU40_CC41 {
5804 _marker: PhantomData<*const ()>,
5805}
5806unsafe impl Send for CCU40_CC41 {}
5807impl CCU40_CC41 {
5808 #[doc = r"Pointer to the register block"]
5809 pub const PTR: *const ccu40_cc40::RegisterBlock = 0x4000_c200 as *const _;
5810 #[doc = r"Return the pointer to the register block"]
5811 #[inline(always)]
5812 pub const fn ptr() -> *const ccu40_cc40::RegisterBlock {
5813 Self::PTR
5814 }
5815 #[doc = r" Steal an instance of this peripheral"]
5816 #[doc = r""]
5817 #[doc = r" # Safety"]
5818 #[doc = r""]
5819 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5820 #[doc = r" that may race with any existing instances, for example by only"]
5821 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5822 #[doc = r" original peripheral and using critical sections to coordinate"]
5823 #[doc = r" access between multiple new instances."]
5824 #[doc = r""]
5825 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5826 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5827 #[doc = r" no stolen instances are passed to such software."]
5828 pub unsafe fn steal() -> Self {
5829 Self { _marker: PhantomData }
5830 }
5831}
5832impl Deref for CCU40_CC41 {
5833 type Target = ccu40_cc40::RegisterBlock;
5834 #[inline(always)]
5835 fn deref(&self) -> &Self::Target {
5836 unsafe { &*Self::PTR }
5837 }
5838}
5839impl core::fmt::Debug for CCU40_CC41 {
5840 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5841 f.debug_struct("CCU40_CC41").finish()
5842 }
5843}
5844#[doc = "Capture Compare Unit 4 - Unit 0"]
5845pub use self::ccu40_cc40 as ccu40_cc41;
5846#[doc = "Capture Compare Unit 4 - Unit 0"]
5847pub struct CCU40_CC42 {
5848 _marker: PhantomData<*const ()>,
5849}
5850unsafe impl Send for CCU40_CC42 {}
5851impl CCU40_CC42 {
5852 #[doc = r"Pointer to the register block"]
5853 pub const PTR: *const ccu40_cc40::RegisterBlock = 0x4000_c300 as *const _;
5854 #[doc = r"Return the pointer to the register block"]
5855 #[inline(always)]
5856 pub const fn ptr() -> *const ccu40_cc40::RegisterBlock {
5857 Self::PTR
5858 }
5859 #[doc = r" Steal an instance of this peripheral"]
5860 #[doc = r""]
5861 #[doc = r" # Safety"]
5862 #[doc = r""]
5863 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5864 #[doc = r" that may race with any existing instances, for example by only"]
5865 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5866 #[doc = r" original peripheral and using critical sections to coordinate"]
5867 #[doc = r" access between multiple new instances."]
5868 #[doc = r""]
5869 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5870 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5871 #[doc = r" no stolen instances are passed to such software."]
5872 pub unsafe fn steal() -> Self {
5873 Self { _marker: PhantomData }
5874 }
5875}
5876impl Deref for CCU40_CC42 {
5877 type Target = ccu40_cc40::RegisterBlock;
5878 #[inline(always)]
5879 fn deref(&self) -> &Self::Target {
5880 unsafe { &*Self::PTR }
5881 }
5882}
5883impl core::fmt::Debug for CCU40_CC42 {
5884 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5885 f.debug_struct("CCU40_CC42").finish()
5886 }
5887}
5888#[doc = "Capture Compare Unit 4 - Unit 0"]
5889pub use self::ccu40_cc40 as ccu40_cc42;
5890#[doc = "Capture Compare Unit 4 - Unit 0"]
5891pub struct CCU40_CC43 {
5892 _marker: PhantomData<*const ()>,
5893}
5894unsafe impl Send for CCU40_CC43 {}
5895impl CCU40_CC43 {
5896 #[doc = r"Pointer to the register block"]
5897 pub const PTR: *const ccu40_cc40::RegisterBlock = 0x4000_c400 as *const _;
5898 #[doc = r"Return the pointer to the register block"]
5899 #[inline(always)]
5900 pub const fn ptr() -> *const ccu40_cc40::RegisterBlock {
5901 Self::PTR
5902 }
5903 #[doc = r" Steal an instance of this peripheral"]
5904 #[doc = r""]
5905 #[doc = r" # Safety"]
5906 #[doc = r""]
5907 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5908 #[doc = r" that may race with any existing instances, for example by only"]
5909 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5910 #[doc = r" original peripheral and using critical sections to coordinate"]
5911 #[doc = r" access between multiple new instances."]
5912 #[doc = r""]
5913 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5914 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5915 #[doc = r" no stolen instances are passed to such software."]
5916 pub unsafe fn steal() -> Self {
5917 Self { _marker: PhantomData }
5918 }
5919}
5920impl Deref for CCU40_CC43 {
5921 type Target = ccu40_cc40::RegisterBlock;
5922 #[inline(always)]
5923 fn deref(&self) -> &Self::Target {
5924 unsafe { &*Self::PTR }
5925 }
5926}
5927impl core::fmt::Debug for CCU40_CC43 {
5928 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5929 f.debug_struct("CCU40_CC43").finish()
5930 }
5931}
5932#[doc = "Capture Compare Unit 4 - Unit 0"]
5933pub use self::ccu40_cc40 as ccu40_cc43;
5934#[doc = "Capture Compare Unit 4 - Unit 1"]
5935pub struct CCU41_CC40 {
5936 _marker: PhantomData<*const ()>,
5937}
5938unsafe impl Send for CCU41_CC40 {}
5939impl CCU41_CC40 {
5940 #[doc = r"Pointer to the register block"]
5941 pub const PTR: *const ccu40_cc40::RegisterBlock = 0x4001_0100 as *const _;
5942 #[doc = r"Return the pointer to the register block"]
5943 #[inline(always)]
5944 pub const fn ptr() -> *const ccu40_cc40::RegisterBlock {
5945 Self::PTR
5946 }
5947 #[doc = r" Steal an instance of this peripheral"]
5948 #[doc = r""]
5949 #[doc = r" # Safety"]
5950 #[doc = r""]
5951 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5952 #[doc = r" that may race with any existing instances, for example by only"]
5953 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5954 #[doc = r" original peripheral and using critical sections to coordinate"]
5955 #[doc = r" access between multiple new instances."]
5956 #[doc = r""]
5957 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5958 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5959 #[doc = r" no stolen instances are passed to such software."]
5960 pub unsafe fn steal() -> Self {
5961 Self { _marker: PhantomData }
5962 }
5963}
5964impl Deref for CCU41_CC40 {
5965 type Target = ccu40_cc40::RegisterBlock;
5966 #[inline(always)]
5967 fn deref(&self) -> &Self::Target {
5968 unsafe { &*Self::PTR }
5969 }
5970}
5971impl core::fmt::Debug for CCU41_CC40 {
5972 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5973 f.debug_struct("CCU41_CC40").finish()
5974 }
5975}
5976#[doc = "Capture Compare Unit 4 - Unit 1"]
5977pub use self::ccu40_cc40 as ccu41_cc40;
5978#[doc = "Capture Compare Unit 4 - Unit 1"]
5979pub struct CCU41_CC41 {
5980 _marker: PhantomData<*const ()>,
5981}
5982unsafe impl Send for CCU41_CC41 {}
5983impl CCU41_CC41 {
5984 #[doc = r"Pointer to the register block"]
5985 pub const PTR: *const ccu40_cc40::RegisterBlock = 0x4001_0200 as *const _;
5986 #[doc = r"Return the pointer to the register block"]
5987 #[inline(always)]
5988 pub const fn ptr() -> *const ccu40_cc40::RegisterBlock {
5989 Self::PTR
5990 }
5991 #[doc = r" Steal an instance of this peripheral"]
5992 #[doc = r""]
5993 #[doc = r" # Safety"]
5994 #[doc = r""]
5995 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5996 #[doc = r" that may race with any existing instances, for example by only"]
5997 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5998 #[doc = r" original peripheral and using critical sections to coordinate"]
5999 #[doc = r" access between multiple new instances."]
6000 #[doc = r""]
6001 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6002 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6003 #[doc = r" no stolen instances are passed to such software."]
6004 pub unsafe fn steal() -> Self {
6005 Self { _marker: PhantomData }
6006 }
6007}
6008impl Deref for CCU41_CC41 {
6009 type Target = ccu40_cc40::RegisterBlock;
6010 #[inline(always)]
6011 fn deref(&self) -> &Self::Target {
6012 unsafe { &*Self::PTR }
6013 }
6014}
6015impl core::fmt::Debug for CCU41_CC41 {
6016 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6017 f.debug_struct("CCU41_CC41").finish()
6018 }
6019}
6020#[doc = "Capture Compare Unit 4 - Unit 1"]
6021pub use self::ccu40_cc40 as ccu41_cc41;
6022#[doc = "Capture Compare Unit 4 - Unit 1"]
6023pub struct CCU41_CC42 {
6024 _marker: PhantomData<*const ()>,
6025}
6026unsafe impl Send for CCU41_CC42 {}
6027impl CCU41_CC42 {
6028 #[doc = r"Pointer to the register block"]
6029 pub const PTR: *const ccu40_cc40::RegisterBlock = 0x4001_0300 as *const _;
6030 #[doc = r"Return the pointer to the register block"]
6031 #[inline(always)]
6032 pub const fn ptr() -> *const ccu40_cc40::RegisterBlock {
6033 Self::PTR
6034 }
6035 #[doc = r" Steal an instance of this peripheral"]
6036 #[doc = r""]
6037 #[doc = r" # Safety"]
6038 #[doc = r""]
6039 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6040 #[doc = r" that may race with any existing instances, for example by only"]
6041 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6042 #[doc = r" original peripheral and using critical sections to coordinate"]
6043 #[doc = r" access between multiple new instances."]
6044 #[doc = r""]
6045 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6046 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6047 #[doc = r" no stolen instances are passed to such software."]
6048 pub unsafe fn steal() -> Self {
6049 Self { _marker: PhantomData }
6050 }
6051}
6052impl Deref for CCU41_CC42 {
6053 type Target = ccu40_cc40::RegisterBlock;
6054 #[inline(always)]
6055 fn deref(&self) -> &Self::Target {
6056 unsafe { &*Self::PTR }
6057 }
6058}
6059impl core::fmt::Debug for CCU41_CC42 {
6060 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6061 f.debug_struct("CCU41_CC42").finish()
6062 }
6063}
6064#[doc = "Capture Compare Unit 4 - Unit 1"]
6065pub use self::ccu40_cc40 as ccu41_cc42;
6066#[doc = "Capture Compare Unit 4 - Unit 1"]
6067pub struct CCU41_CC43 {
6068 _marker: PhantomData<*const ()>,
6069}
6070unsafe impl Send for CCU41_CC43 {}
6071impl CCU41_CC43 {
6072 #[doc = r"Pointer to the register block"]
6073 pub const PTR: *const ccu40_cc40::RegisterBlock = 0x4001_0400 as *const _;
6074 #[doc = r"Return the pointer to the register block"]
6075 #[inline(always)]
6076 pub const fn ptr() -> *const ccu40_cc40::RegisterBlock {
6077 Self::PTR
6078 }
6079 #[doc = r" Steal an instance of this peripheral"]
6080 #[doc = r""]
6081 #[doc = r" # Safety"]
6082 #[doc = r""]
6083 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6084 #[doc = r" that may race with any existing instances, for example by only"]
6085 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6086 #[doc = r" original peripheral and using critical sections to coordinate"]
6087 #[doc = r" access between multiple new instances."]
6088 #[doc = r""]
6089 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6090 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6091 #[doc = r" no stolen instances are passed to such software."]
6092 pub unsafe fn steal() -> Self {
6093 Self { _marker: PhantomData }
6094 }
6095}
6096impl Deref for CCU41_CC43 {
6097 type Target = ccu40_cc40::RegisterBlock;
6098 #[inline(always)]
6099 fn deref(&self) -> &Self::Target {
6100 unsafe { &*Self::PTR }
6101 }
6102}
6103impl core::fmt::Debug for CCU41_CC43 {
6104 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6105 f.debug_struct("CCU41_CC43").finish()
6106 }
6107}
6108#[doc = "Capture Compare Unit 4 - Unit 1"]
6109pub use self::ccu40_cc40 as ccu41_cc43;
6110#[doc = "Capture Compare Unit 8 - Unit 0"]
6111pub struct CCU80 {
6112 _marker: PhantomData<*const ()>,
6113}
6114unsafe impl Send for CCU80 {}
6115impl CCU80 {
6116 #[doc = r"Pointer to the register block"]
6117 pub const PTR: *const ccu80::RegisterBlock = 0x4002_0000 as *const _;
6118 #[doc = r"Return the pointer to the register block"]
6119 #[inline(always)]
6120 pub const fn ptr() -> *const ccu80::RegisterBlock {
6121 Self::PTR
6122 }
6123 #[doc = r" Steal an instance of this peripheral"]
6124 #[doc = r""]
6125 #[doc = r" # Safety"]
6126 #[doc = r""]
6127 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6128 #[doc = r" that may race with any existing instances, for example by only"]
6129 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6130 #[doc = r" original peripheral and using critical sections to coordinate"]
6131 #[doc = r" access between multiple new instances."]
6132 #[doc = r""]
6133 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6134 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6135 #[doc = r" no stolen instances are passed to such software."]
6136 pub unsafe fn steal() -> Self {
6137 Self { _marker: PhantomData }
6138 }
6139}
6140impl Deref for CCU80 {
6141 type Target = ccu80::RegisterBlock;
6142 #[inline(always)]
6143 fn deref(&self) -> &Self::Target {
6144 unsafe { &*Self::PTR }
6145 }
6146}
6147impl core::fmt::Debug for CCU80 {
6148 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6149 f.debug_struct("CCU80").finish()
6150 }
6151}
6152#[doc = "Capture Compare Unit 8 - Unit 0"]
6153pub mod ccu80;
6154#[doc = "Capture Compare Unit 8 - Unit 0"]
6155pub struct CCU80_CC80 {
6156 _marker: PhantomData<*const ()>,
6157}
6158unsafe impl Send for CCU80_CC80 {}
6159impl CCU80_CC80 {
6160 #[doc = r"Pointer to the register block"]
6161 pub const PTR: *const ccu80_cc80::RegisterBlock = 0x4002_0100 as *const _;
6162 #[doc = r"Return the pointer to the register block"]
6163 #[inline(always)]
6164 pub const fn ptr() -> *const ccu80_cc80::RegisterBlock {
6165 Self::PTR
6166 }
6167 #[doc = r" Steal an instance of this peripheral"]
6168 #[doc = r""]
6169 #[doc = r" # Safety"]
6170 #[doc = r""]
6171 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6172 #[doc = r" that may race with any existing instances, for example by only"]
6173 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6174 #[doc = r" original peripheral and using critical sections to coordinate"]
6175 #[doc = r" access between multiple new instances."]
6176 #[doc = r""]
6177 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6178 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6179 #[doc = r" no stolen instances are passed to such software."]
6180 pub unsafe fn steal() -> Self {
6181 Self { _marker: PhantomData }
6182 }
6183}
6184impl Deref for CCU80_CC80 {
6185 type Target = ccu80_cc80::RegisterBlock;
6186 #[inline(always)]
6187 fn deref(&self) -> &Self::Target {
6188 unsafe { &*Self::PTR }
6189 }
6190}
6191impl core::fmt::Debug for CCU80_CC80 {
6192 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6193 f.debug_struct("CCU80_CC80").finish()
6194 }
6195}
6196#[doc = "Capture Compare Unit 8 - Unit 0"]
6197pub mod ccu80_cc80;
6198#[doc = "Capture Compare Unit 8 - Unit 0"]
6199pub struct CCU80_CC81 {
6200 _marker: PhantomData<*const ()>,
6201}
6202unsafe impl Send for CCU80_CC81 {}
6203impl CCU80_CC81 {
6204 #[doc = r"Pointer to the register block"]
6205 pub const PTR: *const ccu80_cc80::RegisterBlock = 0x4002_0200 as *const _;
6206 #[doc = r"Return the pointer to the register block"]
6207 #[inline(always)]
6208 pub const fn ptr() -> *const ccu80_cc80::RegisterBlock {
6209 Self::PTR
6210 }
6211 #[doc = r" Steal an instance of this peripheral"]
6212 #[doc = r""]
6213 #[doc = r" # Safety"]
6214 #[doc = r""]
6215 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6216 #[doc = r" that may race with any existing instances, for example by only"]
6217 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6218 #[doc = r" original peripheral and using critical sections to coordinate"]
6219 #[doc = r" access between multiple new instances."]
6220 #[doc = r""]
6221 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6222 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6223 #[doc = r" no stolen instances are passed to such software."]
6224 pub unsafe fn steal() -> Self {
6225 Self { _marker: PhantomData }
6226 }
6227}
6228impl Deref for CCU80_CC81 {
6229 type Target = ccu80_cc80::RegisterBlock;
6230 #[inline(always)]
6231 fn deref(&self) -> &Self::Target {
6232 unsafe { &*Self::PTR }
6233 }
6234}
6235impl core::fmt::Debug for CCU80_CC81 {
6236 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6237 f.debug_struct("CCU80_CC81").finish()
6238 }
6239}
6240#[doc = "Capture Compare Unit 8 - Unit 0"]
6241pub use self::ccu80_cc80 as ccu80_cc81;
6242#[doc = "Capture Compare Unit 8 - Unit 0"]
6243pub struct CCU80_CC82 {
6244 _marker: PhantomData<*const ()>,
6245}
6246unsafe impl Send for CCU80_CC82 {}
6247impl CCU80_CC82 {
6248 #[doc = r"Pointer to the register block"]
6249 pub const PTR: *const ccu80_cc80::RegisterBlock = 0x4002_0300 as *const _;
6250 #[doc = r"Return the pointer to the register block"]
6251 #[inline(always)]
6252 pub const fn ptr() -> *const ccu80_cc80::RegisterBlock {
6253 Self::PTR
6254 }
6255 #[doc = r" Steal an instance of this peripheral"]
6256 #[doc = r""]
6257 #[doc = r" # Safety"]
6258 #[doc = r""]
6259 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6260 #[doc = r" that may race with any existing instances, for example by only"]
6261 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6262 #[doc = r" original peripheral and using critical sections to coordinate"]
6263 #[doc = r" access between multiple new instances."]
6264 #[doc = r""]
6265 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6266 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6267 #[doc = r" no stolen instances are passed to such software."]
6268 pub unsafe fn steal() -> Self {
6269 Self { _marker: PhantomData }
6270 }
6271}
6272impl Deref for CCU80_CC82 {
6273 type Target = ccu80_cc80::RegisterBlock;
6274 #[inline(always)]
6275 fn deref(&self) -> &Self::Target {
6276 unsafe { &*Self::PTR }
6277 }
6278}
6279impl core::fmt::Debug for CCU80_CC82 {
6280 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6281 f.debug_struct("CCU80_CC82").finish()
6282 }
6283}
6284#[doc = "Capture Compare Unit 8 - Unit 0"]
6285pub use self::ccu80_cc80 as ccu80_cc82;
6286#[doc = "Capture Compare Unit 8 - Unit 0"]
6287pub struct CCU80_CC83 {
6288 _marker: PhantomData<*const ()>,
6289}
6290unsafe impl Send for CCU80_CC83 {}
6291impl CCU80_CC83 {
6292 #[doc = r"Pointer to the register block"]
6293 pub const PTR: *const ccu80_cc80::RegisterBlock = 0x4002_0400 as *const _;
6294 #[doc = r"Return the pointer to the register block"]
6295 #[inline(always)]
6296 pub const fn ptr() -> *const ccu80_cc80::RegisterBlock {
6297 Self::PTR
6298 }
6299 #[doc = r" Steal an instance of this peripheral"]
6300 #[doc = r""]
6301 #[doc = r" # Safety"]
6302 #[doc = r""]
6303 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6304 #[doc = r" that may race with any existing instances, for example by only"]
6305 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6306 #[doc = r" original peripheral and using critical sections to coordinate"]
6307 #[doc = r" access between multiple new instances."]
6308 #[doc = r""]
6309 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6310 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6311 #[doc = r" no stolen instances are passed to such software."]
6312 pub unsafe fn steal() -> Self {
6313 Self { _marker: PhantomData }
6314 }
6315}
6316impl Deref for CCU80_CC83 {
6317 type Target = ccu80_cc80::RegisterBlock;
6318 #[inline(always)]
6319 fn deref(&self) -> &Self::Target {
6320 unsafe { &*Self::PTR }
6321 }
6322}
6323impl core::fmt::Debug for CCU80_CC83 {
6324 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6325 f.debug_struct("CCU80_CC83").finish()
6326 }
6327}
6328#[doc = "Capture Compare Unit 8 - Unit 0"]
6329pub use self::ccu80_cc80 as ccu80_cc83;
6330#[doc = "High Resolution PWM Unit"]
6331pub struct HRPWM0 {
6332 _marker: PhantomData<*const ()>,
6333}
6334unsafe impl Send for HRPWM0 {}
6335impl HRPWM0 {
6336 #[doc = r"Pointer to the register block"]
6337 pub const PTR: *const hrpwm0::RegisterBlock = 0x4002_0900 as *const _;
6338 #[doc = r"Return the pointer to the register block"]
6339 #[inline(always)]
6340 pub const fn ptr() -> *const hrpwm0::RegisterBlock {
6341 Self::PTR
6342 }
6343 #[doc = r" Steal an instance of this peripheral"]
6344 #[doc = r""]
6345 #[doc = r" # Safety"]
6346 #[doc = r""]
6347 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6348 #[doc = r" that may race with any existing instances, for example by only"]
6349 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6350 #[doc = r" original peripheral and using critical sections to coordinate"]
6351 #[doc = r" access between multiple new instances."]
6352 #[doc = r""]
6353 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6354 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6355 #[doc = r" no stolen instances are passed to such software."]
6356 pub unsafe fn steal() -> Self {
6357 Self { _marker: PhantomData }
6358 }
6359}
6360impl Deref for HRPWM0 {
6361 type Target = hrpwm0::RegisterBlock;
6362 #[inline(always)]
6363 fn deref(&self) -> &Self::Target {
6364 unsafe { &*Self::PTR }
6365 }
6366}
6367impl core::fmt::Debug for HRPWM0 {
6368 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6369 f.debug_struct("HRPWM0").finish()
6370 }
6371}
6372#[doc = "High Resolution PWM Unit"]
6373pub mod hrpwm0;
6374#[doc = "High Resolution PWM Unit"]
6375pub struct HRPWM0_CSG0 {
6376 _marker: PhantomData<*const ()>,
6377}
6378unsafe impl Send for HRPWM0_CSG0 {}
6379impl HRPWM0_CSG0 {
6380 #[doc = r"Pointer to the register block"]
6381 pub const PTR: *const hrpwm0_csg0::RegisterBlock = 0x4002_0a00 as *const _;
6382 #[doc = r"Return the pointer to the register block"]
6383 #[inline(always)]
6384 pub const fn ptr() -> *const hrpwm0_csg0::RegisterBlock {
6385 Self::PTR
6386 }
6387 #[doc = r" Steal an instance of this peripheral"]
6388 #[doc = r""]
6389 #[doc = r" # Safety"]
6390 #[doc = r""]
6391 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6392 #[doc = r" that may race with any existing instances, for example by only"]
6393 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6394 #[doc = r" original peripheral and using critical sections to coordinate"]
6395 #[doc = r" access between multiple new instances."]
6396 #[doc = r""]
6397 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6398 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6399 #[doc = r" no stolen instances are passed to such software."]
6400 pub unsafe fn steal() -> Self {
6401 Self { _marker: PhantomData }
6402 }
6403}
6404impl Deref for HRPWM0_CSG0 {
6405 type Target = hrpwm0_csg0::RegisterBlock;
6406 #[inline(always)]
6407 fn deref(&self) -> &Self::Target {
6408 unsafe { &*Self::PTR }
6409 }
6410}
6411impl core::fmt::Debug for HRPWM0_CSG0 {
6412 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6413 f.debug_struct("HRPWM0_CSG0").finish()
6414 }
6415}
6416#[doc = "High Resolution PWM Unit"]
6417pub mod hrpwm0_csg0;
6418#[doc = "High Resolution PWM Unit"]
6419pub struct HRPWM0_CSG1 {
6420 _marker: PhantomData<*const ()>,
6421}
6422unsafe impl Send for HRPWM0_CSG1 {}
6423impl HRPWM0_CSG1 {
6424 #[doc = r"Pointer to the register block"]
6425 pub const PTR: *const hrpwm0_csg0::RegisterBlock = 0x4002_0b00 as *const _;
6426 #[doc = r"Return the pointer to the register block"]
6427 #[inline(always)]
6428 pub const fn ptr() -> *const hrpwm0_csg0::RegisterBlock {
6429 Self::PTR
6430 }
6431 #[doc = r" Steal an instance of this peripheral"]
6432 #[doc = r""]
6433 #[doc = r" # Safety"]
6434 #[doc = r""]
6435 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6436 #[doc = r" that may race with any existing instances, for example by only"]
6437 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6438 #[doc = r" original peripheral and using critical sections to coordinate"]
6439 #[doc = r" access between multiple new instances."]
6440 #[doc = r""]
6441 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6442 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6443 #[doc = r" no stolen instances are passed to such software."]
6444 pub unsafe fn steal() -> Self {
6445 Self { _marker: PhantomData }
6446 }
6447}
6448impl Deref for HRPWM0_CSG1 {
6449 type Target = hrpwm0_csg0::RegisterBlock;
6450 #[inline(always)]
6451 fn deref(&self) -> &Self::Target {
6452 unsafe { &*Self::PTR }
6453 }
6454}
6455impl core::fmt::Debug for HRPWM0_CSG1 {
6456 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6457 f.debug_struct("HRPWM0_CSG1").finish()
6458 }
6459}
6460#[doc = "High Resolution PWM Unit"]
6461pub use self::hrpwm0_csg0 as hrpwm0_csg1;
6462#[doc = "High Resolution PWM Unit"]
6463pub struct HRPWM0_CSG2 {
6464 _marker: PhantomData<*const ()>,
6465}
6466unsafe impl Send for HRPWM0_CSG2 {}
6467impl HRPWM0_CSG2 {
6468 #[doc = r"Pointer to the register block"]
6469 pub const PTR: *const hrpwm0_csg0::RegisterBlock = 0x4002_0c00 as *const _;
6470 #[doc = r"Return the pointer to the register block"]
6471 #[inline(always)]
6472 pub const fn ptr() -> *const hrpwm0_csg0::RegisterBlock {
6473 Self::PTR
6474 }
6475 #[doc = r" Steal an instance of this peripheral"]
6476 #[doc = r""]
6477 #[doc = r" # Safety"]
6478 #[doc = r""]
6479 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6480 #[doc = r" that may race with any existing instances, for example by only"]
6481 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6482 #[doc = r" original peripheral and using critical sections to coordinate"]
6483 #[doc = r" access between multiple new instances."]
6484 #[doc = r""]
6485 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6486 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6487 #[doc = r" no stolen instances are passed to such software."]
6488 pub unsafe fn steal() -> Self {
6489 Self { _marker: PhantomData }
6490 }
6491}
6492impl Deref for HRPWM0_CSG2 {
6493 type Target = hrpwm0_csg0::RegisterBlock;
6494 #[inline(always)]
6495 fn deref(&self) -> &Self::Target {
6496 unsafe { &*Self::PTR }
6497 }
6498}
6499impl core::fmt::Debug for HRPWM0_CSG2 {
6500 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6501 f.debug_struct("HRPWM0_CSG2").finish()
6502 }
6503}
6504#[doc = "High Resolution PWM Unit"]
6505pub use self::hrpwm0_csg0 as hrpwm0_csg2;
6506#[doc = "High Resolution PWM Unit"]
6507pub struct HRPWM0_HRC0 {
6508 _marker: PhantomData<*const ()>,
6509}
6510unsafe impl Send for HRPWM0_HRC0 {}
6511impl HRPWM0_HRC0 {
6512 #[doc = r"Pointer to the register block"]
6513 pub const PTR: *const hrpwm0_hrc0::RegisterBlock = 0x4002_1300 as *const _;
6514 #[doc = r"Return the pointer to the register block"]
6515 #[inline(always)]
6516 pub const fn ptr() -> *const hrpwm0_hrc0::RegisterBlock {
6517 Self::PTR
6518 }
6519 #[doc = r" Steal an instance of this peripheral"]
6520 #[doc = r""]
6521 #[doc = r" # Safety"]
6522 #[doc = r""]
6523 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6524 #[doc = r" that may race with any existing instances, for example by only"]
6525 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6526 #[doc = r" original peripheral and using critical sections to coordinate"]
6527 #[doc = r" access between multiple new instances."]
6528 #[doc = r""]
6529 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6530 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6531 #[doc = r" no stolen instances are passed to such software."]
6532 pub unsafe fn steal() -> Self {
6533 Self { _marker: PhantomData }
6534 }
6535}
6536impl Deref for HRPWM0_HRC0 {
6537 type Target = hrpwm0_hrc0::RegisterBlock;
6538 #[inline(always)]
6539 fn deref(&self) -> &Self::Target {
6540 unsafe { &*Self::PTR }
6541 }
6542}
6543impl core::fmt::Debug for HRPWM0_HRC0 {
6544 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6545 f.debug_struct("HRPWM0_HRC0").finish()
6546 }
6547}
6548#[doc = "High Resolution PWM Unit"]
6549pub mod hrpwm0_hrc0;
6550#[doc = "High Resolution PWM Unit"]
6551pub struct HRPWM0_HRC1 {
6552 _marker: PhantomData<*const ()>,
6553}
6554unsafe impl Send for HRPWM0_HRC1 {}
6555impl HRPWM0_HRC1 {
6556 #[doc = r"Pointer to the register block"]
6557 pub const PTR: *const hrpwm0_hrc0::RegisterBlock = 0x4002_1400 as *const _;
6558 #[doc = r"Return the pointer to the register block"]
6559 #[inline(always)]
6560 pub const fn ptr() -> *const hrpwm0_hrc0::RegisterBlock {
6561 Self::PTR
6562 }
6563 #[doc = r" Steal an instance of this peripheral"]
6564 #[doc = r""]
6565 #[doc = r" # Safety"]
6566 #[doc = r""]
6567 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6568 #[doc = r" that may race with any existing instances, for example by only"]
6569 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6570 #[doc = r" original peripheral and using critical sections to coordinate"]
6571 #[doc = r" access between multiple new instances."]
6572 #[doc = r""]
6573 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6574 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6575 #[doc = r" no stolen instances are passed to such software."]
6576 pub unsafe fn steal() -> Self {
6577 Self { _marker: PhantomData }
6578 }
6579}
6580impl Deref for HRPWM0_HRC1 {
6581 type Target = hrpwm0_hrc0::RegisterBlock;
6582 #[inline(always)]
6583 fn deref(&self) -> &Self::Target {
6584 unsafe { &*Self::PTR }
6585 }
6586}
6587impl core::fmt::Debug for HRPWM0_HRC1 {
6588 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6589 f.debug_struct("HRPWM0_HRC1").finish()
6590 }
6591}
6592#[doc = "High Resolution PWM Unit"]
6593pub use self::hrpwm0_hrc0 as hrpwm0_hrc1;
6594#[doc = "High Resolution PWM Unit"]
6595pub struct HRPWM0_HRC2 {
6596 _marker: PhantomData<*const ()>,
6597}
6598unsafe impl Send for HRPWM0_HRC2 {}
6599impl HRPWM0_HRC2 {
6600 #[doc = r"Pointer to the register block"]
6601 pub const PTR: *const hrpwm0_hrc0::RegisterBlock = 0x4002_1500 as *const _;
6602 #[doc = r"Return the pointer to the register block"]
6603 #[inline(always)]
6604 pub const fn ptr() -> *const hrpwm0_hrc0::RegisterBlock {
6605 Self::PTR
6606 }
6607 #[doc = r" Steal an instance of this peripheral"]
6608 #[doc = r""]
6609 #[doc = r" # Safety"]
6610 #[doc = r""]
6611 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6612 #[doc = r" that may race with any existing instances, for example by only"]
6613 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6614 #[doc = r" original peripheral and using critical sections to coordinate"]
6615 #[doc = r" access between multiple new instances."]
6616 #[doc = r""]
6617 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6618 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6619 #[doc = r" no stolen instances are passed to such software."]
6620 pub unsafe fn steal() -> Self {
6621 Self { _marker: PhantomData }
6622 }
6623}
6624impl Deref for HRPWM0_HRC2 {
6625 type Target = hrpwm0_hrc0::RegisterBlock;
6626 #[inline(always)]
6627 fn deref(&self) -> &Self::Target {
6628 unsafe { &*Self::PTR }
6629 }
6630}
6631impl core::fmt::Debug for HRPWM0_HRC2 {
6632 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6633 f.debug_struct("HRPWM0_HRC2").finish()
6634 }
6635}
6636#[doc = "High Resolution PWM Unit"]
6637pub use self::hrpwm0_hrc0 as hrpwm0_hrc2;
6638#[doc = "High Resolution PWM Unit"]
6639pub struct HRPWM0_HRC3 {
6640 _marker: PhantomData<*const ()>,
6641}
6642unsafe impl Send for HRPWM0_HRC3 {}
6643impl HRPWM0_HRC3 {
6644 #[doc = r"Pointer to the register block"]
6645 pub const PTR: *const hrpwm0_hrc0::RegisterBlock = 0x4002_1600 as *const _;
6646 #[doc = r"Return the pointer to the register block"]
6647 #[inline(always)]
6648 pub const fn ptr() -> *const hrpwm0_hrc0::RegisterBlock {
6649 Self::PTR
6650 }
6651 #[doc = r" Steal an instance of this peripheral"]
6652 #[doc = r""]
6653 #[doc = r" # Safety"]
6654 #[doc = r""]
6655 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6656 #[doc = r" that may race with any existing instances, for example by only"]
6657 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6658 #[doc = r" original peripheral and using critical sections to coordinate"]
6659 #[doc = r" access between multiple new instances."]
6660 #[doc = r""]
6661 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6662 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6663 #[doc = r" no stolen instances are passed to such software."]
6664 pub unsafe fn steal() -> Self {
6665 Self { _marker: PhantomData }
6666 }
6667}
6668impl Deref for HRPWM0_HRC3 {
6669 type Target = hrpwm0_hrc0::RegisterBlock;
6670 #[inline(always)]
6671 fn deref(&self) -> &Self::Target {
6672 unsafe { &*Self::PTR }
6673 }
6674}
6675impl core::fmt::Debug for HRPWM0_HRC3 {
6676 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6677 f.debug_struct("HRPWM0_HRC3").finish()
6678 }
6679}
6680#[doc = "High Resolution PWM Unit"]
6681pub use self::hrpwm0_hrc0 as hrpwm0_hrc3;
6682#[doc = "Position Interface 0"]
6683pub struct POSIF0 {
6684 _marker: PhantomData<*const ()>,
6685}
6686unsafe impl Send for POSIF0 {}
6687impl POSIF0 {
6688 #[doc = r"Pointer to the register block"]
6689 pub const PTR: *const posif0::RegisterBlock = 0x4002_8000 as *const _;
6690 #[doc = r"Return the pointer to the register block"]
6691 #[inline(always)]
6692 pub const fn ptr() -> *const posif0::RegisterBlock {
6693 Self::PTR
6694 }
6695 #[doc = r" Steal an instance of this peripheral"]
6696 #[doc = r""]
6697 #[doc = r" # Safety"]
6698 #[doc = r""]
6699 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6700 #[doc = r" that may race with any existing instances, for example by only"]
6701 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6702 #[doc = r" original peripheral and using critical sections to coordinate"]
6703 #[doc = r" access between multiple new instances."]
6704 #[doc = r""]
6705 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6706 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6707 #[doc = r" no stolen instances are passed to such software."]
6708 pub unsafe fn steal() -> Self {
6709 Self { _marker: PhantomData }
6710 }
6711}
6712impl Deref for POSIF0 {
6713 type Target = posif0::RegisterBlock;
6714 #[inline(always)]
6715 fn deref(&self) -> &Self::Target {
6716 unsafe { &*Self::PTR }
6717 }
6718}
6719impl core::fmt::Debug for POSIF0 {
6720 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6721 f.debug_struct("POSIF0").finish()
6722 }
6723}
6724#[doc = "Position Interface 0"]
6725pub mod posif0;
6726#[doc = "Port 0"]
6727pub struct PORT0 {
6728 _marker: PhantomData<*const ()>,
6729}
6730unsafe impl Send for PORT0 {}
6731impl PORT0 {
6732 #[doc = r"Pointer to the register block"]
6733 pub const PTR: *const port0::RegisterBlock = 0x4802_8000 as *const _;
6734 #[doc = r"Return the pointer to the register block"]
6735 #[inline(always)]
6736 pub const fn ptr() -> *const port0::RegisterBlock {
6737 Self::PTR
6738 }
6739 #[doc = r" Steal an instance of this peripheral"]
6740 #[doc = r""]
6741 #[doc = r" # Safety"]
6742 #[doc = r""]
6743 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6744 #[doc = r" that may race with any existing instances, for example by only"]
6745 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6746 #[doc = r" original peripheral and using critical sections to coordinate"]
6747 #[doc = r" access between multiple new instances."]
6748 #[doc = r""]
6749 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6750 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6751 #[doc = r" no stolen instances are passed to such software."]
6752 pub unsafe fn steal() -> Self {
6753 Self { _marker: PhantomData }
6754 }
6755}
6756impl Deref for PORT0 {
6757 type Target = port0::RegisterBlock;
6758 #[inline(always)]
6759 fn deref(&self) -> &Self::Target {
6760 unsafe { &*Self::PTR }
6761 }
6762}
6763impl core::fmt::Debug for PORT0 {
6764 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6765 f.debug_struct("PORT0").finish()
6766 }
6767}
6768#[doc = "Port 0"]
6769pub mod port0;
6770#[doc = "Port 1"]
6771pub struct PORT1 {
6772 _marker: PhantomData<*const ()>,
6773}
6774unsafe impl Send for PORT1 {}
6775impl PORT1 {
6776 #[doc = r"Pointer to the register block"]
6777 pub const PTR: *const port1::RegisterBlock = 0x4802_8100 as *const _;
6778 #[doc = r"Return the pointer to the register block"]
6779 #[inline(always)]
6780 pub const fn ptr() -> *const port1::RegisterBlock {
6781 Self::PTR
6782 }
6783 #[doc = r" Steal an instance of this peripheral"]
6784 #[doc = r""]
6785 #[doc = r" # Safety"]
6786 #[doc = r""]
6787 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6788 #[doc = r" that may race with any existing instances, for example by only"]
6789 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6790 #[doc = r" original peripheral and using critical sections to coordinate"]
6791 #[doc = r" access between multiple new instances."]
6792 #[doc = r""]
6793 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6794 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6795 #[doc = r" no stolen instances are passed to such software."]
6796 pub unsafe fn steal() -> Self {
6797 Self { _marker: PhantomData }
6798 }
6799}
6800impl Deref for PORT1 {
6801 type Target = port1::RegisterBlock;
6802 #[inline(always)]
6803 fn deref(&self) -> &Self::Target {
6804 unsafe { &*Self::PTR }
6805 }
6806}
6807impl core::fmt::Debug for PORT1 {
6808 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6809 f.debug_struct("PORT1").finish()
6810 }
6811}
6812#[doc = "Port 1"]
6813pub mod port1;
6814#[doc = "Port 2"]
6815pub struct PORT2 {
6816 _marker: PhantomData<*const ()>,
6817}
6818unsafe impl Send for PORT2 {}
6819impl PORT2 {
6820 #[doc = r"Pointer to the register block"]
6821 pub const PTR: *const port2::RegisterBlock = 0x4802_8200 as *const _;
6822 #[doc = r"Return the pointer to the register block"]
6823 #[inline(always)]
6824 pub const fn ptr() -> *const port2::RegisterBlock {
6825 Self::PTR
6826 }
6827 #[doc = r" Steal an instance of this peripheral"]
6828 #[doc = r""]
6829 #[doc = r" # Safety"]
6830 #[doc = r""]
6831 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6832 #[doc = r" that may race with any existing instances, for example by only"]
6833 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6834 #[doc = r" original peripheral and using critical sections to coordinate"]
6835 #[doc = r" access between multiple new instances."]
6836 #[doc = r""]
6837 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6838 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6839 #[doc = r" no stolen instances are passed to such software."]
6840 pub unsafe fn steal() -> Self {
6841 Self { _marker: PhantomData }
6842 }
6843}
6844impl Deref for PORT2 {
6845 type Target = port2::RegisterBlock;
6846 #[inline(always)]
6847 fn deref(&self) -> &Self::Target {
6848 unsafe { &*Self::PTR }
6849 }
6850}
6851impl core::fmt::Debug for PORT2 {
6852 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6853 f.debug_struct("PORT2").finish()
6854 }
6855}
6856#[doc = "Port 2"]
6857pub mod port2;
6858#[doc = "Port 3"]
6859pub struct PORT3 {
6860 _marker: PhantomData<*const ()>,
6861}
6862unsafe impl Send for PORT3 {}
6863impl PORT3 {
6864 #[doc = r"Pointer to the register block"]
6865 pub const PTR: *const port3::RegisterBlock = 0x4802_8300 as *const _;
6866 #[doc = r"Return the pointer to the register block"]
6867 #[inline(always)]
6868 pub const fn ptr() -> *const port3::RegisterBlock {
6869 Self::PTR
6870 }
6871 #[doc = r" Steal an instance of this peripheral"]
6872 #[doc = r""]
6873 #[doc = r" # Safety"]
6874 #[doc = r""]
6875 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6876 #[doc = r" that may race with any existing instances, for example by only"]
6877 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6878 #[doc = r" original peripheral and using critical sections to coordinate"]
6879 #[doc = r" access between multiple new instances."]
6880 #[doc = r""]
6881 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6882 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6883 #[doc = r" no stolen instances are passed to such software."]
6884 pub unsafe fn steal() -> Self {
6885 Self { _marker: PhantomData }
6886 }
6887}
6888impl Deref for PORT3 {
6889 type Target = port3::RegisterBlock;
6890 #[inline(always)]
6891 fn deref(&self) -> &Self::Target {
6892 unsafe { &*Self::PTR }
6893 }
6894}
6895impl core::fmt::Debug for PORT3 {
6896 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6897 f.debug_struct("PORT3").finish()
6898 }
6899}
6900#[doc = "Port 3"]
6901pub mod port3;
6902#[doc = "Port 14"]
6903pub struct PORT14 {
6904 _marker: PhantomData<*const ()>,
6905}
6906unsafe impl Send for PORT14 {}
6907impl PORT14 {
6908 #[doc = r"Pointer to the register block"]
6909 pub const PTR: *const port14::RegisterBlock = 0x4802_8e00 as *const _;
6910 #[doc = r"Return the pointer to the register block"]
6911 #[inline(always)]
6912 pub const fn ptr() -> *const port14::RegisterBlock {
6913 Self::PTR
6914 }
6915 #[doc = r" Steal an instance of this peripheral"]
6916 #[doc = r""]
6917 #[doc = r" # Safety"]
6918 #[doc = r""]
6919 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6920 #[doc = r" that may race with any existing instances, for example by only"]
6921 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6922 #[doc = r" original peripheral and using critical sections to coordinate"]
6923 #[doc = r" access between multiple new instances."]
6924 #[doc = r""]
6925 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6926 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6927 #[doc = r" no stolen instances are passed to such software."]
6928 pub unsafe fn steal() -> Self {
6929 Self { _marker: PhantomData }
6930 }
6931}
6932impl Deref for PORT14 {
6933 type Target = port14::RegisterBlock;
6934 #[inline(always)]
6935 fn deref(&self) -> &Self::Target {
6936 unsafe { &*Self::PTR }
6937 }
6938}
6939impl core::fmt::Debug for PORT14 {
6940 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6941 f.debug_struct("PORT14").finish()
6942 }
6943}
6944#[doc = "Port 14"]
6945pub mod port14;
6946#[no_mangle]
6947static mut DEVICE_PERIPHERALS: bool = false;
6948#[doc = r" All the peripherals."]
6949#[allow(non_snake_case)]
6950pub struct Peripherals {
6951 #[doc = "PPB"]
6952 pub PPB: PPB,
6953 #[doc = "DLR"]
6954 pub DLR: DLR,
6955 #[doc = "ERU0"]
6956 pub ERU0: ERU0,
6957 #[doc = "ERU1"]
6958 pub ERU1: ERU1,
6959 #[doc = "GPDMA0"]
6960 pub GPDMA0: GPDMA0,
6961 #[doc = "GPDMA0_CH0"]
6962 pub GPDMA0_CH0: GPDMA0_CH0,
6963 #[doc = "GPDMA0_CH1"]
6964 pub GPDMA0_CH1: GPDMA0_CH1,
6965 #[doc = "GPDMA0_CH2"]
6966 pub GPDMA0_CH2: GPDMA0_CH2,
6967 #[doc = "GPDMA0_CH3"]
6968 pub GPDMA0_CH3: GPDMA0_CH3,
6969 #[doc = "GPDMA0_CH4"]
6970 pub GPDMA0_CH4: GPDMA0_CH4,
6971 #[doc = "GPDMA0_CH5"]
6972 pub GPDMA0_CH5: GPDMA0_CH5,
6973 #[doc = "GPDMA0_CH6"]
6974 pub GPDMA0_CH6: GPDMA0_CH6,
6975 #[doc = "GPDMA0_CH7"]
6976 pub GPDMA0_CH7: GPDMA0_CH7,
6977 #[doc = "FCE"]
6978 pub FCE: FCE,
6979 #[doc = "FCE_KE0"]
6980 pub FCE_KE0: FCE_KE0,
6981 #[doc = "FCE_KE1"]
6982 pub FCE_KE1: FCE_KE1,
6983 #[doc = "FCE_KE2"]
6984 pub FCE_KE2: FCE_KE2,
6985 #[doc = "FCE_KE3"]
6986 pub FCE_KE3: FCE_KE3,
6987 #[doc = "PBA0"]
6988 pub PBA0: PBA0,
6989 #[doc = "PBA1"]
6990 pub PBA1: PBA1,
6991 #[doc = "FLASH0"]
6992 pub FLASH0: FLASH0,
6993 #[doc = "PREF"]
6994 pub PREF: PREF,
6995 #[doc = "PMU0"]
6996 pub PMU0: PMU0,
6997 #[doc = "WDT"]
6998 pub WDT: WDT,
6999 #[doc = "RTC"]
7000 pub RTC: RTC,
7001 #[doc = "SCU_CLK"]
7002 pub SCU_CLK: SCU_CLK,
7003 #[doc = "SCU_OSC"]
7004 pub SCU_OSC: SCU_OSC,
7005 #[doc = "SCU_PLL"]
7006 pub SCU_PLL: SCU_PLL,
7007 #[doc = "SCU_GENERAL"]
7008 pub SCU_GENERAL: SCU_GENERAL,
7009 #[doc = "SCU_INTERRUPT"]
7010 pub SCU_INTERRUPT: SCU_INTERRUPT,
7011 #[doc = "SCU_PARITY"]
7012 pub SCU_PARITY: SCU_PARITY,
7013 #[doc = "SCU_TRAP"]
7014 pub SCU_TRAP: SCU_TRAP,
7015 #[doc = "SCU_HIBERNATE"]
7016 pub SCU_HIBERNATE: SCU_HIBERNATE,
7017 #[doc = "SCU_POWER"]
7018 pub SCU_POWER: SCU_POWER,
7019 #[doc = "SCU_RESET"]
7020 pub SCU_RESET: SCU_RESET,
7021 #[doc = "LEDTS0"]
7022 pub LEDTS0: LEDTS0,
7023 #[doc = "USB0"]
7024 pub USB0: USB0,
7025 #[doc = "USB0_EP0"]
7026 pub USB0_EP0: USB0_EP0,
7027 #[doc = "USB0_EP1"]
7028 pub USB0_EP1: USB0_EP1,
7029 #[doc = "USB0_EP2"]
7030 pub USB0_EP2: USB0_EP2,
7031 #[doc = "USB0_EP3"]
7032 pub USB0_EP3: USB0_EP3,
7033 #[doc = "USB0_EP4"]
7034 pub USB0_EP4: USB0_EP4,
7035 #[doc = "USB0_EP5"]
7036 pub USB0_EP5: USB0_EP5,
7037 #[doc = "USB0_EP6"]
7038 pub USB0_EP6: USB0_EP6,
7039 #[doc = "USIC0"]
7040 pub USIC0: USIC0,
7041 #[doc = "USIC1"]
7042 pub USIC1: USIC1,
7043 #[doc = "USIC0_CH0"]
7044 pub USIC0_CH0: USIC0_CH0,
7045 #[doc = "USIC0_CH1"]
7046 pub USIC0_CH1: USIC0_CH1,
7047 #[doc = "USIC1_CH0"]
7048 pub USIC1_CH0: USIC1_CH0,
7049 #[doc = "USIC1_CH1"]
7050 pub USIC1_CH1: USIC1_CH1,
7051 #[doc = "CAN"]
7052 pub CAN: CAN,
7053 #[doc = "CAN_NODE0"]
7054 pub CAN_NODE0: CAN_NODE0,
7055 #[doc = "CAN_NODE1"]
7056 pub CAN_NODE1: CAN_NODE1,
7057 #[doc = "CAN_MO0"]
7058 pub CAN_MO0: CAN_MO0,
7059 #[doc = "CAN_MO1"]
7060 pub CAN_MO1: CAN_MO1,
7061 #[doc = "CAN_MO2"]
7062 pub CAN_MO2: CAN_MO2,
7063 #[doc = "CAN_MO3"]
7064 pub CAN_MO3: CAN_MO3,
7065 #[doc = "CAN_MO4"]
7066 pub CAN_MO4: CAN_MO4,
7067 #[doc = "CAN_MO5"]
7068 pub CAN_MO5: CAN_MO5,
7069 #[doc = "CAN_MO6"]
7070 pub CAN_MO6: CAN_MO6,
7071 #[doc = "CAN_MO7"]
7072 pub CAN_MO7: CAN_MO7,
7073 #[doc = "CAN_MO8"]
7074 pub CAN_MO8: CAN_MO8,
7075 #[doc = "CAN_MO9"]
7076 pub CAN_MO9: CAN_MO9,
7077 #[doc = "CAN_MO10"]
7078 pub CAN_MO10: CAN_MO10,
7079 #[doc = "CAN_MO11"]
7080 pub CAN_MO11: CAN_MO11,
7081 #[doc = "CAN_MO12"]
7082 pub CAN_MO12: CAN_MO12,
7083 #[doc = "CAN_MO13"]
7084 pub CAN_MO13: CAN_MO13,
7085 #[doc = "CAN_MO14"]
7086 pub CAN_MO14: CAN_MO14,
7087 #[doc = "CAN_MO15"]
7088 pub CAN_MO15: CAN_MO15,
7089 #[doc = "CAN_MO16"]
7090 pub CAN_MO16: CAN_MO16,
7091 #[doc = "CAN_MO17"]
7092 pub CAN_MO17: CAN_MO17,
7093 #[doc = "CAN_MO18"]
7094 pub CAN_MO18: CAN_MO18,
7095 #[doc = "CAN_MO19"]
7096 pub CAN_MO19: CAN_MO19,
7097 #[doc = "CAN_MO20"]
7098 pub CAN_MO20: CAN_MO20,
7099 #[doc = "CAN_MO21"]
7100 pub CAN_MO21: CAN_MO21,
7101 #[doc = "CAN_MO22"]
7102 pub CAN_MO22: CAN_MO22,
7103 #[doc = "CAN_MO23"]
7104 pub CAN_MO23: CAN_MO23,
7105 #[doc = "CAN_MO24"]
7106 pub CAN_MO24: CAN_MO24,
7107 #[doc = "CAN_MO25"]
7108 pub CAN_MO25: CAN_MO25,
7109 #[doc = "CAN_MO26"]
7110 pub CAN_MO26: CAN_MO26,
7111 #[doc = "CAN_MO27"]
7112 pub CAN_MO27: CAN_MO27,
7113 #[doc = "CAN_MO28"]
7114 pub CAN_MO28: CAN_MO28,
7115 #[doc = "CAN_MO29"]
7116 pub CAN_MO29: CAN_MO29,
7117 #[doc = "CAN_MO30"]
7118 pub CAN_MO30: CAN_MO30,
7119 #[doc = "CAN_MO31"]
7120 pub CAN_MO31: CAN_MO31,
7121 #[doc = "CAN_MO32"]
7122 pub CAN_MO32: CAN_MO32,
7123 #[doc = "CAN_MO33"]
7124 pub CAN_MO33: CAN_MO33,
7125 #[doc = "CAN_MO34"]
7126 pub CAN_MO34: CAN_MO34,
7127 #[doc = "CAN_MO35"]
7128 pub CAN_MO35: CAN_MO35,
7129 #[doc = "CAN_MO36"]
7130 pub CAN_MO36: CAN_MO36,
7131 #[doc = "CAN_MO37"]
7132 pub CAN_MO37: CAN_MO37,
7133 #[doc = "CAN_MO38"]
7134 pub CAN_MO38: CAN_MO38,
7135 #[doc = "CAN_MO39"]
7136 pub CAN_MO39: CAN_MO39,
7137 #[doc = "CAN_MO40"]
7138 pub CAN_MO40: CAN_MO40,
7139 #[doc = "CAN_MO41"]
7140 pub CAN_MO41: CAN_MO41,
7141 #[doc = "CAN_MO42"]
7142 pub CAN_MO42: CAN_MO42,
7143 #[doc = "CAN_MO43"]
7144 pub CAN_MO43: CAN_MO43,
7145 #[doc = "CAN_MO44"]
7146 pub CAN_MO44: CAN_MO44,
7147 #[doc = "CAN_MO45"]
7148 pub CAN_MO45: CAN_MO45,
7149 #[doc = "CAN_MO46"]
7150 pub CAN_MO46: CAN_MO46,
7151 #[doc = "CAN_MO47"]
7152 pub CAN_MO47: CAN_MO47,
7153 #[doc = "CAN_MO48"]
7154 pub CAN_MO48: CAN_MO48,
7155 #[doc = "CAN_MO49"]
7156 pub CAN_MO49: CAN_MO49,
7157 #[doc = "CAN_MO50"]
7158 pub CAN_MO50: CAN_MO50,
7159 #[doc = "CAN_MO51"]
7160 pub CAN_MO51: CAN_MO51,
7161 #[doc = "CAN_MO52"]
7162 pub CAN_MO52: CAN_MO52,
7163 #[doc = "CAN_MO53"]
7164 pub CAN_MO53: CAN_MO53,
7165 #[doc = "CAN_MO54"]
7166 pub CAN_MO54: CAN_MO54,
7167 #[doc = "CAN_MO55"]
7168 pub CAN_MO55: CAN_MO55,
7169 #[doc = "CAN_MO56"]
7170 pub CAN_MO56: CAN_MO56,
7171 #[doc = "CAN_MO57"]
7172 pub CAN_MO57: CAN_MO57,
7173 #[doc = "CAN_MO58"]
7174 pub CAN_MO58: CAN_MO58,
7175 #[doc = "CAN_MO59"]
7176 pub CAN_MO59: CAN_MO59,
7177 #[doc = "CAN_MO60"]
7178 pub CAN_MO60: CAN_MO60,
7179 #[doc = "CAN_MO61"]
7180 pub CAN_MO61: CAN_MO61,
7181 #[doc = "CAN_MO62"]
7182 pub CAN_MO62: CAN_MO62,
7183 #[doc = "CAN_MO63"]
7184 pub CAN_MO63: CAN_MO63,
7185 #[doc = "VADC"]
7186 pub VADC: VADC,
7187 #[doc = "VADC_G0"]
7188 pub VADC_G0: VADC_G0,
7189 #[doc = "VADC_G1"]
7190 pub VADC_G1: VADC_G1,
7191 #[doc = "DAC"]
7192 pub DAC: DAC,
7193 #[doc = "CCU40"]
7194 pub CCU40: CCU40,
7195 #[doc = "CCU41"]
7196 pub CCU41: CCU41,
7197 #[doc = "CCU40_CC40"]
7198 pub CCU40_CC40: CCU40_CC40,
7199 #[doc = "CCU40_CC41"]
7200 pub CCU40_CC41: CCU40_CC41,
7201 #[doc = "CCU40_CC42"]
7202 pub CCU40_CC42: CCU40_CC42,
7203 #[doc = "CCU40_CC43"]
7204 pub CCU40_CC43: CCU40_CC43,
7205 #[doc = "CCU41_CC40"]
7206 pub CCU41_CC40: CCU41_CC40,
7207 #[doc = "CCU41_CC41"]
7208 pub CCU41_CC41: CCU41_CC41,
7209 #[doc = "CCU41_CC42"]
7210 pub CCU41_CC42: CCU41_CC42,
7211 #[doc = "CCU41_CC43"]
7212 pub CCU41_CC43: CCU41_CC43,
7213 #[doc = "CCU80"]
7214 pub CCU80: CCU80,
7215 #[doc = "CCU80_CC80"]
7216 pub CCU80_CC80: CCU80_CC80,
7217 #[doc = "CCU80_CC81"]
7218 pub CCU80_CC81: CCU80_CC81,
7219 #[doc = "CCU80_CC82"]
7220 pub CCU80_CC82: CCU80_CC82,
7221 #[doc = "CCU80_CC83"]
7222 pub CCU80_CC83: CCU80_CC83,
7223 #[doc = "HRPWM0"]
7224 pub HRPWM0: HRPWM0,
7225 #[doc = "HRPWM0_CSG0"]
7226 pub HRPWM0_CSG0: HRPWM0_CSG0,
7227 #[doc = "HRPWM0_CSG1"]
7228 pub HRPWM0_CSG1: HRPWM0_CSG1,
7229 #[doc = "HRPWM0_CSG2"]
7230 pub HRPWM0_CSG2: HRPWM0_CSG2,
7231 #[doc = "HRPWM0_HRC0"]
7232 pub HRPWM0_HRC0: HRPWM0_HRC0,
7233 #[doc = "HRPWM0_HRC1"]
7234 pub HRPWM0_HRC1: HRPWM0_HRC1,
7235 #[doc = "HRPWM0_HRC2"]
7236 pub HRPWM0_HRC2: HRPWM0_HRC2,
7237 #[doc = "HRPWM0_HRC3"]
7238 pub HRPWM0_HRC3: HRPWM0_HRC3,
7239 #[doc = "POSIF0"]
7240 pub POSIF0: POSIF0,
7241 #[doc = "PORT0"]
7242 pub PORT0: PORT0,
7243 #[doc = "PORT1"]
7244 pub PORT1: PORT1,
7245 #[doc = "PORT2"]
7246 pub PORT2: PORT2,
7247 #[doc = "PORT3"]
7248 pub PORT3: PORT3,
7249 #[doc = "PORT14"]
7250 pub PORT14: PORT14,
7251}
7252impl Peripherals {
7253 #[doc = r" Returns all the peripherals *once*."]
7254 #[cfg(feature = "critical-section")]
7255 #[inline]
7256 pub fn take() -> Option<Self> {
7257 critical_section::with(|_| {
7258 if unsafe { DEVICE_PERIPHERALS } {
7259 return None;
7260 }
7261 Some(unsafe { Peripherals::steal() })
7262 })
7263 }
7264 #[doc = r" Unchecked version of `Peripherals::take`."]
7265 #[doc = r""]
7266 #[doc = r" # Safety"]
7267 #[doc = r""]
7268 #[doc = r" Each of the returned peripherals must be used at most once."]
7269 #[inline]
7270 pub unsafe fn steal() -> Self {
7271 DEVICE_PERIPHERALS = true;
7272 Peripherals {
7273 PPB: PPB::steal(),
7274 DLR: DLR::steal(),
7275 ERU0: ERU0::steal(),
7276 ERU1: ERU1::steal(),
7277 GPDMA0: GPDMA0::steal(),
7278 GPDMA0_CH0: GPDMA0_CH0::steal(),
7279 GPDMA0_CH1: GPDMA0_CH1::steal(),
7280 GPDMA0_CH2: GPDMA0_CH2::steal(),
7281 GPDMA0_CH3: GPDMA0_CH3::steal(),
7282 GPDMA0_CH4: GPDMA0_CH4::steal(),
7283 GPDMA0_CH5: GPDMA0_CH5::steal(),
7284 GPDMA0_CH6: GPDMA0_CH6::steal(),
7285 GPDMA0_CH7: GPDMA0_CH7::steal(),
7286 FCE: FCE::steal(),
7287 FCE_KE0: FCE_KE0::steal(),
7288 FCE_KE1: FCE_KE1::steal(),
7289 FCE_KE2: FCE_KE2::steal(),
7290 FCE_KE3: FCE_KE3::steal(),
7291 PBA0: PBA0::steal(),
7292 PBA1: PBA1::steal(),
7293 FLASH0: FLASH0::steal(),
7294 PREF: PREF::steal(),
7295 PMU0: PMU0::steal(),
7296 WDT: WDT::steal(),
7297 RTC: RTC::steal(),
7298 SCU_CLK: SCU_CLK::steal(),
7299 SCU_OSC: SCU_OSC::steal(),
7300 SCU_PLL: SCU_PLL::steal(),
7301 SCU_GENERAL: SCU_GENERAL::steal(),
7302 SCU_INTERRUPT: SCU_INTERRUPT::steal(),
7303 SCU_PARITY: SCU_PARITY::steal(),
7304 SCU_TRAP: SCU_TRAP::steal(),
7305 SCU_HIBERNATE: SCU_HIBERNATE::steal(),
7306 SCU_POWER: SCU_POWER::steal(),
7307 SCU_RESET: SCU_RESET::steal(),
7308 LEDTS0: LEDTS0::steal(),
7309 USB0: USB0::steal(),
7310 USB0_EP0: USB0_EP0::steal(),
7311 USB0_EP1: USB0_EP1::steal(),
7312 USB0_EP2: USB0_EP2::steal(),
7313 USB0_EP3: USB0_EP3::steal(),
7314 USB0_EP4: USB0_EP4::steal(),
7315 USB0_EP5: USB0_EP5::steal(),
7316 USB0_EP6: USB0_EP6::steal(),
7317 USIC0: USIC0::steal(),
7318 USIC1: USIC1::steal(),
7319 USIC0_CH0: USIC0_CH0::steal(),
7320 USIC0_CH1: USIC0_CH1::steal(),
7321 USIC1_CH0: USIC1_CH0::steal(),
7322 USIC1_CH1: USIC1_CH1::steal(),
7323 CAN: CAN::steal(),
7324 CAN_NODE0: CAN_NODE0::steal(),
7325 CAN_NODE1: CAN_NODE1::steal(),
7326 CAN_MO0: CAN_MO0::steal(),
7327 CAN_MO1: CAN_MO1::steal(),
7328 CAN_MO2: CAN_MO2::steal(),
7329 CAN_MO3: CAN_MO3::steal(),
7330 CAN_MO4: CAN_MO4::steal(),
7331 CAN_MO5: CAN_MO5::steal(),
7332 CAN_MO6: CAN_MO6::steal(),
7333 CAN_MO7: CAN_MO7::steal(),
7334 CAN_MO8: CAN_MO8::steal(),
7335 CAN_MO9: CAN_MO9::steal(),
7336 CAN_MO10: CAN_MO10::steal(),
7337 CAN_MO11: CAN_MO11::steal(),
7338 CAN_MO12: CAN_MO12::steal(),
7339 CAN_MO13: CAN_MO13::steal(),
7340 CAN_MO14: CAN_MO14::steal(),
7341 CAN_MO15: CAN_MO15::steal(),
7342 CAN_MO16: CAN_MO16::steal(),
7343 CAN_MO17: CAN_MO17::steal(),
7344 CAN_MO18: CAN_MO18::steal(),
7345 CAN_MO19: CAN_MO19::steal(),
7346 CAN_MO20: CAN_MO20::steal(),
7347 CAN_MO21: CAN_MO21::steal(),
7348 CAN_MO22: CAN_MO22::steal(),
7349 CAN_MO23: CAN_MO23::steal(),
7350 CAN_MO24: CAN_MO24::steal(),
7351 CAN_MO25: CAN_MO25::steal(),
7352 CAN_MO26: CAN_MO26::steal(),
7353 CAN_MO27: CAN_MO27::steal(),
7354 CAN_MO28: CAN_MO28::steal(),
7355 CAN_MO29: CAN_MO29::steal(),
7356 CAN_MO30: CAN_MO30::steal(),
7357 CAN_MO31: CAN_MO31::steal(),
7358 CAN_MO32: CAN_MO32::steal(),
7359 CAN_MO33: CAN_MO33::steal(),
7360 CAN_MO34: CAN_MO34::steal(),
7361 CAN_MO35: CAN_MO35::steal(),
7362 CAN_MO36: CAN_MO36::steal(),
7363 CAN_MO37: CAN_MO37::steal(),
7364 CAN_MO38: CAN_MO38::steal(),
7365 CAN_MO39: CAN_MO39::steal(),
7366 CAN_MO40: CAN_MO40::steal(),
7367 CAN_MO41: CAN_MO41::steal(),
7368 CAN_MO42: CAN_MO42::steal(),
7369 CAN_MO43: CAN_MO43::steal(),
7370 CAN_MO44: CAN_MO44::steal(),
7371 CAN_MO45: CAN_MO45::steal(),
7372 CAN_MO46: CAN_MO46::steal(),
7373 CAN_MO47: CAN_MO47::steal(),
7374 CAN_MO48: CAN_MO48::steal(),
7375 CAN_MO49: CAN_MO49::steal(),
7376 CAN_MO50: CAN_MO50::steal(),
7377 CAN_MO51: CAN_MO51::steal(),
7378 CAN_MO52: CAN_MO52::steal(),
7379 CAN_MO53: CAN_MO53::steal(),
7380 CAN_MO54: CAN_MO54::steal(),
7381 CAN_MO55: CAN_MO55::steal(),
7382 CAN_MO56: CAN_MO56::steal(),
7383 CAN_MO57: CAN_MO57::steal(),
7384 CAN_MO58: CAN_MO58::steal(),
7385 CAN_MO59: CAN_MO59::steal(),
7386 CAN_MO60: CAN_MO60::steal(),
7387 CAN_MO61: CAN_MO61::steal(),
7388 CAN_MO62: CAN_MO62::steal(),
7389 CAN_MO63: CAN_MO63::steal(),
7390 VADC: VADC::steal(),
7391 VADC_G0: VADC_G0::steal(),
7392 VADC_G1: VADC_G1::steal(),
7393 DAC: DAC::steal(),
7394 CCU40: CCU40::steal(),
7395 CCU41: CCU41::steal(),
7396 CCU40_CC40: CCU40_CC40::steal(),
7397 CCU40_CC41: CCU40_CC41::steal(),
7398 CCU40_CC42: CCU40_CC42::steal(),
7399 CCU40_CC43: CCU40_CC43::steal(),
7400 CCU41_CC40: CCU41_CC40::steal(),
7401 CCU41_CC41: CCU41_CC41::steal(),
7402 CCU41_CC42: CCU41_CC42::steal(),
7403 CCU41_CC43: CCU41_CC43::steal(),
7404 CCU80: CCU80::steal(),
7405 CCU80_CC80: CCU80_CC80::steal(),
7406 CCU80_CC81: CCU80_CC81::steal(),
7407 CCU80_CC82: CCU80_CC82::steal(),
7408 CCU80_CC83: CCU80_CC83::steal(),
7409 HRPWM0: HRPWM0::steal(),
7410 HRPWM0_CSG0: HRPWM0_CSG0::steal(),
7411 HRPWM0_CSG1: HRPWM0_CSG1::steal(),
7412 HRPWM0_CSG2: HRPWM0_CSG2::steal(),
7413 HRPWM0_HRC0: HRPWM0_HRC0::steal(),
7414 HRPWM0_HRC1: HRPWM0_HRC1::steal(),
7415 HRPWM0_HRC2: HRPWM0_HRC2::steal(),
7416 HRPWM0_HRC3: HRPWM0_HRC3::steal(),
7417 POSIF0: POSIF0::steal(),
7418 PORT0: PORT0::steal(),
7419 PORT1: PORT1::steal(),
7420 PORT2: PORT2::steal(),
7421 PORT3: PORT3::steal(),
7422 PORT14: PORT14::steal(),
7423 }
7424 }
7425}