1#![doc = "Peripheral access API for XMC4400 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 VADC0_G2_0();
39 fn VADC0_G2_1();
40 fn VADC0_G2_2();
41 fn VADC0_G2_3();
42 fn VADC0_G3_0();
43 fn VADC0_G3_1();
44 fn VADC0_G3_2();
45 fn VADC0_G3_3();
46 fn DSD0_M_0();
47 fn DSD0_M_1();
48 fn DSD0_M_2();
49 fn DSD0_M_3();
50 fn DSD0_A_4();
51 fn DSD0_A_5();
52 fn DSD0_A_6();
53 fn DSD0_A_7();
54 fn DAC0_0();
55 fn DAC0_1();
56 fn CCU40_0();
57 fn CCU40_1();
58 fn CCU40_2();
59 fn CCU40_3();
60 fn CCU41_0();
61 fn CCU41_1();
62 fn CCU41_2();
63 fn CCU41_3();
64 fn CCU42_0();
65 fn CCU42_1();
66 fn CCU42_2();
67 fn CCU42_3();
68 fn CCU43_0();
69 fn CCU43_1();
70 fn CCU43_2();
71 fn CCU43_3();
72 fn CCU80_0();
73 fn CCU80_1();
74 fn CCU80_2();
75 fn CCU80_3();
76 fn CCU81_0();
77 fn CCU81_1();
78 fn CCU81_2();
79 fn CCU81_3();
80 fn POSIF0_0();
81 fn POSIF0_1();
82 fn POSIF1_0();
83 fn POSIF1_1();
84 fn HRPWM_0();
85 fn HRPWM_1();
86 fn HRPWM_2();
87 fn HRPWM_3();
88 fn CAN0_0();
89 fn CAN0_1();
90 fn CAN0_2();
91 fn CAN0_3();
92 fn CAN0_4();
93 fn CAN0_5();
94 fn CAN0_6();
95 fn CAN0_7();
96 fn USIC0_0();
97 fn USIC0_1();
98 fn USIC0_2();
99 fn USIC0_3();
100 fn USIC0_4();
101 fn USIC0_5();
102 fn USIC1_0();
103 fn USIC1_1();
104 fn USIC1_2();
105 fn USIC1_3();
106 fn USIC1_4();
107 fn USIC1_5();
108 fn LEDTS0_0();
109 fn FCE0_0();
110 fn GPDMA0_0();
111 fn USB0_0();
112 fn ETH0_0();
113}
114#[doc(hidden)]
115#[repr(C)]
116pub union Vector {
117 _handler: unsafe extern "C" fn(),
118 _reserved: u32,
119}
120#[cfg(feature = "rt")]
121#[doc(hidden)]
122#[link_section = ".vector_table.interrupts"]
123#[no_mangle]
124pub static __INTERRUPTS: [Vector; 109] = [
125 Vector { _handler: SCU_0 },
126 Vector { _handler: ERU0_0 },
127 Vector { _handler: ERU0_1 },
128 Vector { _handler: ERU0_2 },
129 Vector { _handler: ERU0_3 },
130 Vector { _handler: ERU1_0 },
131 Vector { _handler: ERU1_1 },
132 Vector { _handler: ERU1_2 },
133 Vector { _handler: ERU1_3 },
134 Vector { _reserved: 0 },
135 Vector { _reserved: 0 },
136 Vector { _reserved: 0 },
137 Vector { _handler: PMU0_0 },
138 Vector { _reserved: 0 },
139 Vector { _handler: VADC0_C0_0 },
140 Vector { _handler: VADC0_C0_1 },
141 Vector { _handler: VADC0_C0_2 },
142 Vector { _handler: VADC0_C0_3 },
143 Vector { _handler: VADC0_G0_0 },
144 Vector { _handler: VADC0_G0_1 },
145 Vector { _handler: VADC0_G0_2 },
146 Vector { _handler: VADC0_G0_3 },
147 Vector { _handler: VADC0_G1_0 },
148 Vector { _handler: VADC0_G1_1 },
149 Vector { _handler: VADC0_G1_2 },
150 Vector { _handler: VADC0_G1_3 },
151 Vector { _handler: VADC0_G2_0 },
152 Vector { _handler: VADC0_G2_1 },
153 Vector { _handler: VADC0_G2_2 },
154 Vector { _handler: VADC0_G2_3 },
155 Vector { _handler: VADC0_G3_0 },
156 Vector { _handler: VADC0_G3_1 },
157 Vector { _handler: VADC0_G3_2 },
158 Vector { _handler: VADC0_G3_3 },
159 Vector { _handler: DSD0_M_0 },
160 Vector { _handler: DSD0_M_1 },
161 Vector { _handler: DSD0_M_2 },
162 Vector { _handler: DSD0_M_3 },
163 Vector { _handler: DSD0_A_4 },
164 Vector { _handler: DSD0_A_5 },
165 Vector { _handler: DSD0_A_6 },
166 Vector { _handler: DSD0_A_7 },
167 Vector { _handler: DAC0_0 },
168 Vector { _handler: DAC0_1 },
169 Vector { _handler: CCU40_0 },
170 Vector { _handler: CCU40_1 },
171 Vector { _handler: CCU40_2 },
172 Vector { _handler: CCU40_3 },
173 Vector { _handler: CCU41_0 },
174 Vector { _handler: CCU41_1 },
175 Vector { _handler: CCU41_2 },
176 Vector { _handler: CCU41_3 },
177 Vector { _handler: CCU42_0 },
178 Vector { _handler: CCU42_1 },
179 Vector { _handler: CCU42_2 },
180 Vector { _handler: CCU42_3 },
181 Vector { _handler: CCU43_0 },
182 Vector { _handler: CCU43_1 },
183 Vector { _handler: CCU43_2 },
184 Vector { _handler: CCU43_3 },
185 Vector { _handler: CCU80_0 },
186 Vector { _handler: CCU80_1 },
187 Vector { _handler: CCU80_2 },
188 Vector { _handler: CCU80_3 },
189 Vector { _handler: CCU81_0 },
190 Vector { _handler: CCU81_1 },
191 Vector { _handler: CCU81_2 },
192 Vector { _handler: CCU81_3 },
193 Vector { _handler: POSIF0_0 },
194 Vector { _handler: POSIF0_1 },
195 Vector { _handler: POSIF1_0 },
196 Vector { _handler: POSIF1_1 },
197 Vector { _handler: HRPWM_0 },
198 Vector { _handler: HRPWM_1 },
199 Vector { _handler: HRPWM_2 },
200 Vector { _handler: HRPWM_3 },
201 Vector { _handler: CAN0_0 },
202 Vector { _handler: CAN0_1 },
203 Vector { _handler: CAN0_2 },
204 Vector { _handler: CAN0_3 },
205 Vector { _handler: CAN0_4 },
206 Vector { _handler: CAN0_5 },
207 Vector { _handler: CAN0_6 },
208 Vector { _handler: CAN0_7 },
209 Vector { _handler: USIC0_0 },
210 Vector { _handler: USIC0_1 },
211 Vector { _handler: USIC0_2 },
212 Vector { _handler: USIC0_3 },
213 Vector { _handler: USIC0_4 },
214 Vector { _handler: USIC0_5 },
215 Vector { _handler: USIC1_0 },
216 Vector { _handler: USIC1_1 },
217 Vector { _handler: USIC1_2 },
218 Vector { _handler: USIC1_3 },
219 Vector { _handler: USIC1_4 },
220 Vector { _handler: USIC1_5 },
221 Vector { _reserved: 0 },
222 Vector { _reserved: 0 },
223 Vector { _reserved: 0 },
224 Vector { _reserved: 0 },
225 Vector { _reserved: 0 },
226 Vector { _reserved: 0 },
227 Vector { _handler: LEDTS0_0 },
228 Vector { _reserved: 0 },
229 Vector { _handler: FCE0_0 },
230 Vector { _handler: GPDMA0_0 },
231 Vector { _reserved: 0 },
232 Vector { _handler: USB0_0 },
233 Vector { _handler: ETH0_0 },
234];
235#[doc = r"Enumeration of all the interrupts."]
236#[derive(Copy, Clone, Debug, PartialEq, Eq)]
237#[repr(u16)]
238pub enum Interrupt {
239 #[doc = "0 - System Control"]
240 SCU_0 = 0,
241 #[doc = "1 - External Request Unit 0"]
242 ERU0_0 = 1,
243 #[doc = "2 - External Request Unit 0"]
244 ERU0_1 = 2,
245 #[doc = "3 - External Request Unit 0"]
246 ERU0_2 = 3,
247 #[doc = "4 - External Request Unit 0"]
248 ERU0_3 = 4,
249 #[doc = "5 - External Request Unit 1"]
250 ERU1_0 = 5,
251 #[doc = "6 - External Request Unit 1"]
252 ERU1_1 = 6,
253 #[doc = "7 - External Request Unit 1"]
254 ERU1_2 = 7,
255 #[doc = "8 - External Request Unit 1"]
256 ERU1_3 = 8,
257 #[doc = "12 - Program Management Unit"]
258 PMU0_0 = 12,
259 #[doc = "14 - Analog to Digital Converter Common Block 0"]
260 VADC0_C0_0 = 14,
261 #[doc = "15 - Analog to Digital Converter Common Block 0"]
262 VADC0_C0_1 = 15,
263 #[doc = "16 - Analog to Digital Converter Common Block 0"]
264 VADC0_C0_2 = 16,
265 #[doc = "17 - Analog to Digital Converter Common Block 0"]
266 VADC0_C0_3 = 17,
267 #[doc = "18 - Analog to Digital Converter Group 0"]
268 VADC0_G0_0 = 18,
269 #[doc = "19 - Analog to Digital Converter Group 0"]
270 VADC0_G0_1 = 19,
271 #[doc = "20 - Analog to Digital Converter Group 0"]
272 VADC0_G0_2 = 20,
273 #[doc = "21 - Analog to Digital Converter Group 0"]
274 VADC0_G0_3 = 21,
275 #[doc = "22 - Analog to Digital Converter Group 1"]
276 VADC0_G1_0 = 22,
277 #[doc = "23 - Analog to Digital Converter Group 1"]
278 VADC0_G1_1 = 23,
279 #[doc = "24 - Analog to Digital Converter Group 1"]
280 VADC0_G1_2 = 24,
281 #[doc = "25 - Analog to Digital Converter Group 1"]
282 VADC0_G1_3 = 25,
283 #[doc = "26 - Analog to Digital Converter Group 2"]
284 VADC0_G2_0 = 26,
285 #[doc = "27 - Analog to Digital Converter Group 2"]
286 VADC0_G2_1 = 27,
287 #[doc = "28 - Analog to Digital Converter Group 2"]
288 VADC0_G2_2 = 28,
289 #[doc = "29 - Analog to Digital Converter Group 2"]
290 VADC0_G2_3 = 29,
291 #[doc = "30 - Analog to Digital Converter Group 3"]
292 VADC0_G3_0 = 30,
293 #[doc = "31 - Analog to Digital Converter Group 3"]
294 VADC0_G3_1 = 31,
295 #[doc = "32 - Analog to Digital Converter Group 3"]
296 VADC0_G3_2 = 32,
297 #[doc = "33 - Analog to Digital Converter Group 3"]
298 VADC0_G3_3 = 33,
299 #[doc = "34 - Delta Sigma Demodulator Main"]
300 DSD0_M_0 = 34,
301 #[doc = "35 - Delta Sigma Demodulator Main"]
302 DSD0_M_1 = 35,
303 #[doc = "36 - Delta Sigma Demodulator Main"]
304 DSD0_M_2 = 36,
305 #[doc = "37 - Delta Sigma Demodulator Main"]
306 DSD0_M_3 = 37,
307 #[doc = "38 - Delta Sigma Demodulator Auxiliary"]
308 DSD0_A_4 = 38,
309 #[doc = "39 - Delta Sigma Demodulator Auxiliary"]
310 DSD0_A_5 = 39,
311 #[doc = "40 - Delta Sigma Demodulator Auxiliary"]
312 DSD0_A_6 = 40,
313 #[doc = "41 - Delta Sigma Demodulator Auxiliary"]
314 DSD0_A_7 = 41,
315 #[doc = "42 - Digital to Analog Converter"]
316 DAC0_0 = 42,
317 #[doc = "43 - Digital to Analog Converter"]
318 DAC0_1 = 43,
319 #[doc = "44 - Capture Compare Unit 4 (Module 0)"]
320 CCU40_0 = 44,
321 #[doc = "45 - Capture Compare Unit 4 (Module 0)"]
322 CCU40_1 = 45,
323 #[doc = "46 - Capture Compare Unit 4 (Module 0)"]
324 CCU40_2 = 46,
325 #[doc = "47 - Capture Compare Unit 4 (Module 0)"]
326 CCU40_3 = 47,
327 #[doc = "48 - Capture Compare Unit 4 (Module 1)"]
328 CCU41_0 = 48,
329 #[doc = "49 - Capture Compare Unit 4 (Module 1)"]
330 CCU41_1 = 49,
331 #[doc = "50 - Capture Compare Unit 4 (Module 1)"]
332 CCU41_2 = 50,
333 #[doc = "51 - Capture Compare Unit 4 (Module 1)"]
334 CCU41_3 = 51,
335 #[doc = "52 - Capture Compare Unit 4 (Module 2)"]
336 CCU42_0 = 52,
337 #[doc = "53 - Capture Compare Unit 4 (Module 2)"]
338 CCU42_1 = 53,
339 #[doc = "54 - Capture Compare Unit 4 (Module 2)"]
340 CCU42_2 = 54,
341 #[doc = "55 - Capture Compare Unit 4 (Module 2)"]
342 CCU42_3 = 55,
343 #[doc = "56 - Capture Compare Unit 4 (Module 3)"]
344 CCU43_0 = 56,
345 #[doc = "57 - Capture Compare Unit 4 (Module 3)"]
346 CCU43_1 = 57,
347 #[doc = "58 - Capture Compare Unit 4 (Module 3)"]
348 CCU43_2 = 58,
349 #[doc = "59 - Capture Compare Unit 4 (Module 3)"]
350 CCU43_3 = 59,
351 #[doc = "60 - Capture Compare Unit 8 (Module 0)"]
352 CCU80_0 = 60,
353 #[doc = "61 - Capture Compare Unit 8 (Module 0)"]
354 CCU80_1 = 61,
355 #[doc = "62 - Capture Compare Unit 8 (Module 0)"]
356 CCU80_2 = 62,
357 #[doc = "63 - Capture Compare Unit 8 (Module 0)"]
358 CCU80_3 = 63,
359 #[doc = "64 - Capture Compare Unit 8 (Module 1)"]
360 CCU81_0 = 64,
361 #[doc = "65 - Capture Compare Unit 8 (Module 1)"]
362 CCU81_1 = 65,
363 #[doc = "66 - Capture Compare Unit 8 (Module 1)"]
364 CCU81_2 = 66,
365 #[doc = "67 - Capture Compare Unit 8 (Module 1)"]
366 CCU81_3 = 67,
367 #[doc = "68 - Position Interface (Module 0)"]
368 POSIF0_0 = 68,
369 #[doc = "69 - Position Interface (Module 0)"]
370 POSIF0_1 = 69,
371 #[doc = "70 - Position Interface (Module 1)"]
372 POSIF1_0 = 70,
373 #[doc = "71 - Position Interface (Module 1)"]
374 POSIF1_1 = 71,
375 #[doc = "72 - High Resolution Pulse Width Modulation (Module 0)"]
376 HRPWM_0 = 72,
377 #[doc = "73 - High Resolution Pulse Width Modulation (Module 0)"]
378 HRPWM_1 = 73,
379 #[doc = "74 - High Resolution Pulse Width Modulation (Module 0)"]
380 HRPWM_2 = 74,
381 #[doc = "75 - High Resolution Pulse Width Modulation (Module 0)"]
382 HRPWM_3 = 75,
383 #[doc = "76 - MultiCAN"]
384 CAN0_0 = 76,
385 #[doc = "77 - MultiCAN"]
386 CAN0_1 = 77,
387 #[doc = "78 - MultiCAN"]
388 CAN0_2 = 78,
389 #[doc = "79 - MultiCAN"]
390 CAN0_3 = 79,
391 #[doc = "80 - MultiCAN"]
392 CAN0_4 = 80,
393 #[doc = "81 - MultiCAN"]
394 CAN0_5 = 81,
395 #[doc = "82 - MultiCAN"]
396 CAN0_6 = 82,
397 #[doc = "83 - MultiCAN"]
398 CAN0_7 = 83,
399 #[doc = "84 - Universal Serial Interface Channel (Module 0)"]
400 USIC0_0 = 84,
401 #[doc = "85 - Universal Serial Interface Channel (Module 0)"]
402 USIC0_1 = 85,
403 #[doc = "86 - Universal Serial Interface Channel (Module 0)"]
404 USIC0_2 = 86,
405 #[doc = "87 - Universal Serial Interface Channel (Module 0)"]
406 USIC0_3 = 87,
407 #[doc = "88 - Universal Serial Interface Channel (Module 0)"]
408 USIC0_4 = 88,
409 #[doc = "89 - Universal Serial Interface Channel (Module 0)"]
410 USIC0_5 = 89,
411 #[doc = "90 - Universal Serial Interface Channel (Module 1)"]
412 USIC1_0 = 90,
413 #[doc = "91 - Universal Serial Interface Channel (Module 1)"]
414 USIC1_1 = 91,
415 #[doc = "92 - Universal Serial Interface Channel (Module 1)"]
416 USIC1_2 = 92,
417 #[doc = "93 - Universal Serial Interface Channel (Module 1)"]
418 USIC1_3 = 93,
419 #[doc = "94 - Universal Serial Interface Channel (Module 1)"]
420 USIC1_4 = 94,
421 #[doc = "95 - Universal Serial Interface Channel (Module 1)"]
422 USIC1_5 = 95,
423 #[doc = "102 - LED and Touch Sense Control Unit (Module 0)"]
424 LEDTS0_0 = 102,
425 #[doc = "104 - Flexible CRC Engine"]
426 FCE0_0 = 104,
427 #[doc = "105 - General Purpose DMA Unit 0"]
428 GPDMA0_0 = 105,
429 #[doc = "107 - Universal Serial Bus (Module 0)"]
430 USB0_0 = 107,
431 #[doc = "108 - Ethernet (Module 0)"]
432 ETH0_0 = 108,
433}
434unsafe impl cortex_m::interrupt::InterruptNumber for Interrupt {
435 #[inline(always)]
436 fn number(self) -> u16 {
437 self as u16
438 }
439}
440#[doc = "Cortex-M4 Private Peripheral Block"]
441pub struct PPB {
442 _marker: PhantomData<*const ()>,
443}
444unsafe impl Send for PPB {}
445impl PPB {
446 #[doc = r"Pointer to the register block"]
447 pub const PTR: *const ppb::RegisterBlock = 0xe000_e000 as *const _;
448 #[doc = r"Return the pointer to the register block"]
449 #[inline(always)]
450 pub const fn ptr() -> *const ppb::RegisterBlock {
451 Self::PTR
452 }
453 #[doc = r" Steal an instance of this peripheral"]
454 #[doc = r""]
455 #[doc = r" # Safety"]
456 #[doc = r""]
457 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
458 #[doc = r" that may race with any existing instances, for example by only"]
459 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
460 #[doc = r" original peripheral and using critical sections to coordinate"]
461 #[doc = r" access between multiple new instances."]
462 #[doc = r""]
463 #[doc = r" Additionally, other software such as HALs may rely on only one"]
464 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
465 #[doc = r" no stolen instances are passed to such software."]
466 pub unsafe fn steal() -> Self {
467 Self { _marker: PhantomData }
468 }
469}
470impl Deref for PPB {
471 type Target = ppb::RegisterBlock;
472 #[inline(always)]
473 fn deref(&self) -> &Self::Target {
474 unsafe { &*Self::PTR }
475 }
476}
477impl core::fmt::Debug for PPB {
478 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
479 f.debug_struct("PPB").finish()
480 }
481}
482#[doc = "Cortex-M4 Private Peripheral Block"]
483pub mod ppb;
484#[doc = "DMA Line Router"]
485pub struct DLR {
486 _marker: PhantomData<*const ()>,
487}
488unsafe impl Send for DLR {}
489impl DLR {
490 #[doc = r"Pointer to the register block"]
491 pub const PTR: *const dlr::RegisterBlock = 0x5000_4900 as *const _;
492 #[doc = r"Return the pointer to the register block"]
493 #[inline(always)]
494 pub const fn ptr() -> *const dlr::RegisterBlock {
495 Self::PTR
496 }
497 #[doc = r" Steal an instance of this peripheral"]
498 #[doc = r""]
499 #[doc = r" # Safety"]
500 #[doc = r""]
501 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
502 #[doc = r" that may race with any existing instances, for example by only"]
503 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
504 #[doc = r" original peripheral and using critical sections to coordinate"]
505 #[doc = r" access between multiple new instances."]
506 #[doc = r""]
507 #[doc = r" Additionally, other software such as HALs may rely on only one"]
508 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
509 #[doc = r" no stolen instances are passed to such software."]
510 pub unsafe fn steal() -> Self {
511 Self { _marker: PhantomData }
512 }
513}
514impl Deref for DLR {
515 type Target = dlr::RegisterBlock;
516 #[inline(always)]
517 fn deref(&self) -> &Self::Target {
518 unsafe { &*Self::PTR }
519 }
520}
521impl core::fmt::Debug for DLR {
522 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
523 f.debug_struct("DLR").finish()
524 }
525}
526#[doc = "DMA Line Router"]
527pub mod dlr;
528#[doc = "Event Request Unit 0"]
529pub struct ERU0 {
530 _marker: PhantomData<*const ()>,
531}
532unsafe impl Send for ERU0 {}
533impl ERU0 {
534 #[doc = r"Pointer to the register block"]
535 pub const PTR: *const eru0::RegisterBlock = 0x5000_4800 as *const _;
536 #[doc = r"Return the pointer to the register block"]
537 #[inline(always)]
538 pub const fn ptr() -> *const eru0::RegisterBlock {
539 Self::PTR
540 }
541 #[doc = r" Steal an instance of this peripheral"]
542 #[doc = r""]
543 #[doc = r" # Safety"]
544 #[doc = r""]
545 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
546 #[doc = r" that may race with any existing instances, for example by only"]
547 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
548 #[doc = r" original peripheral and using critical sections to coordinate"]
549 #[doc = r" access between multiple new instances."]
550 #[doc = r""]
551 #[doc = r" Additionally, other software such as HALs may rely on only one"]
552 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
553 #[doc = r" no stolen instances are passed to such software."]
554 pub unsafe fn steal() -> Self {
555 Self { _marker: PhantomData }
556 }
557}
558impl Deref for ERU0 {
559 type Target = eru0::RegisterBlock;
560 #[inline(always)]
561 fn deref(&self) -> &Self::Target {
562 unsafe { &*Self::PTR }
563 }
564}
565impl core::fmt::Debug for ERU0 {
566 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
567 f.debug_struct("ERU0").finish()
568 }
569}
570#[doc = "Event Request Unit 0"]
571pub mod eru0;
572#[doc = "Event Request Unit 1"]
573pub struct ERU1 {
574 _marker: PhantomData<*const ()>,
575}
576unsafe impl Send for ERU1 {}
577impl ERU1 {
578 #[doc = r"Pointer to the register block"]
579 pub const PTR: *const eru0::RegisterBlock = 0x4004_4000 as *const _;
580 #[doc = r"Return the pointer to the register block"]
581 #[inline(always)]
582 pub const fn ptr() -> *const eru0::RegisterBlock {
583 Self::PTR
584 }
585 #[doc = r" Steal an instance of this peripheral"]
586 #[doc = r""]
587 #[doc = r" # Safety"]
588 #[doc = r""]
589 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
590 #[doc = r" that may race with any existing instances, for example by only"]
591 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
592 #[doc = r" original peripheral and using critical sections to coordinate"]
593 #[doc = r" access between multiple new instances."]
594 #[doc = r""]
595 #[doc = r" Additionally, other software such as HALs may rely on only one"]
596 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
597 #[doc = r" no stolen instances are passed to such software."]
598 pub unsafe fn steal() -> Self {
599 Self { _marker: PhantomData }
600 }
601}
602impl Deref for ERU1 {
603 type Target = eru0::RegisterBlock;
604 #[inline(always)]
605 fn deref(&self) -> &Self::Target {
606 unsafe { &*Self::PTR }
607 }
608}
609impl core::fmt::Debug for ERU1 {
610 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
611 f.debug_struct("ERU1").finish()
612 }
613}
614#[doc = "Event Request Unit 1"]
615pub use self::eru0 as eru1;
616#[doc = "General Purpose DMA Unit 0"]
617pub struct GPDMA0 {
618 _marker: PhantomData<*const ()>,
619}
620unsafe impl Send for GPDMA0 {}
621impl GPDMA0 {
622 #[doc = r"Pointer to the register block"]
623 pub const PTR: *const gpdma0::RegisterBlock = 0x5001_42c0 as *const _;
624 #[doc = r"Return the pointer to the register block"]
625 #[inline(always)]
626 pub const fn ptr() -> *const gpdma0::RegisterBlock {
627 Self::PTR
628 }
629 #[doc = r" Steal an instance of this peripheral"]
630 #[doc = r""]
631 #[doc = r" # Safety"]
632 #[doc = r""]
633 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
634 #[doc = r" that may race with any existing instances, for example by only"]
635 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
636 #[doc = r" original peripheral and using critical sections to coordinate"]
637 #[doc = r" access between multiple new instances."]
638 #[doc = r""]
639 #[doc = r" Additionally, other software such as HALs may rely on only one"]
640 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
641 #[doc = r" no stolen instances are passed to such software."]
642 pub unsafe fn steal() -> Self {
643 Self { _marker: PhantomData }
644 }
645}
646impl Deref for GPDMA0 {
647 type Target = gpdma0::RegisterBlock;
648 #[inline(always)]
649 fn deref(&self) -> &Self::Target {
650 unsafe { &*Self::PTR }
651 }
652}
653impl core::fmt::Debug for GPDMA0 {
654 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
655 f.debug_struct("GPDMA0").finish()
656 }
657}
658#[doc = "General Purpose DMA Unit 0"]
659pub mod gpdma0;
660#[doc = "General Purpose DMA Unit 0"]
661pub struct GPDMA0_CH0 {
662 _marker: PhantomData<*const ()>,
663}
664unsafe impl Send for GPDMA0_CH0 {}
665impl GPDMA0_CH0 {
666 #[doc = r"Pointer to the register block"]
667 pub const PTR: *const gpdma0_ch0::RegisterBlock = 0x5001_4000 as *const _;
668 #[doc = r"Return the pointer to the register block"]
669 #[inline(always)]
670 pub const fn ptr() -> *const gpdma0_ch0::RegisterBlock {
671 Self::PTR
672 }
673 #[doc = r" Steal an instance of this peripheral"]
674 #[doc = r""]
675 #[doc = r" # Safety"]
676 #[doc = r""]
677 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
678 #[doc = r" that may race with any existing instances, for example by only"]
679 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
680 #[doc = r" original peripheral and using critical sections to coordinate"]
681 #[doc = r" access between multiple new instances."]
682 #[doc = r""]
683 #[doc = r" Additionally, other software such as HALs may rely on only one"]
684 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
685 #[doc = r" no stolen instances are passed to such software."]
686 pub unsafe fn steal() -> Self {
687 Self { _marker: PhantomData }
688 }
689}
690impl Deref for GPDMA0_CH0 {
691 type Target = gpdma0_ch0::RegisterBlock;
692 #[inline(always)]
693 fn deref(&self) -> &Self::Target {
694 unsafe { &*Self::PTR }
695 }
696}
697impl core::fmt::Debug for GPDMA0_CH0 {
698 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
699 f.debug_struct("GPDMA0_CH0").finish()
700 }
701}
702#[doc = "General Purpose DMA Unit 0"]
703pub mod gpdma0_ch0;
704#[doc = "General Purpose DMA Unit 0"]
705pub struct GPDMA0_CH1 {
706 _marker: PhantomData<*const ()>,
707}
708unsafe impl Send for GPDMA0_CH1 {}
709impl GPDMA0_CH1 {
710 #[doc = r"Pointer to the register block"]
711 pub const PTR: *const gpdma0_ch0::RegisterBlock = 0x5001_4058 as *const _;
712 #[doc = r"Return the pointer to the register block"]
713 #[inline(always)]
714 pub const fn ptr() -> *const gpdma0_ch0::RegisterBlock {
715 Self::PTR
716 }
717 #[doc = r" Steal an instance of this peripheral"]
718 #[doc = r""]
719 #[doc = r" # Safety"]
720 #[doc = r""]
721 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
722 #[doc = r" that may race with any existing instances, for example by only"]
723 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
724 #[doc = r" original peripheral and using critical sections to coordinate"]
725 #[doc = r" access between multiple new instances."]
726 #[doc = r""]
727 #[doc = r" Additionally, other software such as HALs may rely on only one"]
728 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
729 #[doc = r" no stolen instances are passed to such software."]
730 pub unsafe fn steal() -> Self {
731 Self { _marker: PhantomData }
732 }
733}
734impl Deref for GPDMA0_CH1 {
735 type Target = gpdma0_ch0::RegisterBlock;
736 #[inline(always)]
737 fn deref(&self) -> &Self::Target {
738 unsafe { &*Self::PTR }
739 }
740}
741impl core::fmt::Debug for GPDMA0_CH1 {
742 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
743 f.debug_struct("GPDMA0_CH1").finish()
744 }
745}
746#[doc = "General Purpose DMA Unit 0"]
747pub use self::gpdma0_ch0 as gpdma0_ch1;
748#[doc = "General Purpose DMA Unit 0"]
749pub struct GPDMA0_CH2 {
750 _marker: PhantomData<*const ()>,
751}
752unsafe impl Send for GPDMA0_CH2 {}
753impl GPDMA0_CH2 {
754 #[doc = r"Pointer to the register block"]
755 pub const PTR: *const gpdma0_ch2::RegisterBlock = 0x5001_40b0 as *const _;
756 #[doc = r"Return the pointer to the register block"]
757 #[inline(always)]
758 pub const fn ptr() -> *const gpdma0_ch2::RegisterBlock {
759 Self::PTR
760 }
761 #[doc = r" Steal an instance of this peripheral"]
762 #[doc = r""]
763 #[doc = r" # Safety"]
764 #[doc = r""]
765 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
766 #[doc = r" that may race with any existing instances, for example by only"]
767 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
768 #[doc = r" original peripheral and using critical sections to coordinate"]
769 #[doc = r" access between multiple new instances."]
770 #[doc = r""]
771 #[doc = r" Additionally, other software such as HALs may rely on only one"]
772 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
773 #[doc = r" no stolen instances are passed to such software."]
774 pub unsafe fn steal() -> Self {
775 Self { _marker: PhantomData }
776 }
777}
778impl Deref for GPDMA0_CH2 {
779 type Target = gpdma0_ch2::RegisterBlock;
780 #[inline(always)]
781 fn deref(&self) -> &Self::Target {
782 unsafe { &*Self::PTR }
783 }
784}
785impl core::fmt::Debug for GPDMA0_CH2 {
786 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
787 f.debug_struct("GPDMA0_CH2").finish()
788 }
789}
790#[doc = "General Purpose DMA Unit 0"]
791pub mod gpdma0_ch2;
792#[doc = "General Purpose DMA Unit 0"]
793pub struct GPDMA0_CH3 {
794 _marker: PhantomData<*const ()>,
795}
796unsafe impl Send for GPDMA0_CH3 {}
797impl GPDMA0_CH3 {
798 #[doc = r"Pointer to the register block"]
799 pub const PTR: *const gpdma0_ch2::RegisterBlock = 0x5001_4108 as *const _;
800 #[doc = r"Return the pointer to the register block"]
801 #[inline(always)]
802 pub const fn ptr() -> *const gpdma0_ch2::RegisterBlock {
803 Self::PTR
804 }
805 #[doc = r" Steal an instance of this peripheral"]
806 #[doc = r""]
807 #[doc = r" # Safety"]
808 #[doc = r""]
809 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
810 #[doc = r" that may race with any existing instances, for example by only"]
811 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
812 #[doc = r" original peripheral and using critical sections to coordinate"]
813 #[doc = r" access between multiple new instances."]
814 #[doc = r""]
815 #[doc = r" Additionally, other software such as HALs may rely on only one"]
816 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
817 #[doc = r" no stolen instances are passed to such software."]
818 pub unsafe fn steal() -> Self {
819 Self { _marker: PhantomData }
820 }
821}
822impl Deref for GPDMA0_CH3 {
823 type Target = gpdma0_ch2::RegisterBlock;
824 #[inline(always)]
825 fn deref(&self) -> &Self::Target {
826 unsafe { &*Self::PTR }
827 }
828}
829impl core::fmt::Debug for GPDMA0_CH3 {
830 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
831 f.debug_struct("GPDMA0_CH3").finish()
832 }
833}
834#[doc = "General Purpose DMA Unit 0"]
835pub use self::gpdma0_ch2 as gpdma0_ch3;
836#[doc = "General Purpose DMA Unit 0"]
837pub struct GPDMA0_CH4 {
838 _marker: PhantomData<*const ()>,
839}
840unsafe impl Send for GPDMA0_CH4 {}
841impl GPDMA0_CH4 {
842 #[doc = r"Pointer to the register block"]
843 pub const PTR: *const gpdma0_ch2::RegisterBlock = 0x5001_4160 as *const _;
844 #[doc = r"Return the pointer to the register block"]
845 #[inline(always)]
846 pub const fn ptr() -> *const gpdma0_ch2::RegisterBlock {
847 Self::PTR
848 }
849 #[doc = r" Steal an instance of this peripheral"]
850 #[doc = r""]
851 #[doc = r" # Safety"]
852 #[doc = r""]
853 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
854 #[doc = r" that may race with any existing instances, for example by only"]
855 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
856 #[doc = r" original peripheral and using critical sections to coordinate"]
857 #[doc = r" access between multiple new instances."]
858 #[doc = r""]
859 #[doc = r" Additionally, other software such as HALs may rely on only one"]
860 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
861 #[doc = r" no stolen instances are passed to such software."]
862 pub unsafe fn steal() -> Self {
863 Self { _marker: PhantomData }
864 }
865}
866impl Deref for GPDMA0_CH4 {
867 type Target = gpdma0_ch2::RegisterBlock;
868 #[inline(always)]
869 fn deref(&self) -> &Self::Target {
870 unsafe { &*Self::PTR }
871 }
872}
873impl core::fmt::Debug for GPDMA0_CH4 {
874 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
875 f.debug_struct("GPDMA0_CH4").finish()
876 }
877}
878#[doc = "General Purpose DMA Unit 0"]
879pub use self::gpdma0_ch2 as gpdma0_ch4;
880#[doc = "General Purpose DMA Unit 0"]
881pub struct GPDMA0_CH5 {
882 _marker: PhantomData<*const ()>,
883}
884unsafe impl Send for GPDMA0_CH5 {}
885impl GPDMA0_CH5 {
886 #[doc = r"Pointer to the register block"]
887 pub const PTR: *const gpdma0_ch2::RegisterBlock = 0x5001_41b8 as *const _;
888 #[doc = r"Return the pointer to the register block"]
889 #[inline(always)]
890 pub const fn ptr() -> *const gpdma0_ch2::RegisterBlock {
891 Self::PTR
892 }
893 #[doc = r" Steal an instance of this peripheral"]
894 #[doc = r""]
895 #[doc = r" # Safety"]
896 #[doc = r""]
897 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
898 #[doc = r" that may race with any existing instances, for example by only"]
899 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
900 #[doc = r" original peripheral and using critical sections to coordinate"]
901 #[doc = r" access between multiple new instances."]
902 #[doc = r""]
903 #[doc = r" Additionally, other software such as HALs may rely on only one"]
904 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
905 #[doc = r" no stolen instances are passed to such software."]
906 pub unsafe fn steal() -> Self {
907 Self { _marker: PhantomData }
908 }
909}
910impl Deref for GPDMA0_CH5 {
911 type Target = gpdma0_ch2::RegisterBlock;
912 #[inline(always)]
913 fn deref(&self) -> &Self::Target {
914 unsafe { &*Self::PTR }
915 }
916}
917impl core::fmt::Debug for GPDMA0_CH5 {
918 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
919 f.debug_struct("GPDMA0_CH5").finish()
920 }
921}
922#[doc = "General Purpose DMA Unit 0"]
923pub use self::gpdma0_ch2 as gpdma0_ch5;
924#[doc = "General Purpose DMA Unit 0"]
925pub struct GPDMA0_CH6 {
926 _marker: PhantomData<*const ()>,
927}
928unsafe impl Send for GPDMA0_CH6 {}
929impl GPDMA0_CH6 {
930 #[doc = r"Pointer to the register block"]
931 pub const PTR: *const gpdma0_ch2::RegisterBlock = 0x5001_4210 as *const _;
932 #[doc = r"Return the pointer to the register block"]
933 #[inline(always)]
934 pub const fn ptr() -> *const gpdma0_ch2::RegisterBlock {
935 Self::PTR
936 }
937 #[doc = r" Steal an instance of this peripheral"]
938 #[doc = r""]
939 #[doc = r" # Safety"]
940 #[doc = r""]
941 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
942 #[doc = r" that may race with any existing instances, for example by only"]
943 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
944 #[doc = r" original peripheral and using critical sections to coordinate"]
945 #[doc = r" access between multiple new instances."]
946 #[doc = r""]
947 #[doc = r" Additionally, other software such as HALs may rely on only one"]
948 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
949 #[doc = r" no stolen instances are passed to such software."]
950 pub unsafe fn steal() -> Self {
951 Self { _marker: PhantomData }
952 }
953}
954impl Deref for GPDMA0_CH6 {
955 type Target = gpdma0_ch2::RegisterBlock;
956 #[inline(always)]
957 fn deref(&self) -> &Self::Target {
958 unsafe { &*Self::PTR }
959 }
960}
961impl core::fmt::Debug for GPDMA0_CH6 {
962 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
963 f.debug_struct("GPDMA0_CH6").finish()
964 }
965}
966#[doc = "General Purpose DMA Unit 0"]
967pub use self::gpdma0_ch2 as gpdma0_ch6;
968#[doc = "General Purpose DMA Unit 0"]
969pub struct GPDMA0_CH7 {
970 _marker: PhantomData<*const ()>,
971}
972unsafe impl Send for GPDMA0_CH7 {}
973impl GPDMA0_CH7 {
974 #[doc = r"Pointer to the register block"]
975 pub const PTR: *const gpdma0_ch2::RegisterBlock = 0x5001_4268 as *const _;
976 #[doc = r"Return the pointer to the register block"]
977 #[inline(always)]
978 pub const fn ptr() -> *const gpdma0_ch2::RegisterBlock {
979 Self::PTR
980 }
981 #[doc = r" Steal an instance of this peripheral"]
982 #[doc = r""]
983 #[doc = r" # Safety"]
984 #[doc = r""]
985 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
986 #[doc = r" that may race with any existing instances, for example by only"]
987 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
988 #[doc = r" original peripheral and using critical sections to coordinate"]
989 #[doc = r" access between multiple new instances."]
990 #[doc = r""]
991 #[doc = r" Additionally, other software such as HALs may rely on only one"]
992 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
993 #[doc = r" no stolen instances are passed to such software."]
994 pub unsafe fn steal() -> Self {
995 Self { _marker: PhantomData }
996 }
997}
998impl Deref for GPDMA0_CH7 {
999 type Target = gpdma0_ch2::RegisterBlock;
1000 #[inline(always)]
1001 fn deref(&self) -> &Self::Target {
1002 unsafe { &*Self::PTR }
1003 }
1004}
1005impl core::fmt::Debug for GPDMA0_CH7 {
1006 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1007 f.debug_struct("GPDMA0_CH7").finish()
1008 }
1009}
1010#[doc = "General Purpose DMA Unit 0"]
1011pub use self::gpdma0_ch2 as gpdma0_ch7;
1012#[doc = "Flexible CRC Engine"]
1013pub struct FCE {
1014 _marker: PhantomData<*const ()>,
1015}
1016unsafe impl Send for FCE {}
1017impl FCE {
1018 #[doc = r"Pointer to the register block"]
1019 pub const PTR: *const fce::RegisterBlock = 0x5002_0000 as *const _;
1020 #[doc = r"Return the pointer to the register block"]
1021 #[inline(always)]
1022 pub const fn ptr() -> *const fce::RegisterBlock {
1023 Self::PTR
1024 }
1025 #[doc = r" Steal an instance of this peripheral"]
1026 #[doc = r""]
1027 #[doc = r" # Safety"]
1028 #[doc = r""]
1029 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1030 #[doc = r" that may race with any existing instances, for example by only"]
1031 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1032 #[doc = r" original peripheral and using critical sections to coordinate"]
1033 #[doc = r" access between multiple new instances."]
1034 #[doc = r""]
1035 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1036 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1037 #[doc = r" no stolen instances are passed to such software."]
1038 pub unsafe fn steal() -> Self {
1039 Self { _marker: PhantomData }
1040 }
1041}
1042impl Deref for FCE {
1043 type Target = fce::RegisterBlock;
1044 #[inline(always)]
1045 fn deref(&self) -> &Self::Target {
1046 unsafe { &*Self::PTR }
1047 }
1048}
1049impl core::fmt::Debug for FCE {
1050 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1051 f.debug_struct("FCE").finish()
1052 }
1053}
1054#[doc = "Flexible CRC Engine"]
1055pub mod fce;
1056#[doc = "Flexible CRC Engine"]
1057pub struct FCE_KE0 {
1058 _marker: PhantomData<*const ()>,
1059}
1060unsafe impl Send for FCE_KE0 {}
1061impl FCE_KE0 {
1062 #[doc = r"Pointer to the register block"]
1063 pub const PTR: *const fce_ke0::RegisterBlock = 0x5002_0020 as *const _;
1064 #[doc = r"Return the pointer to the register block"]
1065 #[inline(always)]
1066 pub const fn ptr() -> *const fce_ke0::RegisterBlock {
1067 Self::PTR
1068 }
1069 #[doc = r" Steal an instance of this peripheral"]
1070 #[doc = r""]
1071 #[doc = r" # Safety"]
1072 #[doc = r""]
1073 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1074 #[doc = r" that may race with any existing instances, for example by only"]
1075 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1076 #[doc = r" original peripheral and using critical sections to coordinate"]
1077 #[doc = r" access between multiple new instances."]
1078 #[doc = r""]
1079 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1080 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1081 #[doc = r" no stolen instances are passed to such software."]
1082 pub unsafe fn steal() -> Self {
1083 Self { _marker: PhantomData }
1084 }
1085}
1086impl Deref for FCE_KE0 {
1087 type Target = fce_ke0::RegisterBlock;
1088 #[inline(always)]
1089 fn deref(&self) -> &Self::Target {
1090 unsafe { &*Self::PTR }
1091 }
1092}
1093impl core::fmt::Debug for FCE_KE0 {
1094 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1095 f.debug_struct("FCE_KE0").finish()
1096 }
1097}
1098#[doc = "Flexible CRC Engine"]
1099pub mod fce_ke0;
1100#[doc = "Flexible CRC Engine"]
1101pub struct FCE_KE1 {
1102 _marker: PhantomData<*const ()>,
1103}
1104unsafe impl Send for FCE_KE1 {}
1105impl FCE_KE1 {
1106 #[doc = r"Pointer to the register block"]
1107 pub const PTR: *const fce_ke0::RegisterBlock = 0x5002_0040 as *const _;
1108 #[doc = r"Return the pointer to the register block"]
1109 #[inline(always)]
1110 pub const fn ptr() -> *const fce_ke0::RegisterBlock {
1111 Self::PTR
1112 }
1113 #[doc = r" Steal an instance of this peripheral"]
1114 #[doc = r""]
1115 #[doc = r" # Safety"]
1116 #[doc = r""]
1117 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1118 #[doc = r" that may race with any existing instances, for example by only"]
1119 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1120 #[doc = r" original peripheral and using critical sections to coordinate"]
1121 #[doc = r" access between multiple new instances."]
1122 #[doc = r""]
1123 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1124 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1125 #[doc = r" no stolen instances are passed to such software."]
1126 pub unsafe fn steal() -> Self {
1127 Self { _marker: PhantomData }
1128 }
1129}
1130impl Deref for FCE_KE1 {
1131 type Target = fce_ke0::RegisterBlock;
1132 #[inline(always)]
1133 fn deref(&self) -> &Self::Target {
1134 unsafe { &*Self::PTR }
1135 }
1136}
1137impl core::fmt::Debug for FCE_KE1 {
1138 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1139 f.debug_struct("FCE_KE1").finish()
1140 }
1141}
1142#[doc = "Flexible CRC Engine"]
1143pub use self::fce_ke0 as fce_ke1;
1144#[doc = "Flexible CRC Engine"]
1145pub struct FCE_KE2 {
1146 _marker: PhantomData<*const ()>,
1147}
1148unsafe impl Send for FCE_KE2 {}
1149impl FCE_KE2 {
1150 #[doc = r"Pointer to the register block"]
1151 pub const PTR: *const fce_ke0::RegisterBlock = 0x5002_0060 as *const _;
1152 #[doc = r"Return the pointer to the register block"]
1153 #[inline(always)]
1154 pub const fn ptr() -> *const fce_ke0::RegisterBlock {
1155 Self::PTR
1156 }
1157 #[doc = r" Steal an instance of this peripheral"]
1158 #[doc = r""]
1159 #[doc = r" # Safety"]
1160 #[doc = r""]
1161 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1162 #[doc = r" that may race with any existing instances, for example by only"]
1163 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1164 #[doc = r" original peripheral and using critical sections to coordinate"]
1165 #[doc = r" access between multiple new instances."]
1166 #[doc = r""]
1167 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1168 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1169 #[doc = r" no stolen instances are passed to such software."]
1170 pub unsafe fn steal() -> Self {
1171 Self { _marker: PhantomData }
1172 }
1173}
1174impl Deref for FCE_KE2 {
1175 type Target = fce_ke0::RegisterBlock;
1176 #[inline(always)]
1177 fn deref(&self) -> &Self::Target {
1178 unsafe { &*Self::PTR }
1179 }
1180}
1181impl core::fmt::Debug for FCE_KE2 {
1182 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1183 f.debug_struct("FCE_KE2").finish()
1184 }
1185}
1186#[doc = "Flexible CRC Engine"]
1187pub use self::fce_ke0 as fce_ke2;
1188#[doc = "Flexible CRC Engine"]
1189pub struct FCE_KE3 {
1190 _marker: PhantomData<*const ()>,
1191}
1192unsafe impl Send for FCE_KE3 {}
1193impl FCE_KE3 {
1194 #[doc = r"Pointer to the register block"]
1195 pub const PTR: *const fce_ke0::RegisterBlock = 0x5002_0080 as *const _;
1196 #[doc = r"Return the pointer to the register block"]
1197 #[inline(always)]
1198 pub const fn ptr() -> *const fce_ke0::RegisterBlock {
1199 Self::PTR
1200 }
1201 #[doc = r" Steal an instance of this peripheral"]
1202 #[doc = r""]
1203 #[doc = r" # Safety"]
1204 #[doc = r""]
1205 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1206 #[doc = r" that may race with any existing instances, for example by only"]
1207 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1208 #[doc = r" original peripheral and using critical sections to coordinate"]
1209 #[doc = r" access between multiple new instances."]
1210 #[doc = r""]
1211 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1212 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1213 #[doc = r" no stolen instances are passed to such software."]
1214 pub unsafe fn steal() -> Self {
1215 Self { _marker: PhantomData }
1216 }
1217}
1218impl Deref for FCE_KE3 {
1219 type Target = fce_ke0::RegisterBlock;
1220 #[inline(always)]
1221 fn deref(&self) -> &Self::Target {
1222 unsafe { &*Self::PTR }
1223 }
1224}
1225impl core::fmt::Debug for FCE_KE3 {
1226 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1227 f.debug_struct("FCE_KE3").finish()
1228 }
1229}
1230#[doc = "Flexible CRC Engine"]
1231pub use self::fce_ke0 as fce_ke3;
1232#[doc = "Peripheral Bridge AHB 0"]
1233pub struct PBA0 {
1234 _marker: PhantomData<*const ()>,
1235}
1236unsafe impl Send for PBA0 {}
1237impl PBA0 {
1238 #[doc = r"Pointer to the register block"]
1239 pub const PTR: *const pba0::RegisterBlock = 0x4000_0000 as *const _;
1240 #[doc = r"Return the pointer to the register block"]
1241 #[inline(always)]
1242 pub const fn ptr() -> *const pba0::RegisterBlock {
1243 Self::PTR
1244 }
1245 #[doc = r" Steal an instance of this peripheral"]
1246 #[doc = r""]
1247 #[doc = r" # Safety"]
1248 #[doc = r""]
1249 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1250 #[doc = r" that may race with any existing instances, for example by only"]
1251 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1252 #[doc = r" original peripheral and using critical sections to coordinate"]
1253 #[doc = r" access between multiple new instances."]
1254 #[doc = r""]
1255 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1256 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1257 #[doc = r" no stolen instances are passed to such software."]
1258 pub unsafe fn steal() -> Self {
1259 Self { _marker: PhantomData }
1260 }
1261}
1262impl Deref for PBA0 {
1263 type Target = pba0::RegisterBlock;
1264 #[inline(always)]
1265 fn deref(&self) -> &Self::Target {
1266 unsafe { &*Self::PTR }
1267 }
1268}
1269impl core::fmt::Debug for PBA0 {
1270 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1271 f.debug_struct("PBA0").finish()
1272 }
1273}
1274#[doc = "Peripheral Bridge AHB 0"]
1275pub mod pba0;
1276#[doc = "Peripheral Bridge AHB 1"]
1277pub struct PBA1 {
1278 _marker: PhantomData<*const ()>,
1279}
1280unsafe impl Send for PBA1 {}
1281impl PBA1 {
1282 #[doc = r"Pointer to the register block"]
1283 pub const PTR: *const pba0::RegisterBlock = 0x4800_0000 as *const _;
1284 #[doc = r"Return the pointer to the register block"]
1285 #[inline(always)]
1286 pub const fn ptr() -> *const pba0::RegisterBlock {
1287 Self::PTR
1288 }
1289 #[doc = r" Steal an instance of this peripheral"]
1290 #[doc = r""]
1291 #[doc = r" # Safety"]
1292 #[doc = r""]
1293 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1294 #[doc = r" that may race with any existing instances, for example by only"]
1295 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1296 #[doc = r" original peripheral and using critical sections to coordinate"]
1297 #[doc = r" access between multiple new instances."]
1298 #[doc = r""]
1299 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1300 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1301 #[doc = r" no stolen instances are passed to such software."]
1302 pub unsafe fn steal() -> Self {
1303 Self { _marker: PhantomData }
1304 }
1305}
1306impl Deref for PBA1 {
1307 type Target = pba0::RegisterBlock;
1308 #[inline(always)]
1309 fn deref(&self) -> &Self::Target {
1310 unsafe { &*Self::PTR }
1311 }
1312}
1313impl core::fmt::Debug for PBA1 {
1314 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1315 f.debug_struct("PBA1").finish()
1316 }
1317}
1318#[doc = "Peripheral Bridge AHB 1"]
1319pub use self::pba0 as pba1;
1320#[doc = "Flash Memory Controller"]
1321pub struct FLASH0 {
1322 _marker: PhantomData<*const ()>,
1323}
1324unsafe impl Send for FLASH0 {}
1325impl FLASH0 {
1326 #[doc = r"Pointer to the register block"]
1327 pub const PTR: *const flash0::RegisterBlock = 0x5800_1000 as *const _;
1328 #[doc = r"Return the pointer to the register block"]
1329 #[inline(always)]
1330 pub const fn ptr() -> *const flash0::RegisterBlock {
1331 Self::PTR
1332 }
1333 #[doc = r" Steal an instance of this peripheral"]
1334 #[doc = r""]
1335 #[doc = r" # Safety"]
1336 #[doc = r""]
1337 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1338 #[doc = r" that may race with any existing instances, for example by only"]
1339 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1340 #[doc = r" original peripheral and using critical sections to coordinate"]
1341 #[doc = r" access between multiple new instances."]
1342 #[doc = r""]
1343 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1344 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1345 #[doc = r" no stolen instances are passed to such software."]
1346 pub unsafe fn steal() -> Self {
1347 Self { _marker: PhantomData }
1348 }
1349}
1350impl Deref for FLASH0 {
1351 type Target = flash0::RegisterBlock;
1352 #[inline(always)]
1353 fn deref(&self) -> &Self::Target {
1354 unsafe { &*Self::PTR }
1355 }
1356}
1357impl core::fmt::Debug for FLASH0 {
1358 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1359 f.debug_struct("FLASH0").finish()
1360 }
1361}
1362#[doc = "Flash Memory Controller"]
1363pub mod flash0;
1364#[doc = "Prefetch Unit"]
1365pub struct PREF {
1366 _marker: PhantomData<*const ()>,
1367}
1368unsafe impl Send for PREF {}
1369impl PREF {
1370 #[doc = r"Pointer to the register block"]
1371 pub const PTR: *const pref::RegisterBlock = 0x5800_4000 as *const _;
1372 #[doc = r"Return the pointer to the register block"]
1373 #[inline(always)]
1374 pub const fn ptr() -> *const pref::RegisterBlock {
1375 Self::PTR
1376 }
1377 #[doc = r" Steal an instance of this peripheral"]
1378 #[doc = r""]
1379 #[doc = r" # Safety"]
1380 #[doc = r""]
1381 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1382 #[doc = r" that may race with any existing instances, for example by only"]
1383 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1384 #[doc = r" original peripheral and using critical sections to coordinate"]
1385 #[doc = r" access between multiple new instances."]
1386 #[doc = r""]
1387 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1388 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1389 #[doc = r" no stolen instances are passed to such software."]
1390 pub unsafe fn steal() -> Self {
1391 Self { _marker: PhantomData }
1392 }
1393}
1394impl Deref for PREF {
1395 type Target = pref::RegisterBlock;
1396 #[inline(always)]
1397 fn deref(&self) -> &Self::Target {
1398 unsafe { &*Self::PTR }
1399 }
1400}
1401impl core::fmt::Debug for PREF {
1402 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1403 f.debug_struct("PREF").finish()
1404 }
1405}
1406#[doc = "Prefetch Unit"]
1407pub mod pref;
1408#[doc = "Program Management Unit"]
1409pub struct PMU0 {
1410 _marker: PhantomData<*const ()>,
1411}
1412unsafe impl Send for PMU0 {}
1413impl PMU0 {
1414 #[doc = r"Pointer to the register block"]
1415 pub const PTR: *const pmu0::RegisterBlock = 0x5800_0508 as *const _;
1416 #[doc = r"Return the pointer to the register block"]
1417 #[inline(always)]
1418 pub const fn ptr() -> *const pmu0::RegisterBlock {
1419 Self::PTR
1420 }
1421 #[doc = r" Steal an instance of this peripheral"]
1422 #[doc = r""]
1423 #[doc = r" # Safety"]
1424 #[doc = r""]
1425 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1426 #[doc = r" that may race with any existing instances, for example by only"]
1427 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1428 #[doc = r" original peripheral and using critical sections to coordinate"]
1429 #[doc = r" access between multiple new instances."]
1430 #[doc = r""]
1431 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1432 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1433 #[doc = r" no stolen instances are passed to such software."]
1434 pub unsafe fn steal() -> Self {
1435 Self { _marker: PhantomData }
1436 }
1437}
1438impl Deref for PMU0 {
1439 type Target = pmu0::RegisterBlock;
1440 #[inline(always)]
1441 fn deref(&self) -> &Self::Target {
1442 unsafe { &*Self::PTR }
1443 }
1444}
1445impl core::fmt::Debug for PMU0 {
1446 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1447 f.debug_struct("PMU0").finish()
1448 }
1449}
1450#[doc = "Program Management Unit"]
1451pub mod pmu0;
1452#[doc = "Watch Dog Timer"]
1453pub struct WDT {
1454 _marker: PhantomData<*const ()>,
1455}
1456unsafe impl Send for WDT {}
1457impl WDT {
1458 #[doc = r"Pointer to the register block"]
1459 pub const PTR: *const wdt::RegisterBlock = 0x5000_8000 as *const _;
1460 #[doc = r"Return the pointer to the register block"]
1461 #[inline(always)]
1462 pub const fn ptr() -> *const wdt::RegisterBlock {
1463 Self::PTR
1464 }
1465 #[doc = r" Steal an instance of this peripheral"]
1466 #[doc = r""]
1467 #[doc = r" # Safety"]
1468 #[doc = r""]
1469 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1470 #[doc = r" that may race with any existing instances, for example by only"]
1471 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1472 #[doc = r" original peripheral and using critical sections to coordinate"]
1473 #[doc = r" access between multiple new instances."]
1474 #[doc = r""]
1475 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1476 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1477 #[doc = r" no stolen instances are passed to such software."]
1478 pub unsafe fn steal() -> Self {
1479 Self { _marker: PhantomData }
1480 }
1481}
1482impl Deref for WDT {
1483 type Target = wdt::RegisterBlock;
1484 #[inline(always)]
1485 fn deref(&self) -> &Self::Target {
1486 unsafe { &*Self::PTR }
1487 }
1488}
1489impl core::fmt::Debug for WDT {
1490 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1491 f.debug_struct("WDT").finish()
1492 }
1493}
1494#[doc = "Watch Dog Timer"]
1495pub mod wdt;
1496#[doc = "Real Time Clock"]
1497pub struct RTC {
1498 _marker: PhantomData<*const ()>,
1499}
1500unsafe impl Send for RTC {}
1501impl RTC {
1502 #[doc = r"Pointer to the register block"]
1503 pub const PTR: *const rtc::RegisterBlock = 0x5000_4a00 as *const _;
1504 #[doc = r"Return the pointer to the register block"]
1505 #[inline(always)]
1506 pub const fn ptr() -> *const rtc::RegisterBlock {
1507 Self::PTR
1508 }
1509 #[doc = r" Steal an instance of this peripheral"]
1510 #[doc = r""]
1511 #[doc = r" # Safety"]
1512 #[doc = r""]
1513 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1514 #[doc = r" that may race with any existing instances, for example by only"]
1515 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1516 #[doc = r" original peripheral and using critical sections to coordinate"]
1517 #[doc = r" access between multiple new instances."]
1518 #[doc = r""]
1519 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1520 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1521 #[doc = r" no stolen instances are passed to such software."]
1522 pub unsafe fn steal() -> Self {
1523 Self { _marker: PhantomData }
1524 }
1525}
1526impl Deref for RTC {
1527 type Target = rtc::RegisterBlock;
1528 #[inline(always)]
1529 fn deref(&self) -> &Self::Target {
1530 unsafe { &*Self::PTR }
1531 }
1532}
1533impl core::fmt::Debug for RTC {
1534 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1535 f.debug_struct("RTC").finish()
1536 }
1537}
1538#[doc = "Real Time Clock"]
1539pub mod rtc;
1540#[doc = "System Control Unit"]
1541pub struct SCU_CLK {
1542 _marker: PhantomData<*const ()>,
1543}
1544unsafe impl Send for SCU_CLK {}
1545impl SCU_CLK {
1546 #[doc = r"Pointer to the register block"]
1547 pub const PTR: *const scu_clk::RegisterBlock = 0x5000_4600 as *const _;
1548 #[doc = r"Return the pointer to the register block"]
1549 #[inline(always)]
1550 pub const fn ptr() -> *const scu_clk::RegisterBlock {
1551 Self::PTR
1552 }
1553 #[doc = r" Steal an instance of this peripheral"]
1554 #[doc = r""]
1555 #[doc = r" # Safety"]
1556 #[doc = r""]
1557 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1558 #[doc = r" that may race with any existing instances, for example by only"]
1559 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1560 #[doc = r" original peripheral and using critical sections to coordinate"]
1561 #[doc = r" access between multiple new instances."]
1562 #[doc = r""]
1563 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1564 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1565 #[doc = r" no stolen instances are passed to such software."]
1566 pub unsafe fn steal() -> Self {
1567 Self { _marker: PhantomData }
1568 }
1569}
1570impl Deref for SCU_CLK {
1571 type Target = scu_clk::RegisterBlock;
1572 #[inline(always)]
1573 fn deref(&self) -> &Self::Target {
1574 unsafe { &*Self::PTR }
1575 }
1576}
1577impl core::fmt::Debug for SCU_CLK {
1578 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1579 f.debug_struct("SCU_CLK").finish()
1580 }
1581}
1582#[doc = "System Control Unit"]
1583pub mod scu_clk;
1584#[doc = "System Control Unit"]
1585pub struct SCU_OSC {
1586 _marker: PhantomData<*const ()>,
1587}
1588unsafe impl Send for SCU_OSC {}
1589impl SCU_OSC {
1590 #[doc = r"Pointer to the register block"]
1591 pub const PTR: *const scu_osc::RegisterBlock = 0x5000_4700 as *const _;
1592 #[doc = r"Return the pointer to the register block"]
1593 #[inline(always)]
1594 pub const fn ptr() -> *const scu_osc::RegisterBlock {
1595 Self::PTR
1596 }
1597 #[doc = r" Steal an instance of this peripheral"]
1598 #[doc = r""]
1599 #[doc = r" # Safety"]
1600 #[doc = r""]
1601 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1602 #[doc = r" that may race with any existing instances, for example by only"]
1603 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1604 #[doc = r" original peripheral and using critical sections to coordinate"]
1605 #[doc = r" access between multiple new instances."]
1606 #[doc = r""]
1607 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1608 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1609 #[doc = r" no stolen instances are passed to such software."]
1610 pub unsafe fn steal() -> Self {
1611 Self { _marker: PhantomData }
1612 }
1613}
1614impl Deref for SCU_OSC {
1615 type Target = scu_osc::RegisterBlock;
1616 #[inline(always)]
1617 fn deref(&self) -> &Self::Target {
1618 unsafe { &*Self::PTR }
1619 }
1620}
1621impl core::fmt::Debug for SCU_OSC {
1622 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1623 f.debug_struct("SCU_OSC").finish()
1624 }
1625}
1626#[doc = "System Control Unit"]
1627pub mod scu_osc;
1628#[doc = "System Control Unit"]
1629pub struct SCU_PLL {
1630 _marker: PhantomData<*const ()>,
1631}
1632unsafe impl Send for SCU_PLL {}
1633impl SCU_PLL {
1634 #[doc = r"Pointer to the register block"]
1635 pub const PTR: *const scu_pll::RegisterBlock = 0x5000_4710 as *const _;
1636 #[doc = r"Return the pointer to the register block"]
1637 #[inline(always)]
1638 pub const fn ptr() -> *const scu_pll::RegisterBlock {
1639 Self::PTR
1640 }
1641 #[doc = r" Steal an instance of this peripheral"]
1642 #[doc = r""]
1643 #[doc = r" # Safety"]
1644 #[doc = r""]
1645 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1646 #[doc = r" that may race with any existing instances, for example by only"]
1647 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1648 #[doc = r" original peripheral and using critical sections to coordinate"]
1649 #[doc = r" access between multiple new instances."]
1650 #[doc = r""]
1651 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1652 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1653 #[doc = r" no stolen instances are passed to such software."]
1654 pub unsafe fn steal() -> Self {
1655 Self { _marker: PhantomData }
1656 }
1657}
1658impl Deref for SCU_PLL {
1659 type Target = scu_pll::RegisterBlock;
1660 #[inline(always)]
1661 fn deref(&self) -> &Self::Target {
1662 unsafe { &*Self::PTR }
1663 }
1664}
1665impl core::fmt::Debug for SCU_PLL {
1666 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1667 f.debug_struct("SCU_PLL").finish()
1668 }
1669}
1670#[doc = "System Control Unit"]
1671pub mod scu_pll;
1672#[doc = "System Control Unit"]
1673pub struct SCU_GENERAL {
1674 _marker: PhantomData<*const ()>,
1675}
1676unsafe impl Send for SCU_GENERAL {}
1677impl SCU_GENERAL {
1678 #[doc = r"Pointer to the register block"]
1679 pub const PTR: *const scu_general::RegisterBlock = 0x5000_4000 as *const _;
1680 #[doc = r"Return the pointer to the register block"]
1681 #[inline(always)]
1682 pub const fn ptr() -> *const scu_general::RegisterBlock {
1683 Self::PTR
1684 }
1685 #[doc = r" Steal an instance of this peripheral"]
1686 #[doc = r""]
1687 #[doc = r" # Safety"]
1688 #[doc = r""]
1689 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1690 #[doc = r" that may race with any existing instances, for example by only"]
1691 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1692 #[doc = r" original peripheral and using critical sections to coordinate"]
1693 #[doc = r" access between multiple new instances."]
1694 #[doc = r""]
1695 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1696 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1697 #[doc = r" no stolen instances are passed to such software."]
1698 pub unsafe fn steal() -> Self {
1699 Self { _marker: PhantomData }
1700 }
1701}
1702impl Deref for SCU_GENERAL {
1703 type Target = scu_general::RegisterBlock;
1704 #[inline(always)]
1705 fn deref(&self) -> &Self::Target {
1706 unsafe { &*Self::PTR }
1707 }
1708}
1709impl core::fmt::Debug for SCU_GENERAL {
1710 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1711 f.debug_struct("SCU_GENERAL").finish()
1712 }
1713}
1714#[doc = "System Control Unit"]
1715pub mod scu_general;
1716#[doc = "System Control Unit"]
1717pub struct SCU_INTERRUPT {
1718 _marker: PhantomData<*const ()>,
1719}
1720unsafe impl Send for SCU_INTERRUPT {}
1721impl SCU_INTERRUPT {
1722 #[doc = r"Pointer to the register block"]
1723 pub const PTR: *const scu_interrupt::RegisterBlock = 0x5000_4074 as *const _;
1724 #[doc = r"Return the pointer to the register block"]
1725 #[inline(always)]
1726 pub const fn ptr() -> *const scu_interrupt::RegisterBlock {
1727 Self::PTR
1728 }
1729 #[doc = r" Steal an instance of this peripheral"]
1730 #[doc = r""]
1731 #[doc = r" # Safety"]
1732 #[doc = r""]
1733 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1734 #[doc = r" that may race with any existing instances, for example by only"]
1735 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1736 #[doc = r" original peripheral and using critical sections to coordinate"]
1737 #[doc = r" access between multiple new instances."]
1738 #[doc = r""]
1739 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1740 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1741 #[doc = r" no stolen instances are passed to such software."]
1742 pub unsafe fn steal() -> Self {
1743 Self { _marker: PhantomData }
1744 }
1745}
1746impl Deref for SCU_INTERRUPT {
1747 type Target = scu_interrupt::RegisterBlock;
1748 #[inline(always)]
1749 fn deref(&self) -> &Self::Target {
1750 unsafe { &*Self::PTR }
1751 }
1752}
1753impl core::fmt::Debug for SCU_INTERRUPT {
1754 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1755 f.debug_struct("SCU_INTERRUPT").finish()
1756 }
1757}
1758#[doc = "System Control Unit"]
1759pub mod scu_interrupt;
1760#[doc = "System Control Unit"]
1761pub struct SCU_PARITY {
1762 _marker: PhantomData<*const ()>,
1763}
1764unsafe impl Send for SCU_PARITY {}
1765impl SCU_PARITY {
1766 #[doc = r"Pointer to the register block"]
1767 pub const PTR: *const scu_parity::RegisterBlock = 0x5000_413c as *const _;
1768 #[doc = r"Return the pointer to the register block"]
1769 #[inline(always)]
1770 pub const fn ptr() -> *const scu_parity::RegisterBlock {
1771 Self::PTR
1772 }
1773 #[doc = r" Steal an instance of this peripheral"]
1774 #[doc = r""]
1775 #[doc = r" # Safety"]
1776 #[doc = r""]
1777 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1778 #[doc = r" that may race with any existing instances, for example by only"]
1779 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1780 #[doc = r" original peripheral and using critical sections to coordinate"]
1781 #[doc = r" access between multiple new instances."]
1782 #[doc = r""]
1783 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1784 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1785 #[doc = r" no stolen instances are passed to such software."]
1786 pub unsafe fn steal() -> Self {
1787 Self { _marker: PhantomData }
1788 }
1789}
1790impl Deref for SCU_PARITY {
1791 type Target = scu_parity::RegisterBlock;
1792 #[inline(always)]
1793 fn deref(&self) -> &Self::Target {
1794 unsafe { &*Self::PTR }
1795 }
1796}
1797impl core::fmt::Debug for SCU_PARITY {
1798 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1799 f.debug_struct("SCU_PARITY").finish()
1800 }
1801}
1802#[doc = "System Control Unit"]
1803pub mod scu_parity;
1804#[doc = "System Control Unit"]
1805pub struct SCU_TRAP {
1806 _marker: PhantomData<*const ()>,
1807}
1808unsafe impl Send for SCU_TRAP {}
1809impl SCU_TRAP {
1810 #[doc = r"Pointer to the register block"]
1811 pub const PTR: *const scu_trap::RegisterBlock = 0x5000_4160 as *const _;
1812 #[doc = r"Return the pointer to the register block"]
1813 #[inline(always)]
1814 pub const fn ptr() -> *const scu_trap::RegisterBlock {
1815 Self::PTR
1816 }
1817 #[doc = r" Steal an instance of this peripheral"]
1818 #[doc = r""]
1819 #[doc = r" # Safety"]
1820 #[doc = r""]
1821 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1822 #[doc = r" that may race with any existing instances, for example by only"]
1823 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1824 #[doc = r" original peripheral and using critical sections to coordinate"]
1825 #[doc = r" access between multiple new instances."]
1826 #[doc = r""]
1827 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1828 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1829 #[doc = r" no stolen instances are passed to such software."]
1830 pub unsafe fn steal() -> Self {
1831 Self { _marker: PhantomData }
1832 }
1833}
1834impl Deref for SCU_TRAP {
1835 type Target = scu_trap::RegisterBlock;
1836 #[inline(always)]
1837 fn deref(&self) -> &Self::Target {
1838 unsafe { &*Self::PTR }
1839 }
1840}
1841impl core::fmt::Debug for SCU_TRAP {
1842 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1843 f.debug_struct("SCU_TRAP").finish()
1844 }
1845}
1846#[doc = "System Control Unit"]
1847pub mod scu_trap;
1848#[doc = "System Control Unit"]
1849pub struct SCU_HIBERNATE {
1850 _marker: PhantomData<*const ()>,
1851}
1852unsafe impl Send for SCU_HIBERNATE {}
1853impl SCU_HIBERNATE {
1854 #[doc = r"Pointer to the register block"]
1855 pub const PTR: *const scu_hibernate::RegisterBlock = 0x5000_4300 as *const _;
1856 #[doc = r"Return the pointer to the register block"]
1857 #[inline(always)]
1858 pub const fn ptr() -> *const scu_hibernate::RegisterBlock {
1859 Self::PTR
1860 }
1861 #[doc = r" Steal an instance of this peripheral"]
1862 #[doc = r""]
1863 #[doc = r" # Safety"]
1864 #[doc = r""]
1865 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1866 #[doc = r" that may race with any existing instances, for example by only"]
1867 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1868 #[doc = r" original peripheral and using critical sections to coordinate"]
1869 #[doc = r" access between multiple new instances."]
1870 #[doc = r""]
1871 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1872 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1873 #[doc = r" no stolen instances are passed to such software."]
1874 pub unsafe fn steal() -> Self {
1875 Self { _marker: PhantomData }
1876 }
1877}
1878impl Deref for SCU_HIBERNATE {
1879 type Target = scu_hibernate::RegisterBlock;
1880 #[inline(always)]
1881 fn deref(&self) -> &Self::Target {
1882 unsafe { &*Self::PTR }
1883 }
1884}
1885impl core::fmt::Debug for SCU_HIBERNATE {
1886 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1887 f.debug_struct("SCU_HIBERNATE").finish()
1888 }
1889}
1890#[doc = "System Control Unit"]
1891pub mod scu_hibernate;
1892#[doc = "System Control Unit"]
1893pub struct SCU_POWER {
1894 _marker: PhantomData<*const ()>,
1895}
1896unsafe impl Send for SCU_POWER {}
1897impl SCU_POWER {
1898 #[doc = r"Pointer to the register block"]
1899 pub const PTR: *const scu_power::RegisterBlock = 0x5000_4200 as *const _;
1900 #[doc = r"Return the pointer to the register block"]
1901 #[inline(always)]
1902 pub const fn ptr() -> *const scu_power::RegisterBlock {
1903 Self::PTR
1904 }
1905 #[doc = r" Steal an instance of this peripheral"]
1906 #[doc = r""]
1907 #[doc = r" # Safety"]
1908 #[doc = r""]
1909 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1910 #[doc = r" that may race with any existing instances, for example by only"]
1911 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1912 #[doc = r" original peripheral and using critical sections to coordinate"]
1913 #[doc = r" access between multiple new instances."]
1914 #[doc = r""]
1915 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1916 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1917 #[doc = r" no stolen instances are passed to such software."]
1918 pub unsafe fn steal() -> Self {
1919 Self { _marker: PhantomData }
1920 }
1921}
1922impl Deref for SCU_POWER {
1923 type Target = scu_power::RegisterBlock;
1924 #[inline(always)]
1925 fn deref(&self) -> &Self::Target {
1926 unsafe { &*Self::PTR }
1927 }
1928}
1929impl core::fmt::Debug for SCU_POWER {
1930 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1931 f.debug_struct("SCU_POWER").finish()
1932 }
1933}
1934#[doc = "System Control Unit"]
1935pub mod scu_power;
1936#[doc = "System Control Unit"]
1937pub struct SCU_RESET {
1938 _marker: PhantomData<*const ()>,
1939}
1940unsafe impl Send for SCU_RESET {}
1941impl SCU_RESET {
1942 #[doc = r"Pointer to the register block"]
1943 pub const PTR: *const scu_reset::RegisterBlock = 0x5000_4400 as *const _;
1944 #[doc = r"Return the pointer to the register block"]
1945 #[inline(always)]
1946 pub const fn ptr() -> *const scu_reset::RegisterBlock {
1947 Self::PTR
1948 }
1949 #[doc = r" Steal an instance of this peripheral"]
1950 #[doc = r""]
1951 #[doc = r" # Safety"]
1952 #[doc = r""]
1953 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1954 #[doc = r" that may race with any existing instances, for example by only"]
1955 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1956 #[doc = r" original peripheral and using critical sections to coordinate"]
1957 #[doc = r" access between multiple new instances."]
1958 #[doc = r""]
1959 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1960 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1961 #[doc = r" no stolen instances are passed to such software."]
1962 pub unsafe fn steal() -> Self {
1963 Self { _marker: PhantomData }
1964 }
1965}
1966impl Deref for SCU_RESET {
1967 type Target = scu_reset::RegisterBlock;
1968 #[inline(always)]
1969 fn deref(&self) -> &Self::Target {
1970 unsafe { &*Self::PTR }
1971 }
1972}
1973impl core::fmt::Debug for SCU_RESET {
1974 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1975 f.debug_struct("SCU_RESET").finish()
1976 }
1977}
1978#[doc = "System Control Unit"]
1979pub mod scu_reset;
1980#[doc = "LED and Touch Sense Unit 0"]
1981pub struct LEDTS0 {
1982 _marker: PhantomData<*const ()>,
1983}
1984unsafe impl Send for LEDTS0 {}
1985impl LEDTS0 {
1986 #[doc = r"Pointer to the register block"]
1987 pub const PTR: *const ledts0::RegisterBlock = 0x4801_0000 as *const _;
1988 #[doc = r"Return the pointer to the register block"]
1989 #[inline(always)]
1990 pub const fn ptr() -> *const ledts0::RegisterBlock {
1991 Self::PTR
1992 }
1993 #[doc = r" Steal an instance of this peripheral"]
1994 #[doc = r""]
1995 #[doc = r" # Safety"]
1996 #[doc = r""]
1997 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1998 #[doc = r" that may race with any existing instances, for example by only"]
1999 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2000 #[doc = r" original peripheral and using critical sections to coordinate"]
2001 #[doc = r" access between multiple new instances."]
2002 #[doc = r""]
2003 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2004 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2005 #[doc = r" no stolen instances are passed to such software."]
2006 pub unsafe fn steal() -> Self {
2007 Self { _marker: PhantomData }
2008 }
2009}
2010impl Deref for LEDTS0 {
2011 type Target = ledts0::RegisterBlock;
2012 #[inline(always)]
2013 fn deref(&self) -> &Self::Target {
2014 unsafe { &*Self::PTR }
2015 }
2016}
2017impl core::fmt::Debug for LEDTS0 {
2018 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2019 f.debug_struct("LEDTS0").finish()
2020 }
2021}
2022#[doc = "LED and Touch Sense Unit 0"]
2023pub mod ledts0;
2024#[doc = "Ethernet Control Register"]
2025pub struct ETH0_CON {
2026 _marker: PhantomData<*const ()>,
2027}
2028unsafe impl Send for ETH0_CON {}
2029impl ETH0_CON {
2030 #[doc = r"Pointer to the register block"]
2031 pub const PTR: *const eth0_con::RegisterBlock = 0x5000_4040 as *const _;
2032 #[doc = r"Return the pointer to the register block"]
2033 #[inline(always)]
2034 pub const fn ptr() -> *const eth0_con::RegisterBlock {
2035 Self::PTR
2036 }
2037 #[doc = r" Steal an instance of this peripheral"]
2038 #[doc = r""]
2039 #[doc = r" # Safety"]
2040 #[doc = r""]
2041 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2042 #[doc = r" that may race with any existing instances, for example by only"]
2043 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2044 #[doc = r" original peripheral and using critical sections to coordinate"]
2045 #[doc = r" access between multiple new instances."]
2046 #[doc = r""]
2047 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2048 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2049 #[doc = r" no stolen instances are passed to such software."]
2050 pub unsafe fn steal() -> Self {
2051 Self { _marker: PhantomData }
2052 }
2053}
2054impl Deref for ETH0_CON {
2055 type Target = eth0_con::RegisterBlock;
2056 #[inline(always)]
2057 fn deref(&self) -> &Self::Target {
2058 unsafe { &*Self::PTR }
2059 }
2060}
2061impl core::fmt::Debug for ETH0_CON {
2062 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2063 f.debug_struct("ETH0_CON").finish()
2064 }
2065}
2066#[doc = "Ethernet Control Register"]
2067pub mod eth0_con;
2068#[doc = "Ethernet Unit 0"]
2069pub struct ETH0 {
2070 _marker: PhantomData<*const ()>,
2071}
2072unsafe impl Send for ETH0 {}
2073impl ETH0 {
2074 #[doc = r"Pointer to the register block"]
2075 pub const PTR: *const eth0::RegisterBlock = 0x5000_c000 as *const _;
2076 #[doc = r"Return the pointer to the register block"]
2077 #[inline(always)]
2078 pub const fn ptr() -> *const eth0::RegisterBlock {
2079 Self::PTR
2080 }
2081 #[doc = r" Steal an instance of this peripheral"]
2082 #[doc = r""]
2083 #[doc = r" # Safety"]
2084 #[doc = r""]
2085 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2086 #[doc = r" that may race with any existing instances, for example by only"]
2087 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2088 #[doc = r" original peripheral and using critical sections to coordinate"]
2089 #[doc = r" access between multiple new instances."]
2090 #[doc = r""]
2091 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2092 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2093 #[doc = r" no stolen instances are passed to such software."]
2094 pub unsafe fn steal() -> Self {
2095 Self { _marker: PhantomData }
2096 }
2097}
2098impl Deref for ETH0 {
2099 type Target = eth0::RegisterBlock;
2100 #[inline(always)]
2101 fn deref(&self) -> &Self::Target {
2102 unsafe { &*Self::PTR }
2103 }
2104}
2105impl core::fmt::Debug for ETH0 {
2106 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2107 f.debug_struct("ETH0").finish()
2108 }
2109}
2110#[doc = "Ethernet Unit 0"]
2111pub mod eth0;
2112#[doc = "Universal Serial Bus"]
2113pub struct USB0 {
2114 _marker: PhantomData<*const ()>,
2115}
2116unsafe impl Send for USB0 {}
2117impl USB0 {
2118 #[doc = r"Pointer to the register block"]
2119 pub const PTR: *const usb0::RegisterBlock = 0x5004_0000 as *const _;
2120 #[doc = r"Return the pointer to the register block"]
2121 #[inline(always)]
2122 pub const fn ptr() -> *const usb0::RegisterBlock {
2123 Self::PTR
2124 }
2125 #[doc = r" Steal an instance of this peripheral"]
2126 #[doc = r""]
2127 #[doc = r" # Safety"]
2128 #[doc = r""]
2129 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2130 #[doc = r" that may race with any existing instances, for example by only"]
2131 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2132 #[doc = r" original peripheral and using critical sections to coordinate"]
2133 #[doc = r" access between multiple new instances."]
2134 #[doc = r""]
2135 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2136 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2137 #[doc = r" no stolen instances are passed to such software."]
2138 pub unsafe fn steal() -> Self {
2139 Self { _marker: PhantomData }
2140 }
2141}
2142impl Deref for USB0 {
2143 type Target = usb0::RegisterBlock;
2144 #[inline(always)]
2145 fn deref(&self) -> &Self::Target {
2146 unsafe { &*Self::PTR }
2147 }
2148}
2149impl core::fmt::Debug for USB0 {
2150 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2151 f.debug_struct("USB0").finish()
2152 }
2153}
2154#[doc = "Universal Serial Bus"]
2155pub mod usb0;
2156#[doc = "Universal Serial Bus"]
2157pub struct USB0_EP0 {
2158 _marker: PhantomData<*const ()>,
2159}
2160unsafe impl Send for USB0_EP0 {}
2161impl USB0_EP0 {
2162 #[doc = r"Pointer to the register block"]
2163 pub const PTR: *const usb0_ep0::RegisterBlock = 0x5004_0900 as *const _;
2164 #[doc = r"Return the pointer to the register block"]
2165 #[inline(always)]
2166 pub const fn ptr() -> *const usb0_ep0::RegisterBlock {
2167 Self::PTR
2168 }
2169 #[doc = r" Steal an instance of this peripheral"]
2170 #[doc = r""]
2171 #[doc = r" # Safety"]
2172 #[doc = r""]
2173 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2174 #[doc = r" that may race with any existing instances, for example by only"]
2175 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2176 #[doc = r" original peripheral and using critical sections to coordinate"]
2177 #[doc = r" access between multiple new instances."]
2178 #[doc = r""]
2179 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2180 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2181 #[doc = r" no stolen instances are passed to such software."]
2182 pub unsafe fn steal() -> Self {
2183 Self { _marker: PhantomData }
2184 }
2185}
2186impl Deref for USB0_EP0 {
2187 type Target = usb0_ep0::RegisterBlock;
2188 #[inline(always)]
2189 fn deref(&self) -> &Self::Target {
2190 unsafe { &*Self::PTR }
2191 }
2192}
2193impl core::fmt::Debug for USB0_EP0 {
2194 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2195 f.debug_struct("USB0_EP0").finish()
2196 }
2197}
2198#[doc = "Universal Serial Bus"]
2199pub mod usb0_ep0;
2200#[doc = "Universal Serial Bus"]
2201pub struct USB0_EP1 {
2202 _marker: PhantomData<*const ()>,
2203}
2204unsafe impl Send for USB0_EP1 {}
2205impl USB0_EP1 {
2206 #[doc = r"Pointer to the register block"]
2207 pub const PTR: *const usb0_ep1::RegisterBlock = 0x5004_0920 as *const _;
2208 #[doc = r"Return the pointer to the register block"]
2209 #[inline(always)]
2210 pub const fn ptr() -> *const usb0_ep1::RegisterBlock {
2211 Self::PTR
2212 }
2213 #[doc = r" Steal an instance of this peripheral"]
2214 #[doc = r""]
2215 #[doc = r" # Safety"]
2216 #[doc = r""]
2217 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2218 #[doc = r" that may race with any existing instances, for example by only"]
2219 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2220 #[doc = r" original peripheral and using critical sections to coordinate"]
2221 #[doc = r" access between multiple new instances."]
2222 #[doc = r""]
2223 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2224 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2225 #[doc = r" no stolen instances are passed to such software."]
2226 pub unsafe fn steal() -> Self {
2227 Self { _marker: PhantomData }
2228 }
2229}
2230impl Deref for USB0_EP1 {
2231 type Target = usb0_ep1::RegisterBlock;
2232 #[inline(always)]
2233 fn deref(&self) -> &Self::Target {
2234 unsafe { &*Self::PTR }
2235 }
2236}
2237impl core::fmt::Debug for USB0_EP1 {
2238 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2239 f.debug_struct("USB0_EP1").finish()
2240 }
2241}
2242#[doc = "Universal Serial Bus"]
2243pub mod usb0_ep1;
2244#[doc = "Universal Serial Bus"]
2245pub struct USB0_EP2 {
2246 _marker: PhantomData<*const ()>,
2247}
2248unsafe impl Send for USB0_EP2 {}
2249impl USB0_EP2 {
2250 #[doc = r"Pointer to the register block"]
2251 pub const PTR: *const usb0_ep1::RegisterBlock = 0x5004_0940 as *const _;
2252 #[doc = r"Return the pointer to the register block"]
2253 #[inline(always)]
2254 pub const fn ptr() -> *const usb0_ep1::RegisterBlock {
2255 Self::PTR
2256 }
2257 #[doc = r" Steal an instance of this peripheral"]
2258 #[doc = r""]
2259 #[doc = r" # Safety"]
2260 #[doc = r""]
2261 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2262 #[doc = r" that may race with any existing instances, for example by only"]
2263 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2264 #[doc = r" original peripheral and using critical sections to coordinate"]
2265 #[doc = r" access between multiple new instances."]
2266 #[doc = r""]
2267 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2268 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2269 #[doc = r" no stolen instances are passed to such software."]
2270 pub unsafe fn steal() -> Self {
2271 Self { _marker: PhantomData }
2272 }
2273}
2274impl Deref for USB0_EP2 {
2275 type Target = usb0_ep1::RegisterBlock;
2276 #[inline(always)]
2277 fn deref(&self) -> &Self::Target {
2278 unsafe { &*Self::PTR }
2279 }
2280}
2281impl core::fmt::Debug for USB0_EP2 {
2282 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2283 f.debug_struct("USB0_EP2").finish()
2284 }
2285}
2286#[doc = "Universal Serial Bus"]
2287pub use self::usb0_ep1 as usb0_ep2;
2288#[doc = "Universal Serial Bus"]
2289pub struct USB0_EP3 {
2290 _marker: PhantomData<*const ()>,
2291}
2292unsafe impl Send for USB0_EP3 {}
2293impl USB0_EP3 {
2294 #[doc = r"Pointer to the register block"]
2295 pub const PTR: *const usb0_ep1::RegisterBlock = 0x5004_0960 as *const _;
2296 #[doc = r"Return the pointer to the register block"]
2297 #[inline(always)]
2298 pub const fn ptr() -> *const usb0_ep1::RegisterBlock {
2299 Self::PTR
2300 }
2301 #[doc = r" Steal an instance of this peripheral"]
2302 #[doc = r""]
2303 #[doc = r" # Safety"]
2304 #[doc = r""]
2305 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2306 #[doc = r" that may race with any existing instances, for example by only"]
2307 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2308 #[doc = r" original peripheral and using critical sections to coordinate"]
2309 #[doc = r" access between multiple new instances."]
2310 #[doc = r""]
2311 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2312 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2313 #[doc = r" no stolen instances are passed to such software."]
2314 pub unsafe fn steal() -> Self {
2315 Self { _marker: PhantomData }
2316 }
2317}
2318impl Deref for USB0_EP3 {
2319 type Target = usb0_ep1::RegisterBlock;
2320 #[inline(always)]
2321 fn deref(&self) -> &Self::Target {
2322 unsafe { &*Self::PTR }
2323 }
2324}
2325impl core::fmt::Debug for USB0_EP3 {
2326 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2327 f.debug_struct("USB0_EP3").finish()
2328 }
2329}
2330#[doc = "Universal Serial Bus"]
2331pub use self::usb0_ep1 as usb0_ep3;
2332#[doc = "Universal Serial Bus"]
2333pub struct USB0_EP4 {
2334 _marker: PhantomData<*const ()>,
2335}
2336unsafe impl Send for USB0_EP4 {}
2337impl USB0_EP4 {
2338 #[doc = r"Pointer to the register block"]
2339 pub const PTR: *const usb0_ep1::RegisterBlock = 0x5004_0980 as *const _;
2340 #[doc = r"Return the pointer to the register block"]
2341 #[inline(always)]
2342 pub const fn ptr() -> *const usb0_ep1::RegisterBlock {
2343 Self::PTR
2344 }
2345 #[doc = r" Steal an instance of this peripheral"]
2346 #[doc = r""]
2347 #[doc = r" # Safety"]
2348 #[doc = r""]
2349 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2350 #[doc = r" that may race with any existing instances, for example by only"]
2351 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2352 #[doc = r" original peripheral and using critical sections to coordinate"]
2353 #[doc = r" access between multiple new instances."]
2354 #[doc = r""]
2355 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2356 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2357 #[doc = r" no stolen instances are passed to such software."]
2358 pub unsafe fn steal() -> Self {
2359 Self { _marker: PhantomData }
2360 }
2361}
2362impl Deref for USB0_EP4 {
2363 type Target = usb0_ep1::RegisterBlock;
2364 #[inline(always)]
2365 fn deref(&self) -> &Self::Target {
2366 unsafe { &*Self::PTR }
2367 }
2368}
2369impl core::fmt::Debug for USB0_EP4 {
2370 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2371 f.debug_struct("USB0_EP4").finish()
2372 }
2373}
2374#[doc = "Universal Serial Bus"]
2375pub use self::usb0_ep1 as usb0_ep4;
2376#[doc = "Universal Serial Bus"]
2377pub struct USB0_EP5 {
2378 _marker: PhantomData<*const ()>,
2379}
2380unsafe impl Send for USB0_EP5 {}
2381impl USB0_EP5 {
2382 #[doc = r"Pointer to the register block"]
2383 pub const PTR: *const usb0_ep1::RegisterBlock = 0x5004_09a0 as *const _;
2384 #[doc = r"Return the pointer to the register block"]
2385 #[inline(always)]
2386 pub const fn ptr() -> *const usb0_ep1::RegisterBlock {
2387 Self::PTR
2388 }
2389 #[doc = r" Steal an instance of this peripheral"]
2390 #[doc = r""]
2391 #[doc = r" # Safety"]
2392 #[doc = r""]
2393 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2394 #[doc = r" that may race with any existing instances, for example by only"]
2395 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2396 #[doc = r" original peripheral and using critical sections to coordinate"]
2397 #[doc = r" access between multiple new instances."]
2398 #[doc = r""]
2399 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2400 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2401 #[doc = r" no stolen instances are passed to such software."]
2402 pub unsafe fn steal() -> Self {
2403 Self { _marker: PhantomData }
2404 }
2405}
2406impl Deref for USB0_EP5 {
2407 type Target = usb0_ep1::RegisterBlock;
2408 #[inline(always)]
2409 fn deref(&self) -> &Self::Target {
2410 unsafe { &*Self::PTR }
2411 }
2412}
2413impl core::fmt::Debug for USB0_EP5 {
2414 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2415 f.debug_struct("USB0_EP5").finish()
2416 }
2417}
2418#[doc = "Universal Serial Bus"]
2419pub use self::usb0_ep1 as usb0_ep5;
2420#[doc = "Universal Serial Bus"]
2421pub struct USB0_EP6 {
2422 _marker: PhantomData<*const ()>,
2423}
2424unsafe impl Send for USB0_EP6 {}
2425impl USB0_EP6 {
2426 #[doc = r"Pointer to the register block"]
2427 pub const PTR: *const usb0_ep1::RegisterBlock = 0x5004_09c0 as *const _;
2428 #[doc = r"Return the pointer to the register block"]
2429 #[inline(always)]
2430 pub const fn ptr() -> *const usb0_ep1::RegisterBlock {
2431 Self::PTR
2432 }
2433 #[doc = r" Steal an instance of this peripheral"]
2434 #[doc = r""]
2435 #[doc = r" # Safety"]
2436 #[doc = r""]
2437 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2438 #[doc = r" that may race with any existing instances, for example by only"]
2439 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2440 #[doc = r" original peripheral and using critical sections to coordinate"]
2441 #[doc = r" access between multiple new instances."]
2442 #[doc = r""]
2443 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2444 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2445 #[doc = r" no stolen instances are passed to such software."]
2446 pub unsafe fn steal() -> Self {
2447 Self { _marker: PhantomData }
2448 }
2449}
2450impl Deref for USB0_EP6 {
2451 type Target = usb0_ep1::RegisterBlock;
2452 #[inline(always)]
2453 fn deref(&self) -> &Self::Target {
2454 unsafe { &*Self::PTR }
2455 }
2456}
2457impl core::fmt::Debug for USB0_EP6 {
2458 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2459 f.debug_struct("USB0_EP6").finish()
2460 }
2461}
2462#[doc = "Universal Serial Bus"]
2463pub use self::usb0_ep1 as usb0_ep6;
2464#[doc = "Universal Serial Bus"]
2465pub struct USB0_CH0 {
2466 _marker: PhantomData<*const ()>,
2467}
2468unsafe impl Send for USB0_CH0 {}
2469impl USB0_CH0 {
2470 #[doc = r"Pointer to the register block"]
2471 pub const PTR: *const usb0_ch0::RegisterBlock = 0x5004_0500 as *const _;
2472 #[doc = r"Return the pointer to the register block"]
2473 #[inline(always)]
2474 pub const fn ptr() -> *const usb0_ch0::RegisterBlock {
2475 Self::PTR
2476 }
2477 #[doc = r" Steal an instance of this peripheral"]
2478 #[doc = r""]
2479 #[doc = r" # Safety"]
2480 #[doc = r""]
2481 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2482 #[doc = r" that may race with any existing instances, for example by only"]
2483 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2484 #[doc = r" original peripheral and using critical sections to coordinate"]
2485 #[doc = r" access between multiple new instances."]
2486 #[doc = r""]
2487 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2488 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2489 #[doc = r" no stolen instances are passed to such software."]
2490 pub unsafe fn steal() -> Self {
2491 Self { _marker: PhantomData }
2492 }
2493}
2494impl Deref for USB0_CH0 {
2495 type Target = usb0_ch0::RegisterBlock;
2496 #[inline(always)]
2497 fn deref(&self) -> &Self::Target {
2498 unsafe { &*Self::PTR }
2499 }
2500}
2501impl core::fmt::Debug for USB0_CH0 {
2502 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2503 f.debug_struct("USB0_CH0").finish()
2504 }
2505}
2506#[doc = "Universal Serial Bus"]
2507pub mod usb0_ch0;
2508#[doc = "Universal Serial Bus"]
2509pub struct USB0_CH1 {
2510 _marker: PhantomData<*const ()>,
2511}
2512unsafe impl Send for USB0_CH1 {}
2513impl USB0_CH1 {
2514 #[doc = r"Pointer to the register block"]
2515 pub const PTR: *const usb0_ch0::RegisterBlock = 0x5004_0520 as *const _;
2516 #[doc = r"Return the pointer to the register block"]
2517 #[inline(always)]
2518 pub const fn ptr() -> *const usb0_ch0::RegisterBlock {
2519 Self::PTR
2520 }
2521 #[doc = r" Steal an instance of this peripheral"]
2522 #[doc = r""]
2523 #[doc = r" # Safety"]
2524 #[doc = r""]
2525 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2526 #[doc = r" that may race with any existing instances, for example by only"]
2527 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2528 #[doc = r" original peripheral and using critical sections to coordinate"]
2529 #[doc = r" access between multiple new instances."]
2530 #[doc = r""]
2531 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2532 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2533 #[doc = r" no stolen instances are passed to such software."]
2534 pub unsafe fn steal() -> Self {
2535 Self { _marker: PhantomData }
2536 }
2537}
2538impl Deref for USB0_CH1 {
2539 type Target = usb0_ch0::RegisterBlock;
2540 #[inline(always)]
2541 fn deref(&self) -> &Self::Target {
2542 unsafe { &*Self::PTR }
2543 }
2544}
2545impl core::fmt::Debug for USB0_CH1 {
2546 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2547 f.debug_struct("USB0_CH1").finish()
2548 }
2549}
2550#[doc = "Universal Serial Bus"]
2551pub use self::usb0_ch0 as usb0_ch1;
2552#[doc = "Universal Serial Bus"]
2553pub struct USB0_CH2 {
2554 _marker: PhantomData<*const ()>,
2555}
2556unsafe impl Send for USB0_CH2 {}
2557impl USB0_CH2 {
2558 #[doc = r"Pointer to the register block"]
2559 pub const PTR: *const usb0_ch0::RegisterBlock = 0x5004_0540 as *const _;
2560 #[doc = r"Return the pointer to the register block"]
2561 #[inline(always)]
2562 pub const fn ptr() -> *const usb0_ch0::RegisterBlock {
2563 Self::PTR
2564 }
2565 #[doc = r" Steal an instance of this peripheral"]
2566 #[doc = r""]
2567 #[doc = r" # Safety"]
2568 #[doc = r""]
2569 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2570 #[doc = r" that may race with any existing instances, for example by only"]
2571 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2572 #[doc = r" original peripheral and using critical sections to coordinate"]
2573 #[doc = r" access between multiple new instances."]
2574 #[doc = r""]
2575 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2576 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2577 #[doc = r" no stolen instances are passed to such software."]
2578 pub unsafe fn steal() -> Self {
2579 Self { _marker: PhantomData }
2580 }
2581}
2582impl Deref for USB0_CH2 {
2583 type Target = usb0_ch0::RegisterBlock;
2584 #[inline(always)]
2585 fn deref(&self) -> &Self::Target {
2586 unsafe { &*Self::PTR }
2587 }
2588}
2589impl core::fmt::Debug for USB0_CH2 {
2590 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2591 f.debug_struct("USB0_CH2").finish()
2592 }
2593}
2594#[doc = "Universal Serial Bus"]
2595pub use self::usb0_ch0 as usb0_ch2;
2596#[doc = "Universal Serial Bus"]
2597pub struct USB0_CH3 {
2598 _marker: PhantomData<*const ()>,
2599}
2600unsafe impl Send for USB0_CH3 {}
2601impl USB0_CH3 {
2602 #[doc = r"Pointer to the register block"]
2603 pub const PTR: *const usb0_ch0::RegisterBlock = 0x5004_0560 as *const _;
2604 #[doc = r"Return the pointer to the register block"]
2605 #[inline(always)]
2606 pub const fn ptr() -> *const usb0_ch0::RegisterBlock {
2607 Self::PTR
2608 }
2609 #[doc = r" Steal an instance of this peripheral"]
2610 #[doc = r""]
2611 #[doc = r" # Safety"]
2612 #[doc = r""]
2613 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2614 #[doc = r" that may race with any existing instances, for example by only"]
2615 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2616 #[doc = r" original peripheral and using critical sections to coordinate"]
2617 #[doc = r" access between multiple new instances."]
2618 #[doc = r""]
2619 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2620 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2621 #[doc = r" no stolen instances are passed to such software."]
2622 pub unsafe fn steal() -> Self {
2623 Self { _marker: PhantomData }
2624 }
2625}
2626impl Deref for USB0_CH3 {
2627 type Target = usb0_ch0::RegisterBlock;
2628 #[inline(always)]
2629 fn deref(&self) -> &Self::Target {
2630 unsafe { &*Self::PTR }
2631 }
2632}
2633impl core::fmt::Debug for USB0_CH3 {
2634 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2635 f.debug_struct("USB0_CH3").finish()
2636 }
2637}
2638#[doc = "Universal Serial Bus"]
2639pub use self::usb0_ch0 as usb0_ch3;
2640#[doc = "Universal Serial Bus"]
2641pub struct USB0_CH4 {
2642 _marker: PhantomData<*const ()>,
2643}
2644unsafe impl Send for USB0_CH4 {}
2645impl USB0_CH4 {
2646 #[doc = r"Pointer to the register block"]
2647 pub const PTR: *const usb0_ch0::RegisterBlock = 0x5004_0580 as *const _;
2648 #[doc = r"Return the pointer to the register block"]
2649 #[inline(always)]
2650 pub const fn ptr() -> *const usb0_ch0::RegisterBlock {
2651 Self::PTR
2652 }
2653 #[doc = r" Steal an instance of this peripheral"]
2654 #[doc = r""]
2655 #[doc = r" # Safety"]
2656 #[doc = r""]
2657 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2658 #[doc = r" that may race with any existing instances, for example by only"]
2659 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2660 #[doc = r" original peripheral and using critical sections to coordinate"]
2661 #[doc = r" access between multiple new instances."]
2662 #[doc = r""]
2663 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2664 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2665 #[doc = r" no stolen instances are passed to such software."]
2666 pub unsafe fn steal() -> Self {
2667 Self { _marker: PhantomData }
2668 }
2669}
2670impl Deref for USB0_CH4 {
2671 type Target = usb0_ch0::RegisterBlock;
2672 #[inline(always)]
2673 fn deref(&self) -> &Self::Target {
2674 unsafe { &*Self::PTR }
2675 }
2676}
2677impl core::fmt::Debug for USB0_CH4 {
2678 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2679 f.debug_struct("USB0_CH4").finish()
2680 }
2681}
2682#[doc = "Universal Serial Bus"]
2683pub use self::usb0_ch0 as usb0_ch4;
2684#[doc = "Universal Serial Bus"]
2685pub struct USB0_CH5 {
2686 _marker: PhantomData<*const ()>,
2687}
2688unsafe impl Send for USB0_CH5 {}
2689impl USB0_CH5 {
2690 #[doc = r"Pointer to the register block"]
2691 pub const PTR: *const usb0_ch0::RegisterBlock = 0x5004_05a0 as *const _;
2692 #[doc = r"Return the pointer to the register block"]
2693 #[inline(always)]
2694 pub const fn ptr() -> *const usb0_ch0::RegisterBlock {
2695 Self::PTR
2696 }
2697 #[doc = r" Steal an instance of this peripheral"]
2698 #[doc = r""]
2699 #[doc = r" # Safety"]
2700 #[doc = r""]
2701 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2702 #[doc = r" that may race with any existing instances, for example by only"]
2703 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2704 #[doc = r" original peripheral and using critical sections to coordinate"]
2705 #[doc = r" access between multiple new instances."]
2706 #[doc = r""]
2707 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2708 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2709 #[doc = r" no stolen instances are passed to such software."]
2710 pub unsafe fn steal() -> Self {
2711 Self { _marker: PhantomData }
2712 }
2713}
2714impl Deref for USB0_CH5 {
2715 type Target = usb0_ch0::RegisterBlock;
2716 #[inline(always)]
2717 fn deref(&self) -> &Self::Target {
2718 unsafe { &*Self::PTR }
2719 }
2720}
2721impl core::fmt::Debug for USB0_CH5 {
2722 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2723 f.debug_struct("USB0_CH5").finish()
2724 }
2725}
2726#[doc = "Universal Serial Bus"]
2727pub use self::usb0_ch0 as usb0_ch5;
2728#[doc = "Universal Serial Bus"]
2729pub struct USB0_CH6 {
2730 _marker: PhantomData<*const ()>,
2731}
2732unsafe impl Send for USB0_CH6 {}
2733impl USB0_CH6 {
2734 #[doc = r"Pointer to the register block"]
2735 pub const PTR: *const usb0_ch0::RegisterBlock = 0x5004_05c0 as *const _;
2736 #[doc = r"Return the pointer to the register block"]
2737 #[inline(always)]
2738 pub const fn ptr() -> *const usb0_ch0::RegisterBlock {
2739 Self::PTR
2740 }
2741 #[doc = r" Steal an instance of this peripheral"]
2742 #[doc = r""]
2743 #[doc = r" # Safety"]
2744 #[doc = r""]
2745 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2746 #[doc = r" that may race with any existing instances, for example by only"]
2747 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2748 #[doc = r" original peripheral and using critical sections to coordinate"]
2749 #[doc = r" access between multiple new instances."]
2750 #[doc = r""]
2751 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2752 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2753 #[doc = r" no stolen instances are passed to such software."]
2754 pub unsafe fn steal() -> Self {
2755 Self { _marker: PhantomData }
2756 }
2757}
2758impl Deref for USB0_CH6 {
2759 type Target = usb0_ch0::RegisterBlock;
2760 #[inline(always)]
2761 fn deref(&self) -> &Self::Target {
2762 unsafe { &*Self::PTR }
2763 }
2764}
2765impl core::fmt::Debug for USB0_CH6 {
2766 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2767 f.debug_struct("USB0_CH6").finish()
2768 }
2769}
2770#[doc = "Universal Serial Bus"]
2771pub use self::usb0_ch0 as usb0_ch6;
2772#[doc = "Universal Serial Bus"]
2773pub struct USB0_CH7 {
2774 _marker: PhantomData<*const ()>,
2775}
2776unsafe impl Send for USB0_CH7 {}
2777impl USB0_CH7 {
2778 #[doc = r"Pointer to the register block"]
2779 pub const PTR: *const usb0_ch0::RegisterBlock = 0x5004_05e0 as *const _;
2780 #[doc = r"Return the pointer to the register block"]
2781 #[inline(always)]
2782 pub const fn ptr() -> *const usb0_ch0::RegisterBlock {
2783 Self::PTR
2784 }
2785 #[doc = r" Steal an instance of this peripheral"]
2786 #[doc = r""]
2787 #[doc = r" # Safety"]
2788 #[doc = r""]
2789 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2790 #[doc = r" that may race with any existing instances, for example by only"]
2791 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2792 #[doc = r" original peripheral and using critical sections to coordinate"]
2793 #[doc = r" access between multiple new instances."]
2794 #[doc = r""]
2795 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2796 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2797 #[doc = r" no stolen instances are passed to such software."]
2798 pub unsafe fn steal() -> Self {
2799 Self { _marker: PhantomData }
2800 }
2801}
2802impl Deref for USB0_CH7 {
2803 type Target = usb0_ch0::RegisterBlock;
2804 #[inline(always)]
2805 fn deref(&self) -> &Self::Target {
2806 unsafe { &*Self::PTR }
2807 }
2808}
2809impl core::fmt::Debug for USB0_CH7 {
2810 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2811 f.debug_struct("USB0_CH7").finish()
2812 }
2813}
2814#[doc = "Universal Serial Bus"]
2815pub use self::usb0_ch0 as usb0_ch7;
2816#[doc = "Universal Serial Bus"]
2817pub struct USB0_CH8 {
2818 _marker: PhantomData<*const ()>,
2819}
2820unsafe impl Send for USB0_CH8 {}
2821impl USB0_CH8 {
2822 #[doc = r"Pointer to the register block"]
2823 pub const PTR: *const usb0_ch0::RegisterBlock = 0x5004_0600 as *const _;
2824 #[doc = r"Return the pointer to the register block"]
2825 #[inline(always)]
2826 pub const fn ptr() -> *const usb0_ch0::RegisterBlock {
2827 Self::PTR
2828 }
2829 #[doc = r" Steal an instance of this peripheral"]
2830 #[doc = r""]
2831 #[doc = r" # Safety"]
2832 #[doc = r""]
2833 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2834 #[doc = r" that may race with any existing instances, for example by only"]
2835 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2836 #[doc = r" original peripheral and using critical sections to coordinate"]
2837 #[doc = r" access between multiple new instances."]
2838 #[doc = r""]
2839 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2840 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2841 #[doc = r" no stolen instances are passed to such software."]
2842 pub unsafe fn steal() -> Self {
2843 Self { _marker: PhantomData }
2844 }
2845}
2846impl Deref for USB0_CH8 {
2847 type Target = usb0_ch0::RegisterBlock;
2848 #[inline(always)]
2849 fn deref(&self) -> &Self::Target {
2850 unsafe { &*Self::PTR }
2851 }
2852}
2853impl core::fmt::Debug for USB0_CH8 {
2854 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2855 f.debug_struct("USB0_CH8").finish()
2856 }
2857}
2858#[doc = "Universal Serial Bus"]
2859pub use self::usb0_ch0 as usb0_ch8;
2860#[doc = "Universal Serial Bus"]
2861pub struct USB0_CH9 {
2862 _marker: PhantomData<*const ()>,
2863}
2864unsafe impl Send for USB0_CH9 {}
2865impl USB0_CH9 {
2866 #[doc = r"Pointer to the register block"]
2867 pub const PTR: *const usb0_ch0::RegisterBlock = 0x5004_0620 as *const _;
2868 #[doc = r"Return the pointer to the register block"]
2869 #[inline(always)]
2870 pub const fn ptr() -> *const usb0_ch0::RegisterBlock {
2871 Self::PTR
2872 }
2873 #[doc = r" Steal an instance of this peripheral"]
2874 #[doc = r""]
2875 #[doc = r" # Safety"]
2876 #[doc = r""]
2877 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2878 #[doc = r" that may race with any existing instances, for example by only"]
2879 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2880 #[doc = r" original peripheral and using critical sections to coordinate"]
2881 #[doc = r" access between multiple new instances."]
2882 #[doc = r""]
2883 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2884 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2885 #[doc = r" no stolen instances are passed to such software."]
2886 pub unsafe fn steal() -> Self {
2887 Self { _marker: PhantomData }
2888 }
2889}
2890impl Deref for USB0_CH9 {
2891 type Target = usb0_ch0::RegisterBlock;
2892 #[inline(always)]
2893 fn deref(&self) -> &Self::Target {
2894 unsafe { &*Self::PTR }
2895 }
2896}
2897impl core::fmt::Debug for USB0_CH9 {
2898 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2899 f.debug_struct("USB0_CH9").finish()
2900 }
2901}
2902#[doc = "Universal Serial Bus"]
2903pub use self::usb0_ch0 as usb0_ch9;
2904#[doc = "Universal Serial Bus"]
2905pub struct USB0_CH10 {
2906 _marker: PhantomData<*const ()>,
2907}
2908unsafe impl Send for USB0_CH10 {}
2909impl USB0_CH10 {
2910 #[doc = r"Pointer to the register block"]
2911 pub const PTR: *const usb0_ch0::RegisterBlock = 0x5004_0640 as *const _;
2912 #[doc = r"Return the pointer to the register block"]
2913 #[inline(always)]
2914 pub const fn ptr() -> *const usb0_ch0::RegisterBlock {
2915 Self::PTR
2916 }
2917 #[doc = r" Steal an instance of this peripheral"]
2918 #[doc = r""]
2919 #[doc = r" # Safety"]
2920 #[doc = r""]
2921 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2922 #[doc = r" that may race with any existing instances, for example by only"]
2923 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2924 #[doc = r" original peripheral and using critical sections to coordinate"]
2925 #[doc = r" access between multiple new instances."]
2926 #[doc = r""]
2927 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2928 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2929 #[doc = r" no stolen instances are passed to such software."]
2930 pub unsafe fn steal() -> Self {
2931 Self { _marker: PhantomData }
2932 }
2933}
2934impl Deref for USB0_CH10 {
2935 type Target = usb0_ch0::RegisterBlock;
2936 #[inline(always)]
2937 fn deref(&self) -> &Self::Target {
2938 unsafe { &*Self::PTR }
2939 }
2940}
2941impl core::fmt::Debug for USB0_CH10 {
2942 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2943 f.debug_struct("USB0_CH10").finish()
2944 }
2945}
2946#[doc = "Universal Serial Bus"]
2947pub use self::usb0_ch0 as usb0_ch10;
2948#[doc = "Universal Serial Bus"]
2949pub struct USB0_CH11 {
2950 _marker: PhantomData<*const ()>,
2951}
2952unsafe impl Send for USB0_CH11 {}
2953impl USB0_CH11 {
2954 #[doc = r"Pointer to the register block"]
2955 pub const PTR: *const usb0_ch0::RegisterBlock = 0x5004_0660 as *const _;
2956 #[doc = r"Return the pointer to the register block"]
2957 #[inline(always)]
2958 pub const fn ptr() -> *const usb0_ch0::RegisterBlock {
2959 Self::PTR
2960 }
2961 #[doc = r" Steal an instance of this peripheral"]
2962 #[doc = r""]
2963 #[doc = r" # Safety"]
2964 #[doc = r""]
2965 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2966 #[doc = r" that may race with any existing instances, for example by only"]
2967 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2968 #[doc = r" original peripheral and using critical sections to coordinate"]
2969 #[doc = r" access between multiple new instances."]
2970 #[doc = r""]
2971 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2972 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2973 #[doc = r" no stolen instances are passed to such software."]
2974 pub unsafe fn steal() -> Self {
2975 Self { _marker: PhantomData }
2976 }
2977}
2978impl Deref for USB0_CH11 {
2979 type Target = usb0_ch0::RegisterBlock;
2980 #[inline(always)]
2981 fn deref(&self) -> &Self::Target {
2982 unsafe { &*Self::PTR }
2983 }
2984}
2985impl core::fmt::Debug for USB0_CH11 {
2986 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2987 f.debug_struct("USB0_CH11").finish()
2988 }
2989}
2990#[doc = "Universal Serial Bus"]
2991pub use self::usb0_ch0 as usb0_ch11;
2992#[doc = "Universal Serial Bus"]
2993pub struct USB0_CH12 {
2994 _marker: PhantomData<*const ()>,
2995}
2996unsafe impl Send for USB0_CH12 {}
2997impl USB0_CH12 {
2998 #[doc = r"Pointer to the register block"]
2999 pub const PTR: *const usb0_ch0::RegisterBlock = 0x5004_0680 as *const _;
3000 #[doc = r"Return the pointer to the register block"]
3001 #[inline(always)]
3002 pub const fn ptr() -> *const usb0_ch0::RegisterBlock {
3003 Self::PTR
3004 }
3005 #[doc = r" Steal an instance of this peripheral"]
3006 #[doc = r""]
3007 #[doc = r" # Safety"]
3008 #[doc = r""]
3009 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3010 #[doc = r" that may race with any existing instances, for example by only"]
3011 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3012 #[doc = r" original peripheral and using critical sections to coordinate"]
3013 #[doc = r" access between multiple new instances."]
3014 #[doc = r""]
3015 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3016 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3017 #[doc = r" no stolen instances are passed to such software."]
3018 pub unsafe fn steal() -> Self {
3019 Self { _marker: PhantomData }
3020 }
3021}
3022impl Deref for USB0_CH12 {
3023 type Target = usb0_ch0::RegisterBlock;
3024 #[inline(always)]
3025 fn deref(&self) -> &Self::Target {
3026 unsafe { &*Self::PTR }
3027 }
3028}
3029impl core::fmt::Debug for USB0_CH12 {
3030 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3031 f.debug_struct("USB0_CH12").finish()
3032 }
3033}
3034#[doc = "Universal Serial Bus"]
3035pub use self::usb0_ch0 as usb0_ch12;
3036#[doc = "Universal Serial Bus"]
3037pub struct USB0_CH13 {
3038 _marker: PhantomData<*const ()>,
3039}
3040unsafe impl Send for USB0_CH13 {}
3041impl USB0_CH13 {
3042 #[doc = r"Pointer to the register block"]
3043 pub const PTR: *const usb0_ch0::RegisterBlock = 0x5004_06a0 as *const _;
3044 #[doc = r"Return the pointer to the register block"]
3045 #[inline(always)]
3046 pub const fn ptr() -> *const usb0_ch0::RegisterBlock {
3047 Self::PTR
3048 }
3049 #[doc = r" Steal an instance of this peripheral"]
3050 #[doc = r""]
3051 #[doc = r" # Safety"]
3052 #[doc = r""]
3053 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3054 #[doc = r" that may race with any existing instances, for example by only"]
3055 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3056 #[doc = r" original peripheral and using critical sections to coordinate"]
3057 #[doc = r" access between multiple new instances."]
3058 #[doc = r""]
3059 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3060 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3061 #[doc = r" no stolen instances are passed to such software."]
3062 pub unsafe fn steal() -> Self {
3063 Self { _marker: PhantomData }
3064 }
3065}
3066impl Deref for USB0_CH13 {
3067 type Target = usb0_ch0::RegisterBlock;
3068 #[inline(always)]
3069 fn deref(&self) -> &Self::Target {
3070 unsafe { &*Self::PTR }
3071 }
3072}
3073impl core::fmt::Debug for USB0_CH13 {
3074 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3075 f.debug_struct("USB0_CH13").finish()
3076 }
3077}
3078#[doc = "Universal Serial Bus"]
3079pub use self::usb0_ch0 as usb0_ch13;
3080#[doc = "Universal Serial Interface Controller 0"]
3081pub struct USIC0 {
3082 _marker: PhantomData<*const ()>,
3083}
3084unsafe impl Send for USIC0 {}
3085impl USIC0 {
3086 #[doc = r"Pointer to the register block"]
3087 pub const PTR: *const usic0::RegisterBlock = 0x4003_0008 as *const _;
3088 #[doc = r"Return the pointer to the register block"]
3089 #[inline(always)]
3090 pub const fn ptr() -> *const usic0::RegisterBlock {
3091 Self::PTR
3092 }
3093 #[doc = r" Steal an instance of this peripheral"]
3094 #[doc = r""]
3095 #[doc = r" # Safety"]
3096 #[doc = r""]
3097 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3098 #[doc = r" that may race with any existing instances, for example by only"]
3099 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3100 #[doc = r" original peripheral and using critical sections to coordinate"]
3101 #[doc = r" access between multiple new instances."]
3102 #[doc = r""]
3103 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3104 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3105 #[doc = r" no stolen instances are passed to such software."]
3106 pub unsafe fn steal() -> Self {
3107 Self { _marker: PhantomData }
3108 }
3109}
3110impl Deref for USIC0 {
3111 type Target = usic0::RegisterBlock;
3112 #[inline(always)]
3113 fn deref(&self) -> &Self::Target {
3114 unsafe { &*Self::PTR }
3115 }
3116}
3117impl core::fmt::Debug for USIC0 {
3118 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3119 f.debug_struct("USIC0").finish()
3120 }
3121}
3122#[doc = "Universal Serial Interface Controller 0"]
3123pub mod usic0;
3124#[doc = "Universal Serial Interface Controller 1"]
3125pub struct USIC1 {
3126 _marker: PhantomData<*const ()>,
3127}
3128unsafe impl Send for USIC1 {}
3129impl USIC1 {
3130 #[doc = r"Pointer to the register block"]
3131 pub const PTR: *const usic0::RegisterBlock = 0x4802_0008 as *const _;
3132 #[doc = r"Return the pointer to the register block"]
3133 #[inline(always)]
3134 pub const fn ptr() -> *const usic0::RegisterBlock {
3135 Self::PTR
3136 }
3137 #[doc = r" Steal an instance of this peripheral"]
3138 #[doc = r""]
3139 #[doc = r" # Safety"]
3140 #[doc = r""]
3141 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3142 #[doc = r" that may race with any existing instances, for example by only"]
3143 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3144 #[doc = r" original peripheral and using critical sections to coordinate"]
3145 #[doc = r" access between multiple new instances."]
3146 #[doc = r""]
3147 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3148 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3149 #[doc = r" no stolen instances are passed to such software."]
3150 pub unsafe fn steal() -> Self {
3151 Self { _marker: PhantomData }
3152 }
3153}
3154impl Deref for USIC1 {
3155 type Target = usic0::RegisterBlock;
3156 #[inline(always)]
3157 fn deref(&self) -> &Self::Target {
3158 unsafe { &*Self::PTR }
3159 }
3160}
3161impl core::fmt::Debug for USIC1 {
3162 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3163 f.debug_struct("USIC1").finish()
3164 }
3165}
3166#[doc = "Universal Serial Interface Controller 1"]
3167pub use self::usic0 as usic1;
3168#[doc = "Universal Serial Interface Controller 0"]
3169pub struct USIC0_CH0 {
3170 _marker: PhantomData<*const ()>,
3171}
3172unsafe impl Send for USIC0_CH0 {}
3173impl USIC0_CH0 {
3174 #[doc = r"Pointer to the register block"]
3175 pub const PTR: *const usic0_ch0::RegisterBlock = 0x4003_0000 as *const _;
3176 #[doc = r"Return the pointer to the register block"]
3177 #[inline(always)]
3178 pub const fn ptr() -> *const usic0_ch0::RegisterBlock {
3179 Self::PTR
3180 }
3181 #[doc = r" Steal an instance of this peripheral"]
3182 #[doc = r""]
3183 #[doc = r" # Safety"]
3184 #[doc = r""]
3185 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3186 #[doc = r" that may race with any existing instances, for example by only"]
3187 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3188 #[doc = r" original peripheral and using critical sections to coordinate"]
3189 #[doc = r" access between multiple new instances."]
3190 #[doc = r""]
3191 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3192 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3193 #[doc = r" no stolen instances are passed to such software."]
3194 pub unsafe fn steal() -> Self {
3195 Self { _marker: PhantomData }
3196 }
3197}
3198impl Deref for USIC0_CH0 {
3199 type Target = usic0_ch0::RegisterBlock;
3200 #[inline(always)]
3201 fn deref(&self) -> &Self::Target {
3202 unsafe { &*Self::PTR }
3203 }
3204}
3205impl core::fmt::Debug for USIC0_CH0 {
3206 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3207 f.debug_struct("USIC0_CH0").finish()
3208 }
3209}
3210#[doc = "Universal Serial Interface Controller 0"]
3211pub mod usic0_ch0;
3212#[doc = "Universal Serial Interface Controller 0"]
3213pub struct USIC0_CH1 {
3214 _marker: PhantomData<*const ()>,
3215}
3216unsafe impl Send for USIC0_CH1 {}
3217impl USIC0_CH1 {
3218 #[doc = r"Pointer to the register block"]
3219 pub const PTR: *const usic0_ch0::RegisterBlock = 0x4003_0200 as *const _;
3220 #[doc = r"Return the pointer to the register block"]
3221 #[inline(always)]
3222 pub const fn ptr() -> *const usic0_ch0::RegisterBlock {
3223 Self::PTR
3224 }
3225 #[doc = r" Steal an instance of this peripheral"]
3226 #[doc = r""]
3227 #[doc = r" # Safety"]
3228 #[doc = r""]
3229 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3230 #[doc = r" that may race with any existing instances, for example by only"]
3231 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3232 #[doc = r" original peripheral and using critical sections to coordinate"]
3233 #[doc = r" access between multiple new instances."]
3234 #[doc = r""]
3235 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3236 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3237 #[doc = r" no stolen instances are passed to such software."]
3238 pub unsafe fn steal() -> Self {
3239 Self { _marker: PhantomData }
3240 }
3241}
3242impl Deref for USIC0_CH1 {
3243 type Target = usic0_ch0::RegisterBlock;
3244 #[inline(always)]
3245 fn deref(&self) -> &Self::Target {
3246 unsafe { &*Self::PTR }
3247 }
3248}
3249impl core::fmt::Debug for USIC0_CH1 {
3250 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3251 f.debug_struct("USIC0_CH1").finish()
3252 }
3253}
3254#[doc = "Universal Serial Interface Controller 0"]
3255pub use self::usic0_ch0 as usic0_ch1;
3256#[doc = "Universal Serial Interface Controller 1"]
3257pub struct USIC1_CH0 {
3258 _marker: PhantomData<*const ()>,
3259}
3260unsafe impl Send for USIC1_CH0 {}
3261impl USIC1_CH0 {
3262 #[doc = r"Pointer to the register block"]
3263 pub const PTR: *const usic0_ch0::RegisterBlock = 0x4802_0000 as *const _;
3264 #[doc = r"Return the pointer to the register block"]
3265 #[inline(always)]
3266 pub const fn ptr() -> *const usic0_ch0::RegisterBlock {
3267 Self::PTR
3268 }
3269 #[doc = r" Steal an instance of this peripheral"]
3270 #[doc = r""]
3271 #[doc = r" # Safety"]
3272 #[doc = r""]
3273 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3274 #[doc = r" that may race with any existing instances, for example by only"]
3275 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3276 #[doc = r" original peripheral and using critical sections to coordinate"]
3277 #[doc = r" access between multiple new instances."]
3278 #[doc = r""]
3279 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3280 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3281 #[doc = r" no stolen instances are passed to such software."]
3282 pub unsafe fn steal() -> Self {
3283 Self { _marker: PhantomData }
3284 }
3285}
3286impl Deref for USIC1_CH0 {
3287 type Target = usic0_ch0::RegisterBlock;
3288 #[inline(always)]
3289 fn deref(&self) -> &Self::Target {
3290 unsafe { &*Self::PTR }
3291 }
3292}
3293impl core::fmt::Debug for USIC1_CH0 {
3294 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3295 f.debug_struct("USIC1_CH0").finish()
3296 }
3297}
3298#[doc = "Universal Serial Interface Controller 1"]
3299pub use self::usic0_ch0 as usic1_ch0;
3300#[doc = "Universal Serial Interface Controller 1"]
3301pub struct USIC1_CH1 {
3302 _marker: PhantomData<*const ()>,
3303}
3304unsafe impl Send for USIC1_CH1 {}
3305impl USIC1_CH1 {
3306 #[doc = r"Pointer to the register block"]
3307 pub const PTR: *const usic0_ch0::RegisterBlock = 0x4802_0200 as *const _;
3308 #[doc = r"Return the pointer to the register block"]
3309 #[inline(always)]
3310 pub const fn ptr() -> *const usic0_ch0::RegisterBlock {
3311 Self::PTR
3312 }
3313 #[doc = r" Steal an instance of this peripheral"]
3314 #[doc = r""]
3315 #[doc = r" # Safety"]
3316 #[doc = r""]
3317 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3318 #[doc = r" that may race with any existing instances, for example by only"]
3319 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3320 #[doc = r" original peripheral and using critical sections to coordinate"]
3321 #[doc = r" access between multiple new instances."]
3322 #[doc = r""]
3323 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3324 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3325 #[doc = r" no stolen instances are passed to such software."]
3326 pub unsafe fn steal() -> Self {
3327 Self { _marker: PhantomData }
3328 }
3329}
3330impl Deref for USIC1_CH1 {
3331 type Target = usic0_ch0::RegisterBlock;
3332 #[inline(always)]
3333 fn deref(&self) -> &Self::Target {
3334 unsafe { &*Self::PTR }
3335 }
3336}
3337impl core::fmt::Debug for USIC1_CH1 {
3338 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3339 f.debug_struct("USIC1_CH1").finish()
3340 }
3341}
3342#[doc = "Universal Serial Interface Controller 1"]
3343pub use self::usic0_ch0 as usic1_ch1;
3344#[doc = "Controller Area Networks"]
3345pub struct CAN {
3346 _marker: PhantomData<*const ()>,
3347}
3348unsafe impl Send for CAN {}
3349impl CAN {
3350 #[doc = r"Pointer to the register block"]
3351 pub const PTR: *const can::RegisterBlock = 0x4801_4000 as *const _;
3352 #[doc = r"Return the pointer to the register block"]
3353 #[inline(always)]
3354 pub const fn ptr() -> *const can::RegisterBlock {
3355 Self::PTR
3356 }
3357 #[doc = r" Steal an instance of this peripheral"]
3358 #[doc = r""]
3359 #[doc = r" # Safety"]
3360 #[doc = r""]
3361 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3362 #[doc = r" that may race with any existing instances, for example by only"]
3363 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3364 #[doc = r" original peripheral and using critical sections to coordinate"]
3365 #[doc = r" access between multiple new instances."]
3366 #[doc = r""]
3367 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3368 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3369 #[doc = r" no stolen instances are passed to such software."]
3370 pub unsafe fn steal() -> Self {
3371 Self { _marker: PhantomData }
3372 }
3373}
3374impl Deref for CAN {
3375 type Target = can::RegisterBlock;
3376 #[inline(always)]
3377 fn deref(&self) -> &Self::Target {
3378 unsafe { &*Self::PTR }
3379 }
3380}
3381impl core::fmt::Debug for CAN {
3382 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3383 f.debug_struct("CAN").finish()
3384 }
3385}
3386#[doc = "Controller Area Networks"]
3387pub mod can;
3388#[doc = "Controller Area Networks"]
3389pub struct CAN_NODE0 {
3390 _marker: PhantomData<*const ()>,
3391}
3392unsafe impl Send for CAN_NODE0 {}
3393impl CAN_NODE0 {
3394 #[doc = r"Pointer to the register block"]
3395 pub const PTR: *const can_node0::RegisterBlock = 0x4801_4200 as *const _;
3396 #[doc = r"Return the pointer to the register block"]
3397 #[inline(always)]
3398 pub const fn ptr() -> *const can_node0::RegisterBlock {
3399 Self::PTR
3400 }
3401 #[doc = r" Steal an instance of this peripheral"]
3402 #[doc = r""]
3403 #[doc = r" # Safety"]
3404 #[doc = r""]
3405 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3406 #[doc = r" that may race with any existing instances, for example by only"]
3407 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3408 #[doc = r" original peripheral and using critical sections to coordinate"]
3409 #[doc = r" access between multiple new instances."]
3410 #[doc = r""]
3411 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3412 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3413 #[doc = r" no stolen instances are passed to such software."]
3414 pub unsafe fn steal() -> Self {
3415 Self { _marker: PhantomData }
3416 }
3417}
3418impl Deref for CAN_NODE0 {
3419 type Target = can_node0::RegisterBlock;
3420 #[inline(always)]
3421 fn deref(&self) -> &Self::Target {
3422 unsafe { &*Self::PTR }
3423 }
3424}
3425impl core::fmt::Debug for CAN_NODE0 {
3426 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3427 f.debug_struct("CAN_NODE0").finish()
3428 }
3429}
3430#[doc = "Controller Area Networks"]
3431pub mod can_node0;
3432#[doc = "Controller Area Networks"]
3433pub struct CAN_NODE1 {
3434 _marker: PhantomData<*const ()>,
3435}
3436unsafe impl Send for CAN_NODE1 {}
3437impl CAN_NODE1 {
3438 #[doc = r"Pointer to the register block"]
3439 pub const PTR: *const can_node0::RegisterBlock = 0x4801_4300 as *const _;
3440 #[doc = r"Return the pointer to the register block"]
3441 #[inline(always)]
3442 pub const fn ptr() -> *const can_node0::RegisterBlock {
3443 Self::PTR
3444 }
3445 #[doc = r" Steal an instance of this peripheral"]
3446 #[doc = r""]
3447 #[doc = r" # Safety"]
3448 #[doc = r""]
3449 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3450 #[doc = r" that may race with any existing instances, for example by only"]
3451 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3452 #[doc = r" original peripheral and using critical sections to coordinate"]
3453 #[doc = r" access between multiple new instances."]
3454 #[doc = r""]
3455 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3456 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3457 #[doc = r" no stolen instances are passed to such software."]
3458 pub unsafe fn steal() -> Self {
3459 Self { _marker: PhantomData }
3460 }
3461}
3462impl Deref for CAN_NODE1 {
3463 type Target = can_node0::RegisterBlock;
3464 #[inline(always)]
3465 fn deref(&self) -> &Self::Target {
3466 unsafe { &*Self::PTR }
3467 }
3468}
3469impl core::fmt::Debug for CAN_NODE1 {
3470 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3471 f.debug_struct("CAN_NODE1").finish()
3472 }
3473}
3474#[doc = "Controller Area Networks"]
3475pub use self::can_node0 as can_node1;
3476#[doc = "Controller Area Networks"]
3477pub struct CAN_MO0 {
3478 _marker: PhantomData<*const ()>,
3479}
3480unsafe impl Send for CAN_MO0 {}
3481impl CAN_MO0 {
3482 #[doc = r"Pointer to the register block"]
3483 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5000 as *const _;
3484 #[doc = r"Return the pointer to the register block"]
3485 #[inline(always)]
3486 pub const fn ptr() -> *const can_mo0::RegisterBlock {
3487 Self::PTR
3488 }
3489 #[doc = r" Steal an instance of this peripheral"]
3490 #[doc = r""]
3491 #[doc = r" # Safety"]
3492 #[doc = r""]
3493 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3494 #[doc = r" that may race with any existing instances, for example by only"]
3495 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3496 #[doc = r" original peripheral and using critical sections to coordinate"]
3497 #[doc = r" access between multiple new instances."]
3498 #[doc = r""]
3499 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3500 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3501 #[doc = r" no stolen instances are passed to such software."]
3502 pub unsafe fn steal() -> Self {
3503 Self { _marker: PhantomData }
3504 }
3505}
3506impl Deref for CAN_MO0 {
3507 type Target = can_mo0::RegisterBlock;
3508 #[inline(always)]
3509 fn deref(&self) -> &Self::Target {
3510 unsafe { &*Self::PTR }
3511 }
3512}
3513impl core::fmt::Debug for CAN_MO0 {
3514 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3515 f.debug_struct("CAN_MO0").finish()
3516 }
3517}
3518#[doc = "Controller Area Networks"]
3519pub mod can_mo0;
3520#[doc = "Controller Area Networks"]
3521pub struct CAN_MO1 {
3522 _marker: PhantomData<*const ()>,
3523}
3524unsafe impl Send for CAN_MO1 {}
3525impl CAN_MO1 {
3526 #[doc = r"Pointer to the register block"]
3527 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5020 as *const _;
3528 #[doc = r"Return the pointer to the register block"]
3529 #[inline(always)]
3530 pub const fn ptr() -> *const can_mo0::RegisterBlock {
3531 Self::PTR
3532 }
3533 #[doc = r" Steal an instance of this peripheral"]
3534 #[doc = r""]
3535 #[doc = r" # Safety"]
3536 #[doc = r""]
3537 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3538 #[doc = r" that may race with any existing instances, for example by only"]
3539 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3540 #[doc = r" original peripheral and using critical sections to coordinate"]
3541 #[doc = r" access between multiple new instances."]
3542 #[doc = r""]
3543 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3544 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3545 #[doc = r" no stolen instances are passed to such software."]
3546 pub unsafe fn steal() -> Self {
3547 Self { _marker: PhantomData }
3548 }
3549}
3550impl Deref for CAN_MO1 {
3551 type Target = can_mo0::RegisterBlock;
3552 #[inline(always)]
3553 fn deref(&self) -> &Self::Target {
3554 unsafe { &*Self::PTR }
3555 }
3556}
3557impl core::fmt::Debug for CAN_MO1 {
3558 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3559 f.debug_struct("CAN_MO1").finish()
3560 }
3561}
3562#[doc = "Controller Area Networks"]
3563pub use self::can_mo0 as can_mo1;
3564#[doc = "Controller Area Networks"]
3565pub struct CAN_MO2 {
3566 _marker: PhantomData<*const ()>,
3567}
3568unsafe impl Send for CAN_MO2 {}
3569impl CAN_MO2 {
3570 #[doc = r"Pointer to the register block"]
3571 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5040 as *const _;
3572 #[doc = r"Return the pointer to the register block"]
3573 #[inline(always)]
3574 pub const fn ptr() -> *const can_mo0::RegisterBlock {
3575 Self::PTR
3576 }
3577 #[doc = r" Steal an instance of this peripheral"]
3578 #[doc = r""]
3579 #[doc = r" # Safety"]
3580 #[doc = r""]
3581 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3582 #[doc = r" that may race with any existing instances, for example by only"]
3583 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3584 #[doc = r" original peripheral and using critical sections to coordinate"]
3585 #[doc = r" access between multiple new instances."]
3586 #[doc = r""]
3587 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3588 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3589 #[doc = r" no stolen instances are passed to such software."]
3590 pub unsafe fn steal() -> Self {
3591 Self { _marker: PhantomData }
3592 }
3593}
3594impl Deref for CAN_MO2 {
3595 type Target = can_mo0::RegisterBlock;
3596 #[inline(always)]
3597 fn deref(&self) -> &Self::Target {
3598 unsafe { &*Self::PTR }
3599 }
3600}
3601impl core::fmt::Debug for CAN_MO2 {
3602 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3603 f.debug_struct("CAN_MO2").finish()
3604 }
3605}
3606#[doc = "Controller Area Networks"]
3607pub use self::can_mo0 as can_mo2;
3608#[doc = "Controller Area Networks"]
3609pub struct CAN_MO3 {
3610 _marker: PhantomData<*const ()>,
3611}
3612unsafe impl Send for CAN_MO3 {}
3613impl CAN_MO3 {
3614 #[doc = r"Pointer to the register block"]
3615 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5060 as *const _;
3616 #[doc = r"Return the pointer to the register block"]
3617 #[inline(always)]
3618 pub const fn ptr() -> *const can_mo0::RegisterBlock {
3619 Self::PTR
3620 }
3621 #[doc = r" Steal an instance of this peripheral"]
3622 #[doc = r""]
3623 #[doc = r" # Safety"]
3624 #[doc = r""]
3625 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3626 #[doc = r" that may race with any existing instances, for example by only"]
3627 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3628 #[doc = r" original peripheral and using critical sections to coordinate"]
3629 #[doc = r" access between multiple new instances."]
3630 #[doc = r""]
3631 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3632 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3633 #[doc = r" no stolen instances are passed to such software."]
3634 pub unsafe fn steal() -> Self {
3635 Self { _marker: PhantomData }
3636 }
3637}
3638impl Deref for CAN_MO3 {
3639 type Target = can_mo0::RegisterBlock;
3640 #[inline(always)]
3641 fn deref(&self) -> &Self::Target {
3642 unsafe { &*Self::PTR }
3643 }
3644}
3645impl core::fmt::Debug for CAN_MO3 {
3646 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3647 f.debug_struct("CAN_MO3").finish()
3648 }
3649}
3650#[doc = "Controller Area Networks"]
3651pub use self::can_mo0 as can_mo3;
3652#[doc = "Controller Area Networks"]
3653pub struct CAN_MO4 {
3654 _marker: PhantomData<*const ()>,
3655}
3656unsafe impl Send for CAN_MO4 {}
3657impl CAN_MO4 {
3658 #[doc = r"Pointer to the register block"]
3659 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5080 as *const _;
3660 #[doc = r"Return the pointer to the register block"]
3661 #[inline(always)]
3662 pub const fn ptr() -> *const can_mo0::RegisterBlock {
3663 Self::PTR
3664 }
3665 #[doc = r" Steal an instance of this peripheral"]
3666 #[doc = r""]
3667 #[doc = r" # Safety"]
3668 #[doc = r""]
3669 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3670 #[doc = r" that may race with any existing instances, for example by only"]
3671 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3672 #[doc = r" original peripheral and using critical sections to coordinate"]
3673 #[doc = r" access between multiple new instances."]
3674 #[doc = r""]
3675 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3676 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3677 #[doc = r" no stolen instances are passed to such software."]
3678 pub unsafe fn steal() -> Self {
3679 Self { _marker: PhantomData }
3680 }
3681}
3682impl Deref for CAN_MO4 {
3683 type Target = can_mo0::RegisterBlock;
3684 #[inline(always)]
3685 fn deref(&self) -> &Self::Target {
3686 unsafe { &*Self::PTR }
3687 }
3688}
3689impl core::fmt::Debug for CAN_MO4 {
3690 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3691 f.debug_struct("CAN_MO4").finish()
3692 }
3693}
3694#[doc = "Controller Area Networks"]
3695pub use self::can_mo0 as can_mo4;
3696#[doc = "Controller Area Networks"]
3697pub struct CAN_MO5 {
3698 _marker: PhantomData<*const ()>,
3699}
3700unsafe impl Send for CAN_MO5 {}
3701impl CAN_MO5 {
3702 #[doc = r"Pointer to the register block"]
3703 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_50a0 as *const _;
3704 #[doc = r"Return the pointer to the register block"]
3705 #[inline(always)]
3706 pub const fn ptr() -> *const can_mo0::RegisterBlock {
3707 Self::PTR
3708 }
3709 #[doc = r" Steal an instance of this peripheral"]
3710 #[doc = r""]
3711 #[doc = r" # Safety"]
3712 #[doc = r""]
3713 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3714 #[doc = r" that may race with any existing instances, for example by only"]
3715 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3716 #[doc = r" original peripheral and using critical sections to coordinate"]
3717 #[doc = r" access between multiple new instances."]
3718 #[doc = r""]
3719 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3720 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3721 #[doc = r" no stolen instances are passed to such software."]
3722 pub unsafe fn steal() -> Self {
3723 Self { _marker: PhantomData }
3724 }
3725}
3726impl Deref for CAN_MO5 {
3727 type Target = can_mo0::RegisterBlock;
3728 #[inline(always)]
3729 fn deref(&self) -> &Self::Target {
3730 unsafe { &*Self::PTR }
3731 }
3732}
3733impl core::fmt::Debug for CAN_MO5 {
3734 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3735 f.debug_struct("CAN_MO5").finish()
3736 }
3737}
3738#[doc = "Controller Area Networks"]
3739pub use self::can_mo0 as can_mo5;
3740#[doc = "Controller Area Networks"]
3741pub struct CAN_MO6 {
3742 _marker: PhantomData<*const ()>,
3743}
3744unsafe impl Send for CAN_MO6 {}
3745impl CAN_MO6 {
3746 #[doc = r"Pointer to the register block"]
3747 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_50c0 as *const _;
3748 #[doc = r"Return the pointer to the register block"]
3749 #[inline(always)]
3750 pub const fn ptr() -> *const can_mo0::RegisterBlock {
3751 Self::PTR
3752 }
3753 #[doc = r" Steal an instance of this peripheral"]
3754 #[doc = r""]
3755 #[doc = r" # Safety"]
3756 #[doc = r""]
3757 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3758 #[doc = r" that may race with any existing instances, for example by only"]
3759 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3760 #[doc = r" original peripheral and using critical sections to coordinate"]
3761 #[doc = r" access between multiple new instances."]
3762 #[doc = r""]
3763 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3764 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3765 #[doc = r" no stolen instances are passed to such software."]
3766 pub unsafe fn steal() -> Self {
3767 Self { _marker: PhantomData }
3768 }
3769}
3770impl Deref for CAN_MO6 {
3771 type Target = can_mo0::RegisterBlock;
3772 #[inline(always)]
3773 fn deref(&self) -> &Self::Target {
3774 unsafe { &*Self::PTR }
3775 }
3776}
3777impl core::fmt::Debug for CAN_MO6 {
3778 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3779 f.debug_struct("CAN_MO6").finish()
3780 }
3781}
3782#[doc = "Controller Area Networks"]
3783pub use self::can_mo0 as can_mo6;
3784#[doc = "Controller Area Networks"]
3785pub struct CAN_MO7 {
3786 _marker: PhantomData<*const ()>,
3787}
3788unsafe impl Send for CAN_MO7 {}
3789impl CAN_MO7 {
3790 #[doc = r"Pointer to the register block"]
3791 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_50e0 as *const _;
3792 #[doc = r"Return the pointer to the register block"]
3793 #[inline(always)]
3794 pub const fn ptr() -> *const can_mo0::RegisterBlock {
3795 Self::PTR
3796 }
3797 #[doc = r" Steal an instance of this peripheral"]
3798 #[doc = r""]
3799 #[doc = r" # Safety"]
3800 #[doc = r""]
3801 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3802 #[doc = r" that may race with any existing instances, for example by only"]
3803 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3804 #[doc = r" original peripheral and using critical sections to coordinate"]
3805 #[doc = r" access between multiple new instances."]
3806 #[doc = r""]
3807 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3808 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3809 #[doc = r" no stolen instances are passed to such software."]
3810 pub unsafe fn steal() -> Self {
3811 Self { _marker: PhantomData }
3812 }
3813}
3814impl Deref for CAN_MO7 {
3815 type Target = can_mo0::RegisterBlock;
3816 #[inline(always)]
3817 fn deref(&self) -> &Self::Target {
3818 unsafe { &*Self::PTR }
3819 }
3820}
3821impl core::fmt::Debug for CAN_MO7 {
3822 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3823 f.debug_struct("CAN_MO7").finish()
3824 }
3825}
3826#[doc = "Controller Area Networks"]
3827pub use self::can_mo0 as can_mo7;
3828#[doc = "Controller Area Networks"]
3829pub struct CAN_MO8 {
3830 _marker: PhantomData<*const ()>,
3831}
3832unsafe impl Send for CAN_MO8 {}
3833impl CAN_MO8 {
3834 #[doc = r"Pointer to the register block"]
3835 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5100 as *const _;
3836 #[doc = r"Return the pointer to the register block"]
3837 #[inline(always)]
3838 pub const fn ptr() -> *const can_mo0::RegisterBlock {
3839 Self::PTR
3840 }
3841 #[doc = r" Steal an instance of this peripheral"]
3842 #[doc = r""]
3843 #[doc = r" # Safety"]
3844 #[doc = r""]
3845 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3846 #[doc = r" that may race with any existing instances, for example by only"]
3847 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3848 #[doc = r" original peripheral and using critical sections to coordinate"]
3849 #[doc = r" access between multiple new instances."]
3850 #[doc = r""]
3851 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3852 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3853 #[doc = r" no stolen instances are passed to such software."]
3854 pub unsafe fn steal() -> Self {
3855 Self { _marker: PhantomData }
3856 }
3857}
3858impl Deref for CAN_MO8 {
3859 type Target = can_mo0::RegisterBlock;
3860 #[inline(always)]
3861 fn deref(&self) -> &Self::Target {
3862 unsafe { &*Self::PTR }
3863 }
3864}
3865impl core::fmt::Debug for CAN_MO8 {
3866 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3867 f.debug_struct("CAN_MO8").finish()
3868 }
3869}
3870#[doc = "Controller Area Networks"]
3871pub use self::can_mo0 as can_mo8;
3872#[doc = "Controller Area Networks"]
3873pub struct CAN_MO9 {
3874 _marker: PhantomData<*const ()>,
3875}
3876unsafe impl Send for CAN_MO9 {}
3877impl CAN_MO9 {
3878 #[doc = r"Pointer to the register block"]
3879 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5120 as *const _;
3880 #[doc = r"Return the pointer to the register block"]
3881 #[inline(always)]
3882 pub const fn ptr() -> *const can_mo0::RegisterBlock {
3883 Self::PTR
3884 }
3885 #[doc = r" Steal an instance of this peripheral"]
3886 #[doc = r""]
3887 #[doc = r" # Safety"]
3888 #[doc = r""]
3889 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3890 #[doc = r" that may race with any existing instances, for example by only"]
3891 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3892 #[doc = r" original peripheral and using critical sections to coordinate"]
3893 #[doc = r" access between multiple new instances."]
3894 #[doc = r""]
3895 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3896 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3897 #[doc = r" no stolen instances are passed to such software."]
3898 pub unsafe fn steal() -> Self {
3899 Self { _marker: PhantomData }
3900 }
3901}
3902impl Deref for CAN_MO9 {
3903 type Target = can_mo0::RegisterBlock;
3904 #[inline(always)]
3905 fn deref(&self) -> &Self::Target {
3906 unsafe { &*Self::PTR }
3907 }
3908}
3909impl core::fmt::Debug for CAN_MO9 {
3910 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3911 f.debug_struct("CAN_MO9").finish()
3912 }
3913}
3914#[doc = "Controller Area Networks"]
3915pub use self::can_mo0 as can_mo9;
3916#[doc = "Controller Area Networks"]
3917pub struct CAN_MO10 {
3918 _marker: PhantomData<*const ()>,
3919}
3920unsafe impl Send for CAN_MO10 {}
3921impl CAN_MO10 {
3922 #[doc = r"Pointer to the register block"]
3923 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5140 as *const _;
3924 #[doc = r"Return the pointer to the register block"]
3925 #[inline(always)]
3926 pub const fn ptr() -> *const can_mo0::RegisterBlock {
3927 Self::PTR
3928 }
3929 #[doc = r" Steal an instance of this peripheral"]
3930 #[doc = r""]
3931 #[doc = r" # Safety"]
3932 #[doc = r""]
3933 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3934 #[doc = r" that may race with any existing instances, for example by only"]
3935 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3936 #[doc = r" original peripheral and using critical sections to coordinate"]
3937 #[doc = r" access between multiple new instances."]
3938 #[doc = r""]
3939 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3940 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3941 #[doc = r" no stolen instances are passed to such software."]
3942 pub unsafe fn steal() -> Self {
3943 Self { _marker: PhantomData }
3944 }
3945}
3946impl Deref for CAN_MO10 {
3947 type Target = can_mo0::RegisterBlock;
3948 #[inline(always)]
3949 fn deref(&self) -> &Self::Target {
3950 unsafe { &*Self::PTR }
3951 }
3952}
3953impl core::fmt::Debug for CAN_MO10 {
3954 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3955 f.debug_struct("CAN_MO10").finish()
3956 }
3957}
3958#[doc = "Controller Area Networks"]
3959pub use self::can_mo0 as can_mo10;
3960#[doc = "Controller Area Networks"]
3961pub struct CAN_MO11 {
3962 _marker: PhantomData<*const ()>,
3963}
3964unsafe impl Send for CAN_MO11 {}
3965impl CAN_MO11 {
3966 #[doc = r"Pointer to the register block"]
3967 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5160 as *const _;
3968 #[doc = r"Return the pointer to the register block"]
3969 #[inline(always)]
3970 pub const fn ptr() -> *const can_mo0::RegisterBlock {
3971 Self::PTR
3972 }
3973 #[doc = r" Steal an instance of this peripheral"]
3974 #[doc = r""]
3975 #[doc = r" # Safety"]
3976 #[doc = r""]
3977 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3978 #[doc = r" that may race with any existing instances, for example by only"]
3979 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3980 #[doc = r" original peripheral and using critical sections to coordinate"]
3981 #[doc = r" access between multiple new instances."]
3982 #[doc = r""]
3983 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3984 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3985 #[doc = r" no stolen instances are passed to such software."]
3986 pub unsafe fn steal() -> Self {
3987 Self { _marker: PhantomData }
3988 }
3989}
3990impl Deref for CAN_MO11 {
3991 type Target = can_mo0::RegisterBlock;
3992 #[inline(always)]
3993 fn deref(&self) -> &Self::Target {
3994 unsafe { &*Self::PTR }
3995 }
3996}
3997impl core::fmt::Debug for CAN_MO11 {
3998 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3999 f.debug_struct("CAN_MO11").finish()
4000 }
4001}
4002#[doc = "Controller Area Networks"]
4003pub use self::can_mo0 as can_mo11;
4004#[doc = "Controller Area Networks"]
4005pub struct CAN_MO12 {
4006 _marker: PhantomData<*const ()>,
4007}
4008unsafe impl Send for CAN_MO12 {}
4009impl CAN_MO12 {
4010 #[doc = r"Pointer to the register block"]
4011 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5180 as *const _;
4012 #[doc = r"Return the pointer to the register block"]
4013 #[inline(always)]
4014 pub const fn ptr() -> *const can_mo0::RegisterBlock {
4015 Self::PTR
4016 }
4017 #[doc = r" Steal an instance of this peripheral"]
4018 #[doc = r""]
4019 #[doc = r" # Safety"]
4020 #[doc = r""]
4021 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4022 #[doc = r" that may race with any existing instances, for example by only"]
4023 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4024 #[doc = r" original peripheral and using critical sections to coordinate"]
4025 #[doc = r" access between multiple new instances."]
4026 #[doc = r""]
4027 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4028 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4029 #[doc = r" no stolen instances are passed to such software."]
4030 pub unsafe fn steal() -> Self {
4031 Self { _marker: PhantomData }
4032 }
4033}
4034impl Deref for CAN_MO12 {
4035 type Target = can_mo0::RegisterBlock;
4036 #[inline(always)]
4037 fn deref(&self) -> &Self::Target {
4038 unsafe { &*Self::PTR }
4039 }
4040}
4041impl core::fmt::Debug for CAN_MO12 {
4042 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4043 f.debug_struct("CAN_MO12").finish()
4044 }
4045}
4046#[doc = "Controller Area Networks"]
4047pub use self::can_mo0 as can_mo12;
4048#[doc = "Controller Area Networks"]
4049pub struct CAN_MO13 {
4050 _marker: PhantomData<*const ()>,
4051}
4052unsafe impl Send for CAN_MO13 {}
4053impl CAN_MO13 {
4054 #[doc = r"Pointer to the register block"]
4055 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_51a0 as *const _;
4056 #[doc = r"Return the pointer to the register block"]
4057 #[inline(always)]
4058 pub const fn ptr() -> *const can_mo0::RegisterBlock {
4059 Self::PTR
4060 }
4061 #[doc = r" Steal an instance of this peripheral"]
4062 #[doc = r""]
4063 #[doc = r" # Safety"]
4064 #[doc = r""]
4065 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4066 #[doc = r" that may race with any existing instances, for example by only"]
4067 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4068 #[doc = r" original peripheral and using critical sections to coordinate"]
4069 #[doc = r" access between multiple new instances."]
4070 #[doc = r""]
4071 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4072 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4073 #[doc = r" no stolen instances are passed to such software."]
4074 pub unsafe fn steal() -> Self {
4075 Self { _marker: PhantomData }
4076 }
4077}
4078impl Deref for CAN_MO13 {
4079 type Target = can_mo0::RegisterBlock;
4080 #[inline(always)]
4081 fn deref(&self) -> &Self::Target {
4082 unsafe { &*Self::PTR }
4083 }
4084}
4085impl core::fmt::Debug for CAN_MO13 {
4086 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4087 f.debug_struct("CAN_MO13").finish()
4088 }
4089}
4090#[doc = "Controller Area Networks"]
4091pub use self::can_mo0 as can_mo13;
4092#[doc = "Controller Area Networks"]
4093pub struct CAN_MO14 {
4094 _marker: PhantomData<*const ()>,
4095}
4096unsafe impl Send for CAN_MO14 {}
4097impl CAN_MO14 {
4098 #[doc = r"Pointer to the register block"]
4099 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_51c0 as *const _;
4100 #[doc = r"Return the pointer to the register block"]
4101 #[inline(always)]
4102 pub const fn ptr() -> *const can_mo0::RegisterBlock {
4103 Self::PTR
4104 }
4105 #[doc = r" Steal an instance of this peripheral"]
4106 #[doc = r""]
4107 #[doc = r" # Safety"]
4108 #[doc = r""]
4109 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4110 #[doc = r" that may race with any existing instances, for example by only"]
4111 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4112 #[doc = r" original peripheral and using critical sections to coordinate"]
4113 #[doc = r" access between multiple new instances."]
4114 #[doc = r""]
4115 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4116 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4117 #[doc = r" no stolen instances are passed to such software."]
4118 pub unsafe fn steal() -> Self {
4119 Self { _marker: PhantomData }
4120 }
4121}
4122impl Deref for CAN_MO14 {
4123 type Target = can_mo0::RegisterBlock;
4124 #[inline(always)]
4125 fn deref(&self) -> &Self::Target {
4126 unsafe { &*Self::PTR }
4127 }
4128}
4129impl core::fmt::Debug for CAN_MO14 {
4130 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4131 f.debug_struct("CAN_MO14").finish()
4132 }
4133}
4134#[doc = "Controller Area Networks"]
4135pub use self::can_mo0 as can_mo14;
4136#[doc = "Controller Area Networks"]
4137pub struct CAN_MO15 {
4138 _marker: PhantomData<*const ()>,
4139}
4140unsafe impl Send for CAN_MO15 {}
4141impl CAN_MO15 {
4142 #[doc = r"Pointer to the register block"]
4143 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_51e0 as *const _;
4144 #[doc = r"Return the pointer to the register block"]
4145 #[inline(always)]
4146 pub const fn ptr() -> *const can_mo0::RegisterBlock {
4147 Self::PTR
4148 }
4149 #[doc = r" Steal an instance of this peripheral"]
4150 #[doc = r""]
4151 #[doc = r" # Safety"]
4152 #[doc = r""]
4153 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4154 #[doc = r" that may race with any existing instances, for example by only"]
4155 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4156 #[doc = r" original peripheral and using critical sections to coordinate"]
4157 #[doc = r" access between multiple new instances."]
4158 #[doc = r""]
4159 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4160 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4161 #[doc = r" no stolen instances are passed to such software."]
4162 pub unsafe fn steal() -> Self {
4163 Self { _marker: PhantomData }
4164 }
4165}
4166impl Deref for CAN_MO15 {
4167 type Target = can_mo0::RegisterBlock;
4168 #[inline(always)]
4169 fn deref(&self) -> &Self::Target {
4170 unsafe { &*Self::PTR }
4171 }
4172}
4173impl core::fmt::Debug for CAN_MO15 {
4174 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4175 f.debug_struct("CAN_MO15").finish()
4176 }
4177}
4178#[doc = "Controller Area Networks"]
4179pub use self::can_mo0 as can_mo15;
4180#[doc = "Controller Area Networks"]
4181pub struct CAN_MO16 {
4182 _marker: PhantomData<*const ()>,
4183}
4184unsafe impl Send for CAN_MO16 {}
4185impl CAN_MO16 {
4186 #[doc = r"Pointer to the register block"]
4187 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5200 as *const _;
4188 #[doc = r"Return the pointer to the register block"]
4189 #[inline(always)]
4190 pub const fn ptr() -> *const can_mo0::RegisterBlock {
4191 Self::PTR
4192 }
4193 #[doc = r" Steal an instance of this peripheral"]
4194 #[doc = r""]
4195 #[doc = r" # Safety"]
4196 #[doc = r""]
4197 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4198 #[doc = r" that may race with any existing instances, for example by only"]
4199 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4200 #[doc = r" original peripheral and using critical sections to coordinate"]
4201 #[doc = r" access between multiple new instances."]
4202 #[doc = r""]
4203 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4204 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4205 #[doc = r" no stolen instances are passed to such software."]
4206 pub unsafe fn steal() -> Self {
4207 Self { _marker: PhantomData }
4208 }
4209}
4210impl Deref for CAN_MO16 {
4211 type Target = can_mo0::RegisterBlock;
4212 #[inline(always)]
4213 fn deref(&self) -> &Self::Target {
4214 unsafe { &*Self::PTR }
4215 }
4216}
4217impl core::fmt::Debug for CAN_MO16 {
4218 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4219 f.debug_struct("CAN_MO16").finish()
4220 }
4221}
4222#[doc = "Controller Area Networks"]
4223pub use self::can_mo0 as can_mo16;
4224#[doc = "Controller Area Networks"]
4225pub struct CAN_MO17 {
4226 _marker: PhantomData<*const ()>,
4227}
4228unsafe impl Send for CAN_MO17 {}
4229impl CAN_MO17 {
4230 #[doc = r"Pointer to the register block"]
4231 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5220 as *const _;
4232 #[doc = r"Return the pointer to the register block"]
4233 #[inline(always)]
4234 pub const fn ptr() -> *const can_mo0::RegisterBlock {
4235 Self::PTR
4236 }
4237 #[doc = r" Steal an instance of this peripheral"]
4238 #[doc = r""]
4239 #[doc = r" # Safety"]
4240 #[doc = r""]
4241 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4242 #[doc = r" that may race with any existing instances, for example by only"]
4243 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4244 #[doc = r" original peripheral and using critical sections to coordinate"]
4245 #[doc = r" access between multiple new instances."]
4246 #[doc = r""]
4247 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4248 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4249 #[doc = r" no stolen instances are passed to such software."]
4250 pub unsafe fn steal() -> Self {
4251 Self { _marker: PhantomData }
4252 }
4253}
4254impl Deref for CAN_MO17 {
4255 type Target = can_mo0::RegisterBlock;
4256 #[inline(always)]
4257 fn deref(&self) -> &Self::Target {
4258 unsafe { &*Self::PTR }
4259 }
4260}
4261impl core::fmt::Debug for CAN_MO17 {
4262 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4263 f.debug_struct("CAN_MO17").finish()
4264 }
4265}
4266#[doc = "Controller Area Networks"]
4267pub use self::can_mo0 as can_mo17;
4268#[doc = "Controller Area Networks"]
4269pub struct CAN_MO18 {
4270 _marker: PhantomData<*const ()>,
4271}
4272unsafe impl Send for CAN_MO18 {}
4273impl CAN_MO18 {
4274 #[doc = r"Pointer to the register block"]
4275 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5240 as *const _;
4276 #[doc = r"Return the pointer to the register block"]
4277 #[inline(always)]
4278 pub const fn ptr() -> *const can_mo0::RegisterBlock {
4279 Self::PTR
4280 }
4281 #[doc = r" Steal an instance of this peripheral"]
4282 #[doc = r""]
4283 #[doc = r" # Safety"]
4284 #[doc = r""]
4285 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4286 #[doc = r" that may race with any existing instances, for example by only"]
4287 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4288 #[doc = r" original peripheral and using critical sections to coordinate"]
4289 #[doc = r" access between multiple new instances."]
4290 #[doc = r""]
4291 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4292 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4293 #[doc = r" no stolen instances are passed to such software."]
4294 pub unsafe fn steal() -> Self {
4295 Self { _marker: PhantomData }
4296 }
4297}
4298impl Deref for CAN_MO18 {
4299 type Target = can_mo0::RegisterBlock;
4300 #[inline(always)]
4301 fn deref(&self) -> &Self::Target {
4302 unsafe { &*Self::PTR }
4303 }
4304}
4305impl core::fmt::Debug for CAN_MO18 {
4306 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4307 f.debug_struct("CAN_MO18").finish()
4308 }
4309}
4310#[doc = "Controller Area Networks"]
4311pub use self::can_mo0 as can_mo18;
4312#[doc = "Controller Area Networks"]
4313pub struct CAN_MO19 {
4314 _marker: PhantomData<*const ()>,
4315}
4316unsafe impl Send for CAN_MO19 {}
4317impl CAN_MO19 {
4318 #[doc = r"Pointer to the register block"]
4319 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5260 as *const _;
4320 #[doc = r"Return the pointer to the register block"]
4321 #[inline(always)]
4322 pub const fn ptr() -> *const can_mo0::RegisterBlock {
4323 Self::PTR
4324 }
4325 #[doc = r" Steal an instance of this peripheral"]
4326 #[doc = r""]
4327 #[doc = r" # Safety"]
4328 #[doc = r""]
4329 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4330 #[doc = r" that may race with any existing instances, for example by only"]
4331 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4332 #[doc = r" original peripheral and using critical sections to coordinate"]
4333 #[doc = r" access between multiple new instances."]
4334 #[doc = r""]
4335 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4336 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4337 #[doc = r" no stolen instances are passed to such software."]
4338 pub unsafe fn steal() -> Self {
4339 Self { _marker: PhantomData }
4340 }
4341}
4342impl Deref for CAN_MO19 {
4343 type Target = can_mo0::RegisterBlock;
4344 #[inline(always)]
4345 fn deref(&self) -> &Self::Target {
4346 unsafe { &*Self::PTR }
4347 }
4348}
4349impl core::fmt::Debug for CAN_MO19 {
4350 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4351 f.debug_struct("CAN_MO19").finish()
4352 }
4353}
4354#[doc = "Controller Area Networks"]
4355pub use self::can_mo0 as can_mo19;
4356#[doc = "Controller Area Networks"]
4357pub struct CAN_MO20 {
4358 _marker: PhantomData<*const ()>,
4359}
4360unsafe impl Send for CAN_MO20 {}
4361impl CAN_MO20 {
4362 #[doc = r"Pointer to the register block"]
4363 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5280 as *const _;
4364 #[doc = r"Return the pointer to the register block"]
4365 #[inline(always)]
4366 pub const fn ptr() -> *const can_mo0::RegisterBlock {
4367 Self::PTR
4368 }
4369 #[doc = r" Steal an instance of this peripheral"]
4370 #[doc = r""]
4371 #[doc = r" # Safety"]
4372 #[doc = r""]
4373 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4374 #[doc = r" that may race with any existing instances, for example by only"]
4375 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4376 #[doc = r" original peripheral and using critical sections to coordinate"]
4377 #[doc = r" access between multiple new instances."]
4378 #[doc = r""]
4379 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4380 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4381 #[doc = r" no stolen instances are passed to such software."]
4382 pub unsafe fn steal() -> Self {
4383 Self { _marker: PhantomData }
4384 }
4385}
4386impl Deref for CAN_MO20 {
4387 type Target = can_mo0::RegisterBlock;
4388 #[inline(always)]
4389 fn deref(&self) -> &Self::Target {
4390 unsafe { &*Self::PTR }
4391 }
4392}
4393impl core::fmt::Debug for CAN_MO20 {
4394 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4395 f.debug_struct("CAN_MO20").finish()
4396 }
4397}
4398#[doc = "Controller Area Networks"]
4399pub use self::can_mo0 as can_mo20;
4400#[doc = "Controller Area Networks"]
4401pub struct CAN_MO21 {
4402 _marker: PhantomData<*const ()>,
4403}
4404unsafe impl Send for CAN_MO21 {}
4405impl CAN_MO21 {
4406 #[doc = r"Pointer to the register block"]
4407 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_52a0 as *const _;
4408 #[doc = r"Return the pointer to the register block"]
4409 #[inline(always)]
4410 pub const fn ptr() -> *const can_mo0::RegisterBlock {
4411 Self::PTR
4412 }
4413 #[doc = r" Steal an instance of this peripheral"]
4414 #[doc = r""]
4415 #[doc = r" # Safety"]
4416 #[doc = r""]
4417 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4418 #[doc = r" that may race with any existing instances, for example by only"]
4419 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4420 #[doc = r" original peripheral and using critical sections to coordinate"]
4421 #[doc = r" access between multiple new instances."]
4422 #[doc = r""]
4423 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4424 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4425 #[doc = r" no stolen instances are passed to such software."]
4426 pub unsafe fn steal() -> Self {
4427 Self { _marker: PhantomData }
4428 }
4429}
4430impl Deref for CAN_MO21 {
4431 type Target = can_mo0::RegisterBlock;
4432 #[inline(always)]
4433 fn deref(&self) -> &Self::Target {
4434 unsafe { &*Self::PTR }
4435 }
4436}
4437impl core::fmt::Debug for CAN_MO21 {
4438 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4439 f.debug_struct("CAN_MO21").finish()
4440 }
4441}
4442#[doc = "Controller Area Networks"]
4443pub use self::can_mo0 as can_mo21;
4444#[doc = "Controller Area Networks"]
4445pub struct CAN_MO22 {
4446 _marker: PhantomData<*const ()>,
4447}
4448unsafe impl Send for CAN_MO22 {}
4449impl CAN_MO22 {
4450 #[doc = r"Pointer to the register block"]
4451 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_52c0 as *const _;
4452 #[doc = r"Return the pointer to the register block"]
4453 #[inline(always)]
4454 pub const fn ptr() -> *const can_mo0::RegisterBlock {
4455 Self::PTR
4456 }
4457 #[doc = r" Steal an instance of this peripheral"]
4458 #[doc = r""]
4459 #[doc = r" # Safety"]
4460 #[doc = r""]
4461 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4462 #[doc = r" that may race with any existing instances, for example by only"]
4463 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4464 #[doc = r" original peripheral and using critical sections to coordinate"]
4465 #[doc = r" access between multiple new instances."]
4466 #[doc = r""]
4467 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4468 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4469 #[doc = r" no stolen instances are passed to such software."]
4470 pub unsafe fn steal() -> Self {
4471 Self { _marker: PhantomData }
4472 }
4473}
4474impl Deref for CAN_MO22 {
4475 type Target = can_mo0::RegisterBlock;
4476 #[inline(always)]
4477 fn deref(&self) -> &Self::Target {
4478 unsafe { &*Self::PTR }
4479 }
4480}
4481impl core::fmt::Debug for CAN_MO22 {
4482 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4483 f.debug_struct("CAN_MO22").finish()
4484 }
4485}
4486#[doc = "Controller Area Networks"]
4487pub use self::can_mo0 as can_mo22;
4488#[doc = "Controller Area Networks"]
4489pub struct CAN_MO23 {
4490 _marker: PhantomData<*const ()>,
4491}
4492unsafe impl Send for CAN_MO23 {}
4493impl CAN_MO23 {
4494 #[doc = r"Pointer to the register block"]
4495 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_52e0 as *const _;
4496 #[doc = r"Return the pointer to the register block"]
4497 #[inline(always)]
4498 pub const fn ptr() -> *const can_mo0::RegisterBlock {
4499 Self::PTR
4500 }
4501 #[doc = r" Steal an instance of this peripheral"]
4502 #[doc = r""]
4503 #[doc = r" # Safety"]
4504 #[doc = r""]
4505 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4506 #[doc = r" that may race with any existing instances, for example by only"]
4507 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4508 #[doc = r" original peripheral and using critical sections to coordinate"]
4509 #[doc = r" access between multiple new instances."]
4510 #[doc = r""]
4511 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4512 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4513 #[doc = r" no stolen instances are passed to such software."]
4514 pub unsafe fn steal() -> Self {
4515 Self { _marker: PhantomData }
4516 }
4517}
4518impl Deref for CAN_MO23 {
4519 type Target = can_mo0::RegisterBlock;
4520 #[inline(always)]
4521 fn deref(&self) -> &Self::Target {
4522 unsafe { &*Self::PTR }
4523 }
4524}
4525impl core::fmt::Debug for CAN_MO23 {
4526 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4527 f.debug_struct("CAN_MO23").finish()
4528 }
4529}
4530#[doc = "Controller Area Networks"]
4531pub use self::can_mo0 as can_mo23;
4532#[doc = "Controller Area Networks"]
4533pub struct CAN_MO24 {
4534 _marker: PhantomData<*const ()>,
4535}
4536unsafe impl Send for CAN_MO24 {}
4537impl CAN_MO24 {
4538 #[doc = r"Pointer to the register block"]
4539 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5300 as *const _;
4540 #[doc = r"Return the pointer to the register block"]
4541 #[inline(always)]
4542 pub const fn ptr() -> *const can_mo0::RegisterBlock {
4543 Self::PTR
4544 }
4545 #[doc = r" Steal an instance of this peripheral"]
4546 #[doc = r""]
4547 #[doc = r" # Safety"]
4548 #[doc = r""]
4549 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4550 #[doc = r" that may race with any existing instances, for example by only"]
4551 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4552 #[doc = r" original peripheral and using critical sections to coordinate"]
4553 #[doc = r" access between multiple new instances."]
4554 #[doc = r""]
4555 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4556 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4557 #[doc = r" no stolen instances are passed to such software."]
4558 pub unsafe fn steal() -> Self {
4559 Self { _marker: PhantomData }
4560 }
4561}
4562impl Deref for CAN_MO24 {
4563 type Target = can_mo0::RegisterBlock;
4564 #[inline(always)]
4565 fn deref(&self) -> &Self::Target {
4566 unsafe { &*Self::PTR }
4567 }
4568}
4569impl core::fmt::Debug for CAN_MO24 {
4570 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4571 f.debug_struct("CAN_MO24").finish()
4572 }
4573}
4574#[doc = "Controller Area Networks"]
4575pub use self::can_mo0 as can_mo24;
4576#[doc = "Controller Area Networks"]
4577pub struct CAN_MO25 {
4578 _marker: PhantomData<*const ()>,
4579}
4580unsafe impl Send for CAN_MO25 {}
4581impl CAN_MO25 {
4582 #[doc = r"Pointer to the register block"]
4583 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5320 as *const _;
4584 #[doc = r"Return the pointer to the register block"]
4585 #[inline(always)]
4586 pub const fn ptr() -> *const can_mo0::RegisterBlock {
4587 Self::PTR
4588 }
4589 #[doc = r" Steal an instance of this peripheral"]
4590 #[doc = r""]
4591 #[doc = r" # Safety"]
4592 #[doc = r""]
4593 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4594 #[doc = r" that may race with any existing instances, for example by only"]
4595 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4596 #[doc = r" original peripheral and using critical sections to coordinate"]
4597 #[doc = r" access between multiple new instances."]
4598 #[doc = r""]
4599 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4600 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4601 #[doc = r" no stolen instances are passed to such software."]
4602 pub unsafe fn steal() -> Self {
4603 Self { _marker: PhantomData }
4604 }
4605}
4606impl Deref for CAN_MO25 {
4607 type Target = can_mo0::RegisterBlock;
4608 #[inline(always)]
4609 fn deref(&self) -> &Self::Target {
4610 unsafe { &*Self::PTR }
4611 }
4612}
4613impl core::fmt::Debug for CAN_MO25 {
4614 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4615 f.debug_struct("CAN_MO25").finish()
4616 }
4617}
4618#[doc = "Controller Area Networks"]
4619pub use self::can_mo0 as can_mo25;
4620#[doc = "Controller Area Networks"]
4621pub struct CAN_MO26 {
4622 _marker: PhantomData<*const ()>,
4623}
4624unsafe impl Send for CAN_MO26 {}
4625impl CAN_MO26 {
4626 #[doc = r"Pointer to the register block"]
4627 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5340 as *const _;
4628 #[doc = r"Return the pointer to the register block"]
4629 #[inline(always)]
4630 pub const fn ptr() -> *const can_mo0::RegisterBlock {
4631 Self::PTR
4632 }
4633 #[doc = r" Steal an instance of this peripheral"]
4634 #[doc = r""]
4635 #[doc = r" # Safety"]
4636 #[doc = r""]
4637 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4638 #[doc = r" that may race with any existing instances, for example by only"]
4639 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4640 #[doc = r" original peripheral and using critical sections to coordinate"]
4641 #[doc = r" access between multiple new instances."]
4642 #[doc = r""]
4643 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4644 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4645 #[doc = r" no stolen instances are passed to such software."]
4646 pub unsafe fn steal() -> Self {
4647 Self { _marker: PhantomData }
4648 }
4649}
4650impl Deref for CAN_MO26 {
4651 type Target = can_mo0::RegisterBlock;
4652 #[inline(always)]
4653 fn deref(&self) -> &Self::Target {
4654 unsafe { &*Self::PTR }
4655 }
4656}
4657impl core::fmt::Debug for CAN_MO26 {
4658 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4659 f.debug_struct("CAN_MO26").finish()
4660 }
4661}
4662#[doc = "Controller Area Networks"]
4663pub use self::can_mo0 as can_mo26;
4664#[doc = "Controller Area Networks"]
4665pub struct CAN_MO27 {
4666 _marker: PhantomData<*const ()>,
4667}
4668unsafe impl Send for CAN_MO27 {}
4669impl CAN_MO27 {
4670 #[doc = r"Pointer to the register block"]
4671 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5360 as *const _;
4672 #[doc = r"Return the pointer to the register block"]
4673 #[inline(always)]
4674 pub const fn ptr() -> *const can_mo0::RegisterBlock {
4675 Self::PTR
4676 }
4677 #[doc = r" Steal an instance of this peripheral"]
4678 #[doc = r""]
4679 #[doc = r" # Safety"]
4680 #[doc = r""]
4681 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4682 #[doc = r" that may race with any existing instances, for example by only"]
4683 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4684 #[doc = r" original peripheral and using critical sections to coordinate"]
4685 #[doc = r" access between multiple new instances."]
4686 #[doc = r""]
4687 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4688 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4689 #[doc = r" no stolen instances are passed to such software."]
4690 pub unsafe fn steal() -> Self {
4691 Self { _marker: PhantomData }
4692 }
4693}
4694impl Deref for CAN_MO27 {
4695 type Target = can_mo0::RegisterBlock;
4696 #[inline(always)]
4697 fn deref(&self) -> &Self::Target {
4698 unsafe { &*Self::PTR }
4699 }
4700}
4701impl core::fmt::Debug for CAN_MO27 {
4702 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4703 f.debug_struct("CAN_MO27").finish()
4704 }
4705}
4706#[doc = "Controller Area Networks"]
4707pub use self::can_mo0 as can_mo27;
4708#[doc = "Controller Area Networks"]
4709pub struct CAN_MO28 {
4710 _marker: PhantomData<*const ()>,
4711}
4712unsafe impl Send for CAN_MO28 {}
4713impl CAN_MO28 {
4714 #[doc = r"Pointer to the register block"]
4715 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5380 as *const _;
4716 #[doc = r"Return the pointer to the register block"]
4717 #[inline(always)]
4718 pub const fn ptr() -> *const can_mo0::RegisterBlock {
4719 Self::PTR
4720 }
4721 #[doc = r" Steal an instance of this peripheral"]
4722 #[doc = r""]
4723 #[doc = r" # Safety"]
4724 #[doc = r""]
4725 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4726 #[doc = r" that may race with any existing instances, for example by only"]
4727 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4728 #[doc = r" original peripheral and using critical sections to coordinate"]
4729 #[doc = r" access between multiple new instances."]
4730 #[doc = r""]
4731 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4732 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4733 #[doc = r" no stolen instances are passed to such software."]
4734 pub unsafe fn steal() -> Self {
4735 Self { _marker: PhantomData }
4736 }
4737}
4738impl Deref for CAN_MO28 {
4739 type Target = can_mo0::RegisterBlock;
4740 #[inline(always)]
4741 fn deref(&self) -> &Self::Target {
4742 unsafe { &*Self::PTR }
4743 }
4744}
4745impl core::fmt::Debug for CAN_MO28 {
4746 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4747 f.debug_struct("CAN_MO28").finish()
4748 }
4749}
4750#[doc = "Controller Area Networks"]
4751pub use self::can_mo0 as can_mo28;
4752#[doc = "Controller Area Networks"]
4753pub struct CAN_MO29 {
4754 _marker: PhantomData<*const ()>,
4755}
4756unsafe impl Send for CAN_MO29 {}
4757impl CAN_MO29 {
4758 #[doc = r"Pointer to the register block"]
4759 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_53a0 as *const _;
4760 #[doc = r"Return the pointer to the register block"]
4761 #[inline(always)]
4762 pub const fn ptr() -> *const can_mo0::RegisterBlock {
4763 Self::PTR
4764 }
4765 #[doc = r" Steal an instance of this peripheral"]
4766 #[doc = r""]
4767 #[doc = r" # Safety"]
4768 #[doc = r""]
4769 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4770 #[doc = r" that may race with any existing instances, for example by only"]
4771 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4772 #[doc = r" original peripheral and using critical sections to coordinate"]
4773 #[doc = r" access between multiple new instances."]
4774 #[doc = r""]
4775 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4776 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4777 #[doc = r" no stolen instances are passed to such software."]
4778 pub unsafe fn steal() -> Self {
4779 Self { _marker: PhantomData }
4780 }
4781}
4782impl Deref for CAN_MO29 {
4783 type Target = can_mo0::RegisterBlock;
4784 #[inline(always)]
4785 fn deref(&self) -> &Self::Target {
4786 unsafe { &*Self::PTR }
4787 }
4788}
4789impl core::fmt::Debug for CAN_MO29 {
4790 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4791 f.debug_struct("CAN_MO29").finish()
4792 }
4793}
4794#[doc = "Controller Area Networks"]
4795pub use self::can_mo0 as can_mo29;
4796#[doc = "Controller Area Networks"]
4797pub struct CAN_MO30 {
4798 _marker: PhantomData<*const ()>,
4799}
4800unsafe impl Send for CAN_MO30 {}
4801impl CAN_MO30 {
4802 #[doc = r"Pointer to the register block"]
4803 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_53c0 as *const _;
4804 #[doc = r"Return the pointer to the register block"]
4805 #[inline(always)]
4806 pub const fn ptr() -> *const can_mo0::RegisterBlock {
4807 Self::PTR
4808 }
4809 #[doc = r" Steal an instance of this peripheral"]
4810 #[doc = r""]
4811 #[doc = r" # Safety"]
4812 #[doc = r""]
4813 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4814 #[doc = r" that may race with any existing instances, for example by only"]
4815 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4816 #[doc = r" original peripheral and using critical sections to coordinate"]
4817 #[doc = r" access between multiple new instances."]
4818 #[doc = r""]
4819 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4820 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4821 #[doc = r" no stolen instances are passed to such software."]
4822 pub unsafe fn steal() -> Self {
4823 Self { _marker: PhantomData }
4824 }
4825}
4826impl Deref for CAN_MO30 {
4827 type Target = can_mo0::RegisterBlock;
4828 #[inline(always)]
4829 fn deref(&self) -> &Self::Target {
4830 unsafe { &*Self::PTR }
4831 }
4832}
4833impl core::fmt::Debug for CAN_MO30 {
4834 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4835 f.debug_struct("CAN_MO30").finish()
4836 }
4837}
4838#[doc = "Controller Area Networks"]
4839pub use self::can_mo0 as can_mo30;
4840#[doc = "Controller Area Networks"]
4841pub struct CAN_MO31 {
4842 _marker: PhantomData<*const ()>,
4843}
4844unsafe impl Send for CAN_MO31 {}
4845impl CAN_MO31 {
4846 #[doc = r"Pointer to the register block"]
4847 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_53e0 as *const _;
4848 #[doc = r"Return the pointer to the register block"]
4849 #[inline(always)]
4850 pub const fn ptr() -> *const can_mo0::RegisterBlock {
4851 Self::PTR
4852 }
4853 #[doc = r" Steal an instance of this peripheral"]
4854 #[doc = r""]
4855 #[doc = r" # Safety"]
4856 #[doc = r""]
4857 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4858 #[doc = r" that may race with any existing instances, for example by only"]
4859 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4860 #[doc = r" original peripheral and using critical sections to coordinate"]
4861 #[doc = r" access between multiple new instances."]
4862 #[doc = r""]
4863 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4864 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4865 #[doc = r" no stolen instances are passed to such software."]
4866 pub unsafe fn steal() -> Self {
4867 Self { _marker: PhantomData }
4868 }
4869}
4870impl Deref for CAN_MO31 {
4871 type Target = can_mo0::RegisterBlock;
4872 #[inline(always)]
4873 fn deref(&self) -> &Self::Target {
4874 unsafe { &*Self::PTR }
4875 }
4876}
4877impl core::fmt::Debug for CAN_MO31 {
4878 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4879 f.debug_struct("CAN_MO31").finish()
4880 }
4881}
4882#[doc = "Controller Area Networks"]
4883pub use self::can_mo0 as can_mo31;
4884#[doc = "Controller Area Networks"]
4885pub struct CAN_MO32 {
4886 _marker: PhantomData<*const ()>,
4887}
4888unsafe impl Send for CAN_MO32 {}
4889impl CAN_MO32 {
4890 #[doc = r"Pointer to the register block"]
4891 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5400 as *const _;
4892 #[doc = r"Return the pointer to the register block"]
4893 #[inline(always)]
4894 pub const fn ptr() -> *const can_mo0::RegisterBlock {
4895 Self::PTR
4896 }
4897 #[doc = r" Steal an instance of this peripheral"]
4898 #[doc = r""]
4899 #[doc = r" # Safety"]
4900 #[doc = r""]
4901 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4902 #[doc = r" that may race with any existing instances, for example by only"]
4903 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4904 #[doc = r" original peripheral and using critical sections to coordinate"]
4905 #[doc = r" access between multiple new instances."]
4906 #[doc = r""]
4907 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4908 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4909 #[doc = r" no stolen instances are passed to such software."]
4910 pub unsafe fn steal() -> Self {
4911 Self { _marker: PhantomData }
4912 }
4913}
4914impl Deref for CAN_MO32 {
4915 type Target = can_mo0::RegisterBlock;
4916 #[inline(always)]
4917 fn deref(&self) -> &Self::Target {
4918 unsafe { &*Self::PTR }
4919 }
4920}
4921impl core::fmt::Debug for CAN_MO32 {
4922 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4923 f.debug_struct("CAN_MO32").finish()
4924 }
4925}
4926#[doc = "Controller Area Networks"]
4927pub use self::can_mo0 as can_mo32;
4928#[doc = "Controller Area Networks"]
4929pub struct CAN_MO33 {
4930 _marker: PhantomData<*const ()>,
4931}
4932unsafe impl Send for CAN_MO33 {}
4933impl CAN_MO33 {
4934 #[doc = r"Pointer to the register block"]
4935 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5420 as *const _;
4936 #[doc = r"Return the pointer to the register block"]
4937 #[inline(always)]
4938 pub const fn ptr() -> *const can_mo0::RegisterBlock {
4939 Self::PTR
4940 }
4941 #[doc = r" Steal an instance of this peripheral"]
4942 #[doc = r""]
4943 #[doc = r" # Safety"]
4944 #[doc = r""]
4945 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4946 #[doc = r" that may race with any existing instances, for example by only"]
4947 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4948 #[doc = r" original peripheral and using critical sections to coordinate"]
4949 #[doc = r" access between multiple new instances."]
4950 #[doc = r""]
4951 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4952 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4953 #[doc = r" no stolen instances are passed to such software."]
4954 pub unsafe fn steal() -> Self {
4955 Self { _marker: PhantomData }
4956 }
4957}
4958impl Deref for CAN_MO33 {
4959 type Target = can_mo0::RegisterBlock;
4960 #[inline(always)]
4961 fn deref(&self) -> &Self::Target {
4962 unsafe { &*Self::PTR }
4963 }
4964}
4965impl core::fmt::Debug for CAN_MO33 {
4966 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4967 f.debug_struct("CAN_MO33").finish()
4968 }
4969}
4970#[doc = "Controller Area Networks"]
4971pub use self::can_mo0 as can_mo33;
4972#[doc = "Controller Area Networks"]
4973pub struct CAN_MO34 {
4974 _marker: PhantomData<*const ()>,
4975}
4976unsafe impl Send for CAN_MO34 {}
4977impl CAN_MO34 {
4978 #[doc = r"Pointer to the register block"]
4979 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5440 as *const _;
4980 #[doc = r"Return the pointer to the register block"]
4981 #[inline(always)]
4982 pub const fn ptr() -> *const can_mo0::RegisterBlock {
4983 Self::PTR
4984 }
4985 #[doc = r" Steal an instance of this peripheral"]
4986 #[doc = r""]
4987 #[doc = r" # Safety"]
4988 #[doc = r""]
4989 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4990 #[doc = r" that may race with any existing instances, for example by only"]
4991 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4992 #[doc = r" original peripheral and using critical sections to coordinate"]
4993 #[doc = r" access between multiple new instances."]
4994 #[doc = r""]
4995 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4996 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4997 #[doc = r" no stolen instances are passed to such software."]
4998 pub unsafe fn steal() -> Self {
4999 Self { _marker: PhantomData }
5000 }
5001}
5002impl Deref for CAN_MO34 {
5003 type Target = can_mo0::RegisterBlock;
5004 #[inline(always)]
5005 fn deref(&self) -> &Self::Target {
5006 unsafe { &*Self::PTR }
5007 }
5008}
5009impl core::fmt::Debug for CAN_MO34 {
5010 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5011 f.debug_struct("CAN_MO34").finish()
5012 }
5013}
5014#[doc = "Controller Area Networks"]
5015pub use self::can_mo0 as can_mo34;
5016#[doc = "Controller Area Networks"]
5017pub struct CAN_MO35 {
5018 _marker: PhantomData<*const ()>,
5019}
5020unsafe impl Send for CAN_MO35 {}
5021impl CAN_MO35 {
5022 #[doc = r"Pointer to the register block"]
5023 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5460 as *const _;
5024 #[doc = r"Return the pointer to the register block"]
5025 #[inline(always)]
5026 pub const fn ptr() -> *const can_mo0::RegisterBlock {
5027 Self::PTR
5028 }
5029 #[doc = r" Steal an instance of this peripheral"]
5030 #[doc = r""]
5031 #[doc = r" # Safety"]
5032 #[doc = r""]
5033 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5034 #[doc = r" that may race with any existing instances, for example by only"]
5035 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5036 #[doc = r" original peripheral and using critical sections to coordinate"]
5037 #[doc = r" access between multiple new instances."]
5038 #[doc = r""]
5039 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5040 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5041 #[doc = r" no stolen instances are passed to such software."]
5042 pub unsafe fn steal() -> Self {
5043 Self { _marker: PhantomData }
5044 }
5045}
5046impl Deref for CAN_MO35 {
5047 type Target = can_mo0::RegisterBlock;
5048 #[inline(always)]
5049 fn deref(&self) -> &Self::Target {
5050 unsafe { &*Self::PTR }
5051 }
5052}
5053impl core::fmt::Debug for CAN_MO35 {
5054 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5055 f.debug_struct("CAN_MO35").finish()
5056 }
5057}
5058#[doc = "Controller Area Networks"]
5059pub use self::can_mo0 as can_mo35;
5060#[doc = "Controller Area Networks"]
5061pub struct CAN_MO36 {
5062 _marker: PhantomData<*const ()>,
5063}
5064unsafe impl Send for CAN_MO36 {}
5065impl CAN_MO36 {
5066 #[doc = r"Pointer to the register block"]
5067 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5480 as *const _;
5068 #[doc = r"Return the pointer to the register block"]
5069 #[inline(always)]
5070 pub const fn ptr() -> *const can_mo0::RegisterBlock {
5071 Self::PTR
5072 }
5073 #[doc = r" Steal an instance of this peripheral"]
5074 #[doc = r""]
5075 #[doc = r" # Safety"]
5076 #[doc = r""]
5077 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5078 #[doc = r" that may race with any existing instances, for example by only"]
5079 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5080 #[doc = r" original peripheral and using critical sections to coordinate"]
5081 #[doc = r" access between multiple new instances."]
5082 #[doc = r""]
5083 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5084 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5085 #[doc = r" no stolen instances are passed to such software."]
5086 pub unsafe fn steal() -> Self {
5087 Self { _marker: PhantomData }
5088 }
5089}
5090impl Deref for CAN_MO36 {
5091 type Target = can_mo0::RegisterBlock;
5092 #[inline(always)]
5093 fn deref(&self) -> &Self::Target {
5094 unsafe { &*Self::PTR }
5095 }
5096}
5097impl core::fmt::Debug for CAN_MO36 {
5098 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5099 f.debug_struct("CAN_MO36").finish()
5100 }
5101}
5102#[doc = "Controller Area Networks"]
5103pub use self::can_mo0 as can_mo36;
5104#[doc = "Controller Area Networks"]
5105pub struct CAN_MO37 {
5106 _marker: PhantomData<*const ()>,
5107}
5108unsafe impl Send for CAN_MO37 {}
5109impl CAN_MO37 {
5110 #[doc = r"Pointer to the register block"]
5111 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_54a0 as *const _;
5112 #[doc = r"Return the pointer to the register block"]
5113 #[inline(always)]
5114 pub const fn ptr() -> *const can_mo0::RegisterBlock {
5115 Self::PTR
5116 }
5117 #[doc = r" Steal an instance of this peripheral"]
5118 #[doc = r""]
5119 #[doc = r" # Safety"]
5120 #[doc = r""]
5121 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5122 #[doc = r" that may race with any existing instances, for example by only"]
5123 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5124 #[doc = r" original peripheral and using critical sections to coordinate"]
5125 #[doc = r" access between multiple new instances."]
5126 #[doc = r""]
5127 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5128 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5129 #[doc = r" no stolen instances are passed to such software."]
5130 pub unsafe fn steal() -> Self {
5131 Self { _marker: PhantomData }
5132 }
5133}
5134impl Deref for CAN_MO37 {
5135 type Target = can_mo0::RegisterBlock;
5136 #[inline(always)]
5137 fn deref(&self) -> &Self::Target {
5138 unsafe { &*Self::PTR }
5139 }
5140}
5141impl core::fmt::Debug for CAN_MO37 {
5142 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5143 f.debug_struct("CAN_MO37").finish()
5144 }
5145}
5146#[doc = "Controller Area Networks"]
5147pub use self::can_mo0 as can_mo37;
5148#[doc = "Controller Area Networks"]
5149pub struct CAN_MO38 {
5150 _marker: PhantomData<*const ()>,
5151}
5152unsafe impl Send for CAN_MO38 {}
5153impl CAN_MO38 {
5154 #[doc = r"Pointer to the register block"]
5155 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_54c0 as *const _;
5156 #[doc = r"Return the pointer to the register block"]
5157 #[inline(always)]
5158 pub const fn ptr() -> *const can_mo0::RegisterBlock {
5159 Self::PTR
5160 }
5161 #[doc = r" Steal an instance of this peripheral"]
5162 #[doc = r""]
5163 #[doc = r" # Safety"]
5164 #[doc = r""]
5165 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5166 #[doc = r" that may race with any existing instances, for example by only"]
5167 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5168 #[doc = r" original peripheral and using critical sections to coordinate"]
5169 #[doc = r" access between multiple new instances."]
5170 #[doc = r""]
5171 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5172 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5173 #[doc = r" no stolen instances are passed to such software."]
5174 pub unsafe fn steal() -> Self {
5175 Self { _marker: PhantomData }
5176 }
5177}
5178impl Deref for CAN_MO38 {
5179 type Target = can_mo0::RegisterBlock;
5180 #[inline(always)]
5181 fn deref(&self) -> &Self::Target {
5182 unsafe { &*Self::PTR }
5183 }
5184}
5185impl core::fmt::Debug for CAN_MO38 {
5186 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5187 f.debug_struct("CAN_MO38").finish()
5188 }
5189}
5190#[doc = "Controller Area Networks"]
5191pub use self::can_mo0 as can_mo38;
5192#[doc = "Controller Area Networks"]
5193pub struct CAN_MO39 {
5194 _marker: PhantomData<*const ()>,
5195}
5196unsafe impl Send for CAN_MO39 {}
5197impl CAN_MO39 {
5198 #[doc = r"Pointer to the register block"]
5199 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_54e0 as *const _;
5200 #[doc = r"Return the pointer to the register block"]
5201 #[inline(always)]
5202 pub const fn ptr() -> *const can_mo0::RegisterBlock {
5203 Self::PTR
5204 }
5205 #[doc = r" Steal an instance of this peripheral"]
5206 #[doc = r""]
5207 #[doc = r" # Safety"]
5208 #[doc = r""]
5209 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5210 #[doc = r" that may race with any existing instances, for example by only"]
5211 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5212 #[doc = r" original peripheral and using critical sections to coordinate"]
5213 #[doc = r" access between multiple new instances."]
5214 #[doc = r""]
5215 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5216 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5217 #[doc = r" no stolen instances are passed to such software."]
5218 pub unsafe fn steal() -> Self {
5219 Self { _marker: PhantomData }
5220 }
5221}
5222impl Deref for CAN_MO39 {
5223 type Target = can_mo0::RegisterBlock;
5224 #[inline(always)]
5225 fn deref(&self) -> &Self::Target {
5226 unsafe { &*Self::PTR }
5227 }
5228}
5229impl core::fmt::Debug for CAN_MO39 {
5230 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5231 f.debug_struct("CAN_MO39").finish()
5232 }
5233}
5234#[doc = "Controller Area Networks"]
5235pub use self::can_mo0 as can_mo39;
5236#[doc = "Controller Area Networks"]
5237pub struct CAN_MO40 {
5238 _marker: PhantomData<*const ()>,
5239}
5240unsafe impl Send for CAN_MO40 {}
5241impl CAN_MO40 {
5242 #[doc = r"Pointer to the register block"]
5243 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5500 as *const _;
5244 #[doc = r"Return the pointer to the register block"]
5245 #[inline(always)]
5246 pub const fn ptr() -> *const can_mo0::RegisterBlock {
5247 Self::PTR
5248 }
5249 #[doc = r" Steal an instance of this peripheral"]
5250 #[doc = r""]
5251 #[doc = r" # Safety"]
5252 #[doc = r""]
5253 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5254 #[doc = r" that may race with any existing instances, for example by only"]
5255 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5256 #[doc = r" original peripheral and using critical sections to coordinate"]
5257 #[doc = r" access between multiple new instances."]
5258 #[doc = r""]
5259 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5260 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5261 #[doc = r" no stolen instances are passed to such software."]
5262 pub unsafe fn steal() -> Self {
5263 Self { _marker: PhantomData }
5264 }
5265}
5266impl Deref for CAN_MO40 {
5267 type Target = can_mo0::RegisterBlock;
5268 #[inline(always)]
5269 fn deref(&self) -> &Self::Target {
5270 unsafe { &*Self::PTR }
5271 }
5272}
5273impl core::fmt::Debug for CAN_MO40 {
5274 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5275 f.debug_struct("CAN_MO40").finish()
5276 }
5277}
5278#[doc = "Controller Area Networks"]
5279pub use self::can_mo0 as can_mo40;
5280#[doc = "Controller Area Networks"]
5281pub struct CAN_MO41 {
5282 _marker: PhantomData<*const ()>,
5283}
5284unsafe impl Send for CAN_MO41 {}
5285impl CAN_MO41 {
5286 #[doc = r"Pointer to the register block"]
5287 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5520 as *const _;
5288 #[doc = r"Return the pointer to the register block"]
5289 #[inline(always)]
5290 pub const fn ptr() -> *const can_mo0::RegisterBlock {
5291 Self::PTR
5292 }
5293 #[doc = r" Steal an instance of this peripheral"]
5294 #[doc = r""]
5295 #[doc = r" # Safety"]
5296 #[doc = r""]
5297 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5298 #[doc = r" that may race with any existing instances, for example by only"]
5299 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5300 #[doc = r" original peripheral and using critical sections to coordinate"]
5301 #[doc = r" access between multiple new instances."]
5302 #[doc = r""]
5303 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5304 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5305 #[doc = r" no stolen instances are passed to such software."]
5306 pub unsafe fn steal() -> Self {
5307 Self { _marker: PhantomData }
5308 }
5309}
5310impl Deref for CAN_MO41 {
5311 type Target = can_mo0::RegisterBlock;
5312 #[inline(always)]
5313 fn deref(&self) -> &Self::Target {
5314 unsafe { &*Self::PTR }
5315 }
5316}
5317impl core::fmt::Debug for CAN_MO41 {
5318 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5319 f.debug_struct("CAN_MO41").finish()
5320 }
5321}
5322#[doc = "Controller Area Networks"]
5323pub use self::can_mo0 as can_mo41;
5324#[doc = "Controller Area Networks"]
5325pub struct CAN_MO42 {
5326 _marker: PhantomData<*const ()>,
5327}
5328unsafe impl Send for CAN_MO42 {}
5329impl CAN_MO42 {
5330 #[doc = r"Pointer to the register block"]
5331 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5540 as *const _;
5332 #[doc = r"Return the pointer to the register block"]
5333 #[inline(always)]
5334 pub const fn ptr() -> *const can_mo0::RegisterBlock {
5335 Self::PTR
5336 }
5337 #[doc = r" Steal an instance of this peripheral"]
5338 #[doc = r""]
5339 #[doc = r" # Safety"]
5340 #[doc = r""]
5341 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5342 #[doc = r" that may race with any existing instances, for example by only"]
5343 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5344 #[doc = r" original peripheral and using critical sections to coordinate"]
5345 #[doc = r" access between multiple new instances."]
5346 #[doc = r""]
5347 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5348 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5349 #[doc = r" no stolen instances are passed to such software."]
5350 pub unsafe fn steal() -> Self {
5351 Self { _marker: PhantomData }
5352 }
5353}
5354impl Deref for CAN_MO42 {
5355 type Target = can_mo0::RegisterBlock;
5356 #[inline(always)]
5357 fn deref(&self) -> &Self::Target {
5358 unsafe { &*Self::PTR }
5359 }
5360}
5361impl core::fmt::Debug for CAN_MO42 {
5362 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5363 f.debug_struct("CAN_MO42").finish()
5364 }
5365}
5366#[doc = "Controller Area Networks"]
5367pub use self::can_mo0 as can_mo42;
5368#[doc = "Controller Area Networks"]
5369pub struct CAN_MO43 {
5370 _marker: PhantomData<*const ()>,
5371}
5372unsafe impl Send for CAN_MO43 {}
5373impl CAN_MO43 {
5374 #[doc = r"Pointer to the register block"]
5375 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5560 as *const _;
5376 #[doc = r"Return the pointer to the register block"]
5377 #[inline(always)]
5378 pub const fn ptr() -> *const can_mo0::RegisterBlock {
5379 Self::PTR
5380 }
5381 #[doc = r" Steal an instance of this peripheral"]
5382 #[doc = r""]
5383 #[doc = r" # Safety"]
5384 #[doc = r""]
5385 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5386 #[doc = r" that may race with any existing instances, for example by only"]
5387 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5388 #[doc = r" original peripheral and using critical sections to coordinate"]
5389 #[doc = r" access between multiple new instances."]
5390 #[doc = r""]
5391 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5392 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5393 #[doc = r" no stolen instances are passed to such software."]
5394 pub unsafe fn steal() -> Self {
5395 Self { _marker: PhantomData }
5396 }
5397}
5398impl Deref for CAN_MO43 {
5399 type Target = can_mo0::RegisterBlock;
5400 #[inline(always)]
5401 fn deref(&self) -> &Self::Target {
5402 unsafe { &*Self::PTR }
5403 }
5404}
5405impl core::fmt::Debug for CAN_MO43 {
5406 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5407 f.debug_struct("CAN_MO43").finish()
5408 }
5409}
5410#[doc = "Controller Area Networks"]
5411pub use self::can_mo0 as can_mo43;
5412#[doc = "Controller Area Networks"]
5413pub struct CAN_MO44 {
5414 _marker: PhantomData<*const ()>,
5415}
5416unsafe impl Send for CAN_MO44 {}
5417impl CAN_MO44 {
5418 #[doc = r"Pointer to the register block"]
5419 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5580 as *const _;
5420 #[doc = r"Return the pointer to the register block"]
5421 #[inline(always)]
5422 pub const fn ptr() -> *const can_mo0::RegisterBlock {
5423 Self::PTR
5424 }
5425 #[doc = r" Steal an instance of this peripheral"]
5426 #[doc = r""]
5427 #[doc = r" # Safety"]
5428 #[doc = r""]
5429 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5430 #[doc = r" that may race with any existing instances, for example by only"]
5431 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5432 #[doc = r" original peripheral and using critical sections to coordinate"]
5433 #[doc = r" access between multiple new instances."]
5434 #[doc = r""]
5435 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5436 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5437 #[doc = r" no stolen instances are passed to such software."]
5438 pub unsafe fn steal() -> Self {
5439 Self { _marker: PhantomData }
5440 }
5441}
5442impl Deref for CAN_MO44 {
5443 type Target = can_mo0::RegisterBlock;
5444 #[inline(always)]
5445 fn deref(&self) -> &Self::Target {
5446 unsafe { &*Self::PTR }
5447 }
5448}
5449impl core::fmt::Debug for CAN_MO44 {
5450 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5451 f.debug_struct("CAN_MO44").finish()
5452 }
5453}
5454#[doc = "Controller Area Networks"]
5455pub use self::can_mo0 as can_mo44;
5456#[doc = "Controller Area Networks"]
5457pub struct CAN_MO45 {
5458 _marker: PhantomData<*const ()>,
5459}
5460unsafe impl Send for CAN_MO45 {}
5461impl CAN_MO45 {
5462 #[doc = r"Pointer to the register block"]
5463 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_55a0 as *const _;
5464 #[doc = r"Return the pointer to the register block"]
5465 #[inline(always)]
5466 pub const fn ptr() -> *const can_mo0::RegisterBlock {
5467 Self::PTR
5468 }
5469 #[doc = r" Steal an instance of this peripheral"]
5470 #[doc = r""]
5471 #[doc = r" # Safety"]
5472 #[doc = r""]
5473 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5474 #[doc = r" that may race with any existing instances, for example by only"]
5475 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5476 #[doc = r" original peripheral and using critical sections to coordinate"]
5477 #[doc = r" access between multiple new instances."]
5478 #[doc = r""]
5479 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5480 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5481 #[doc = r" no stolen instances are passed to such software."]
5482 pub unsafe fn steal() -> Self {
5483 Self { _marker: PhantomData }
5484 }
5485}
5486impl Deref for CAN_MO45 {
5487 type Target = can_mo0::RegisterBlock;
5488 #[inline(always)]
5489 fn deref(&self) -> &Self::Target {
5490 unsafe { &*Self::PTR }
5491 }
5492}
5493impl core::fmt::Debug for CAN_MO45 {
5494 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5495 f.debug_struct("CAN_MO45").finish()
5496 }
5497}
5498#[doc = "Controller Area Networks"]
5499pub use self::can_mo0 as can_mo45;
5500#[doc = "Controller Area Networks"]
5501pub struct CAN_MO46 {
5502 _marker: PhantomData<*const ()>,
5503}
5504unsafe impl Send for CAN_MO46 {}
5505impl CAN_MO46 {
5506 #[doc = r"Pointer to the register block"]
5507 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_55c0 as *const _;
5508 #[doc = r"Return the pointer to the register block"]
5509 #[inline(always)]
5510 pub const fn ptr() -> *const can_mo0::RegisterBlock {
5511 Self::PTR
5512 }
5513 #[doc = r" Steal an instance of this peripheral"]
5514 #[doc = r""]
5515 #[doc = r" # Safety"]
5516 #[doc = r""]
5517 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5518 #[doc = r" that may race with any existing instances, for example by only"]
5519 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5520 #[doc = r" original peripheral and using critical sections to coordinate"]
5521 #[doc = r" access between multiple new instances."]
5522 #[doc = r""]
5523 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5524 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5525 #[doc = r" no stolen instances are passed to such software."]
5526 pub unsafe fn steal() -> Self {
5527 Self { _marker: PhantomData }
5528 }
5529}
5530impl Deref for CAN_MO46 {
5531 type Target = can_mo0::RegisterBlock;
5532 #[inline(always)]
5533 fn deref(&self) -> &Self::Target {
5534 unsafe { &*Self::PTR }
5535 }
5536}
5537impl core::fmt::Debug for CAN_MO46 {
5538 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5539 f.debug_struct("CAN_MO46").finish()
5540 }
5541}
5542#[doc = "Controller Area Networks"]
5543pub use self::can_mo0 as can_mo46;
5544#[doc = "Controller Area Networks"]
5545pub struct CAN_MO47 {
5546 _marker: PhantomData<*const ()>,
5547}
5548unsafe impl Send for CAN_MO47 {}
5549impl CAN_MO47 {
5550 #[doc = r"Pointer to the register block"]
5551 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_55e0 as *const _;
5552 #[doc = r"Return the pointer to the register block"]
5553 #[inline(always)]
5554 pub const fn ptr() -> *const can_mo0::RegisterBlock {
5555 Self::PTR
5556 }
5557 #[doc = r" Steal an instance of this peripheral"]
5558 #[doc = r""]
5559 #[doc = r" # Safety"]
5560 #[doc = r""]
5561 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5562 #[doc = r" that may race with any existing instances, for example by only"]
5563 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5564 #[doc = r" original peripheral and using critical sections to coordinate"]
5565 #[doc = r" access between multiple new instances."]
5566 #[doc = r""]
5567 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5568 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5569 #[doc = r" no stolen instances are passed to such software."]
5570 pub unsafe fn steal() -> Self {
5571 Self { _marker: PhantomData }
5572 }
5573}
5574impl Deref for CAN_MO47 {
5575 type Target = can_mo0::RegisterBlock;
5576 #[inline(always)]
5577 fn deref(&self) -> &Self::Target {
5578 unsafe { &*Self::PTR }
5579 }
5580}
5581impl core::fmt::Debug for CAN_MO47 {
5582 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5583 f.debug_struct("CAN_MO47").finish()
5584 }
5585}
5586#[doc = "Controller Area Networks"]
5587pub use self::can_mo0 as can_mo47;
5588#[doc = "Controller Area Networks"]
5589pub struct CAN_MO48 {
5590 _marker: PhantomData<*const ()>,
5591}
5592unsafe impl Send for CAN_MO48 {}
5593impl CAN_MO48 {
5594 #[doc = r"Pointer to the register block"]
5595 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5600 as *const _;
5596 #[doc = r"Return the pointer to the register block"]
5597 #[inline(always)]
5598 pub const fn ptr() -> *const can_mo0::RegisterBlock {
5599 Self::PTR
5600 }
5601 #[doc = r" Steal an instance of this peripheral"]
5602 #[doc = r""]
5603 #[doc = r" # Safety"]
5604 #[doc = r""]
5605 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5606 #[doc = r" that may race with any existing instances, for example by only"]
5607 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5608 #[doc = r" original peripheral and using critical sections to coordinate"]
5609 #[doc = r" access between multiple new instances."]
5610 #[doc = r""]
5611 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5612 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5613 #[doc = r" no stolen instances are passed to such software."]
5614 pub unsafe fn steal() -> Self {
5615 Self { _marker: PhantomData }
5616 }
5617}
5618impl Deref for CAN_MO48 {
5619 type Target = can_mo0::RegisterBlock;
5620 #[inline(always)]
5621 fn deref(&self) -> &Self::Target {
5622 unsafe { &*Self::PTR }
5623 }
5624}
5625impl core::fmt::Debug for CAN_MO48 {
5626 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5627 f.debug_struct("CAN_MO48").finish()
5628 }
5629}
5630#[doc = "Controller Area Networks"]
5631pub use self::can_mo0 as can_mo48;
5632#[doc = "Controller Area Networks"]
5633pub struct CAN_MO49 {
5634 _marker: PhantomData<*const ()>,
5635}
5636unsafe impl Send for CAN_MO49 {}
5637impl CAN_MO49 {
5638 #[doc = r"Pointer to the register block"]
5639 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5620 as *const _;
5640 #[doc = r"Return the pointer to the register block"]
5641 #[inline(always)]
5642 pub const fn ptr() -> *const can_mo0::RegisterBlock {
5643 Self::PTR
5644 }
5645 #[doc = r" Steal an instance of this peripheral"]
5646 #[doc = r""]
5647 #[doc = r" # Safety"]
5648 #[doc = r""]
5649 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5650 #[doc = r" that may race with any existing instances, for example by only"]
5651 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5652 #[doc = r" original peripheral and using critical sections to coordinate"]
5653 #[doc = r" access between multiple new instances."]
5654 #[doc = r""]
5655 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5656 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5657 #[doc = r" no stolen instances are passed to such software."]
5658 pub unsafe fn steal() -> Self {
5659 Self { _marker: PhantomData }
5660 }
5661}
5662impl Deref for CAN_MO49 {
5663 type Target = can_mo0::RegisterBlock;
5664 #[inline(always)]
5665 fn deref(&self) -> &Self::Target {
5666 unsafe { &*Self::PTR }
5667 }
5668}
5669impl core::fmt::Debug for CAN_MO49 {
5670 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5671 f.debug_struct("CAN_MO49").finish()
5672 }
5673}
5674#[doc = "Controller Area Networks"]
5675pub use self::can_mo0 as can_mo49;
5676#[doc = "Controller Area Networks"]
5677pub struct CAN_MO50 {
5678 _marker: PhantomData<*const ()>,
5679}
5680unsafe impl Send for CAN_MO50 {}
5681impl CAN_MO50 {
5682 #[doc = r"Pointer to the register block"]
5683 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5640 as *const _;
5684 #[doc = r"Return the pointer to the register block"]
5685 #[inline(always)]
5686 pub const fn ptr() -> *const can_mo0::RegisterBlock {
5687 Self::PTR
5688 }
5689 #[doc = r" Steal an instance of this peripheral"]
5690 #[doc = r""]
5691 #[doc = r" # Safety"]
5692 #[doc = r""]
5693 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5694 #[doc = r" that may race with any existing instances, for example by only"]
5695 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5696 #[doc = r" original peripheral and using critical sections to coordinate"]
5697 #[doc = r" access between multiple new instances."]
5698 #[doc = r""]
5699 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5700 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5701 #[doc = r" no stolen instances are passed to such software."]
5702 pub unsafe fn steal() -> Self {
5703 Self { _marker: PhantomData }
5704 }
5705}
5706impl Deref for CAN_MO50 {
5707 type Target = can_mo0::RegisterBlock;
5708 #[inline(always)]
5709 fn deref(&self) -> &Self::Target {
5710 unsafe { &*Self::PTR }
5711 }
5712}
5713impl core::fmt::Debug for CAN_MO50 {
5714 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5715 f.debug_struct("CAN_MO50").finish()
5716 }
5717}
5718#[doc = "Controller Area Networks"]
5719pub use self::can_mo0 as can_mo50;
5720#[doc = "Controller Area Networks"]
5721pub struct CAN_MO51 {
5722 _marker: PhantomData<*const ()>,
5723}
5724unsafe impl Send for CAN_MO51 {}
5725impl CAN_MO51 {
5726 #[doc = r"Pointer to the register block"]
5727 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5660 as *const _;
5728 #[doc = r"Return the pointer to the register block"]
5729 #[inline(always)]
5730 pub const fn ptr() -> *const can_mo0::RegisterBlock {
5731 Self::PTR
5732 }
5733 #[doc = r" Steal an instance of this peripheral"]
5734 #[doc = r""]
5735 #[doc = r" # Safety"]
5736 #[doc = r""]
5737 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5738 #[doc = r" that may race with any existing instances, for example by only"]
5739 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5740 #[doc = r" original peripheral and using critical sections to coordinate"]
5741 #[doc = r" access between multiple new instances."]
5742 #[doc = r""]
5743 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5744 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5745 #[doc = r" no stolen instances are passed to such software."]
5746 pub unsafe fn steal() -> Self {
5747 Self { _marker: PhantomData }
5748 }
5749}
5750impl Deref for CAN_MO51 {
5751 type Target = can_mo0::RegisterBlock;
5752 #[inline(always)]
5753 fn deref(&self) -> &Self::Target {
5754 unsafe { &*Self::PTR }
5755 }
5756}
5757impl core::fmt::Debug for CAN_MO51 {
5758 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5759 f.debug_struct("CAN_MO51").finish()
5760 }
5761}
5762#[doc = "Controller Area Networks"]
5763pub use self::can_mo0 as can_mo51;
5764#[doc = "Controller Area Networks"]
5765pub struct CAN_MO52 {
5766 _marker: PhantomData<*const ()>,
5767}
5768unsafe impl Send for CAN_MO52 {}
5769impl CAN_MO52 {
5770 #[doc = r"Pointer to the register block"]
5771 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5680 as *const _;
5772 #[doc = r"Return the pointer to the register block"]
5773 #[inline(always)]
5774 pub const fn ptr() -> *const can_mo0::RegisterBlock {
5775 Self::PTR
5776 }
5777 #[doc = r" Steal an instance of this peripheral"]
5778 #[doc = r""]
5779 #[doc = r" # Safety"]
5780 #[doc = r""]
5781 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5782 #[doc = r" that may race with any existing instances, for example by only"]
5783 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5784 #[doc = r" original peripheral and using critical sections to coordinate"]
5785 #[doc = r" access between multiple new instances."]
5786 #[doc = r""]
5787 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5788 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5789 #[doc = r" no stolen instances are passed to such software."]
5790 pub unsafe fn steal() -> Self {
5791 Self { _marker: PhantomData }
5792 }
5793}
5794impl Deref for CAN_MO52 {
5795 type Target = can_mo0::RegisterBlock;
5796 #[inline(always)]
5797 fn deref(&self) -> &Self::Target {
5798 unsafe { &*Self::PTR }
5799 }
5800}
5801impl core::fmt::Debug for CAN_MO52 {
5802 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5803 f.debug_struct("CAN_MO52").finish()
5804 }
5805}
5806#[doc = "Controller Area Networks"]
5807pub use self::can_mo0 as can_mo52;
5808#[doc = "Controller Area Networks"]
5809pub struct CAN_MO53 {
5810 _marker: PhantomData<*const ()>,
5811}
5812unsafe impl Send for CAN_MO53 {}
5813impl CAN_MO53 {
5814 #[doc = r"Pointer to the register block"]
5815 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_56a0 as *const _;
5816 #[doc = r"Return the pointer to the register block"]
5817 #[inline(always)]
5818 pub const fn ptr() -> *const can_mo0::RegisterBlock {
5819 Self::PTR
5820 }
5821 #[doc = r" Steal an instance of this peripheral"]
5822 #[doc = r""]
5823 #[doc = r" # Safety"]
5824 #[doc = r""]
5825 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5826 #[doc = r" that may race with any existing instances, for example by only"]
5827 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5828 #[doc = r" original peripheral and using critical sections to coordinate"]
5829 #[doc = r" access between multiple new instances."]
5830 #[doc = r""]
5831 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5832 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5833 #[doc = r" no stolen instances are passed to such software."]
5834 pub unsafe fn steal() -> Self {
5835 Self { _marker: PhantomData }
5836 }
5837}
5838impl Deref for CAN_MO53 {
5839 type Target = can_mo0::RegisterBlock;
5840 #[inline(always)]
5841 fn deref(&self) -> &Self::Target {
5842 unsafe { &*Self::PTR }
5843 }
5844}
5845impl core::fmt::Debug for CAN_MO53 {
5846 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5847 f.debug_struct("CAN_MO53").finish()
5848 }
5849}
5850#[doc = "Controller Area Networks"]
5851pub use self::can_mo0 as can_mo53;
5852#[doc = "Controller Area Networks"]
5853pub struct CAN_MO54 {
5854 _marker: PhantomData<*const ()>,
5855}
5856unsafe impl Send for CAN_MO54 {}
5857impl CAN_MO54 {
5858 #[doc = r"Pointer to the register block"]
5859 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_56c0 as *const _;
5860 #[doc = r"Return the pointer to the register block"]
5861 #[inline(always)]
5862 pub const fn ptr() -> *const can_mo0::RegisterBlock {
5863 Self::PTR
5864 }
5865 #[doc = r" Steal an instance of this peripheral"]
5866 #[doc = r""]
5867 #[doc = r" # Safety"]
5868 #[doc = r""]
5869 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5870 #[doc = r" that may race with any existing instances, for example by only"]
5871 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5872 #[doc = r" original peripheral and using critical sections to coordinate"]
5873 #[doc = r" access between multiple new instances."]
5874 #[doc = r""]
5875 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5876 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5877 #[doc = r" no stolen instances are passed to such software."]
5878 pub unsafe fn steal() -> Self {
5879 Self { _marker: PhantomData }
5880 }
5881}
5882impl Deref for CAN_MO54 {
5883 type Target = can_mo0::RegisterBlock;
5884 #[inline(always)]
5885 fn deref(&self) -> &Self::Target {
5886 unsafe { &*Self::PTR }
5887 }
5888}
5889impl core::fmt::Debug for CAN_MO54 {
5890 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5891 f.debug_struct("CAN_MO54").finish()
5892 }
5893}
5894#[doc = "Controller Area Networks"]
5895pub use self::can_mo0 as can_mo54;
5896#[doc = "Controller Area Networks"]
5897pub struct CAN_MO55 {
5898 _marker: PhantomData<*const ()>,
5899}
5900unsafe impl Send for CAN_MO55 {}
5901impl CAN_MO55 {
5902 #[doc = r"Pointer to the register block"]
5903 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_56e0 as *const _;
5904 #[doc = r"Return the pointer to the register block"]
5905 #[inline(always)]
5906 pub const fn ptr() -> *const can_mo0::RegisterBlock {
5907 Self::PTR
5908 }
5909 #[doc = r" Steal an instance of this peripheral"]
5910 #[doc = r""]
5911 #[doc = r" # Safety"]
5912 #[doc = r""]
5913 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5914 #[doc = r" that may race with any existing instances, for example by only"]
5915 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5916 #[doc = r" original peripheral and using critical sections to coordinate"]
5917 #[doc = r" access between multiple new instances."]
5918 #[doc = r""]
5919 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5920 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5921 #[doc = r" no stolen instances are passed to such software."]
5922 pub unsafe fn steal() -> Self {
5923 Self { _marker: PhantomData }
5924 }
5925}
5926impl Deref for CAN_MO55 {
5927 type Target = can_mo0::RegisterBlock;
5928 #[inline(always)]
5929 fn deref(&self) -> &Self::Target {
5930 unsafe { &*Self::PTR }
5931 }
5932}
5933impl core::fmt::Debug for CAN_MO55 {
5934 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5935 f.debug_struct("CAN_MO55").finish()
5936 }
5937}
5938#[doc = "Controller Area Networks"]
5939pub use self::can_mo0 as can_mo55;
5940#[doc = "Controller Area Networks"]
5941pub struct CAN_MO56 {
5942 _marker: PhantomData<*const ()>,
5943}
5944unsafe impl Send for CAN_MO56 {}
5945impl CAN_MO56 {
5946 #[doc = r"Pointer to the register block"]
5947 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5700 as *const _;
5948 #[doc = r"Return the pointer to the register block"]
5949 #[inline(always)]
5950 pub const fn ptr() -> *const can_mo0::RegisterBlock {
5951 Self::PTR
5952 }
5953 #[doc = r" Steal an instance of this peripheral"]
5954 #[doc = r""]
5955 #[doc = r" # Safety"]
5956 #[doc = r""]
5957 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5958 #[doc = r" that may race with any existing instances, for example by only"]
5959 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5960 #[doc = r" original peripheral and using critical sections to coordinate"]
5961 #[doc = r" access between multiple new instances."]
5962 #[doc = r""]
5963 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5964 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5965 #[doc = r" no stolen instances are passed to such software."]
5966 pub unsafe fn steal() -> Self {
5967 Self { _marker: PhantomData }
5968 }
5969}
5970impl Deref for CAN_MO56 {
5971 type Target = can_mo0::RegisterBlock;
5972 #[inline(always)]
5973 fn deref(&self) -> &Self::Target {
5974 unsafe { &*Self::PTR }
5975 }
5976}
5977impl core::fmt::Debug for CAN_MO56 {
5978 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5979 f.debug_struct("CAN_MO56").finish()
5980 }
5981}
5982#[doc = "Controller Area Networks"]
5983pub use self::can_mo0 as can_mo56;
5984#[doc = "Controller Area Networks"]
5985pub struct CAN_MO57 {
5986 _marker: PhantomData<*const ()>,
5987}
5988unsafe impl Send for CAN_MO57 {}
5989impl CAN_MO57 {
5990 #[doc = r"Pointer to the register block"]
5991 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5720 as *const _;
5992 #[doc = r"Return the pointer to the register block"]
5993 #[inline(always)]
5994 pub const fn ptr() -> *const can_mo0::RegisterBlock {
5995 Self::PTR
5996 }
5997 #[doc = r" Steal an instance of this peripheral"]
5998 #[doc = r""]
5999 #[doc = r" # Safety"]
6000 #[doc = r""]
6001 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6002 #[doc = r" that may race with any existing instances, for example by only"]
6003 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6004 #[doc = r" original peripheral and using critical sections to coordinate"]
6005 #[doc = r" access between multiple new instances."]
6006 #[doc = r""]
6007 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6008 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6009 #[doc = r" no stolen instances are passed to such software."]
6010 pub unsafe fn steal() -> Self {
6011 Self { _marker: PhantomData }
6012 }
6013}
6014impl Deref for CAN_MO57 {
6015 type Target = can_mo0::RegisterBlock;
6016 #[inline(always)]
6017 fn deref(&self) -> &Self::Target {
6018 unsafe { &*Self::PTR }
6019 }
6020}
6021impl core::fmt::Debug for CAN_MO57 {
6022 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6023 f.debug_struct("CAN_MO57").finish()
6024 }
6025}
6026#[doc = "Controller Area Networks"]
6027pub use self::can_mo0 as can_mo57;
6028#[doc = "Controller Area Networks"]
6029pub struct CAN_MO58 {
6030 _marker: PhantomData<*const ()>,
6031}
6032unsafe impl Send for CAN_MO58 {}
6033impl CAN_MO58 {
6034 #[doc = r"Pointer to the register block"]
6035 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5740 as *const _;
6036 #[doc = r"Return the pointer to the register block"]
6037 #[inline(always)]
6038 pub const fn ptr() -> *const can_mo0::RegisterBlock {
6039 Self::PTR
6040 }
6041 #[doc = r" Steal an instance of this peripheral"]
6042 #[doc = r""]
6043 #[doc = r" # Safety"]
6044 #[doc = r""]
6045 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6046 #[doc = r" that may race with any existing instances, for example by only"]
6047 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6048 #[doc = r" original peripheral and using critical sections to coordinate"]
6049 #[doc = r" access between multiple new instances."]
6050 #[doc = r""]
6051 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6052 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6053 #[doc = r" no stolen instances are passed to such software."]
6054 pub unsafe fn steal() -> Self {
6055 Self { _marker: PhantomData }
6056 }
6057}
6058impl Deref for CAN_MO58 {
6059 type Target = can_mo0::RegisterBlock;
6060 #[inline(always)]
6061 fn deref(&self) -> &Self::Target {
6062 unsafe { &*Self::PTR }
6063 }
6064}
6065impl core::fmt::Debug for CAN_MO58 {
6066 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6067 f.debug_struct("CAN_MO58").finish()
6068 }
6069}
6070#[doc = "Controller Area Networks"]
6071pub use self::can_mo0 as can_mo58;
6072#[doc = "Controller Area Networks"]
6073pub struct CAN_MO59 {
6074 _marker: PhantomData<*const ()>,
6075}
6076unsafe impl Send for CAN_MO59 {}
6077impl CAN_MO59 {
6078 #[doc = r"Pointer to the register block"]
6079 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5760 as *const _;
6080 #[doc = r"Return the pointer to the register block"]
6081 #[inline(always)]
6082 pub const fn ptr() -> *const can_mo0::RegisterBlock {
6083 Self::PTR
6084 }
6085 #[doc = r" Steal an instance of this peripheral"]
6086 #[doc = r""]
6087 #[doc = r" # Safety"]
6088 #[doc = r""]
6089 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6090 #[doc = r" that may race with any existing instances, for example by only"]
6091 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6092 #[doc = r" original peripheral and using critical sections to coordinate"]
6093 #[doc = r" access between multiple new instances."]
6094 #[doc = r""]
6095 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6096 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6097 #[doc = r" no stolen instances are passed to such software."]
6098 pub unsafe fn steal() -> Self {
6099 Self { _marker: PhantomData }
6100 }
6101}
6102impl Deref for CAN_MO59 {
6103 type Target = can_mo0::RegisterBlock;
6104 #[inline(always)]
6105 fn deref(&self) -> &Self::Target {
6106 unsafe { &*Self::PTR }
6107 }
6108}
6109impl core::fmt::Debug for CAN_MO59 {
6110 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6111 f.debug_struct("CAN_MO59").finish()
6112 }
6113}
6114#[doc = "Controller Area Networks"]
6115pub use self::can_mo0 as can_mo59;
6116#[doc = "Controller Area Networks"]
6117pub struct CAN_MO60 {
6118 _marker: PhantomData<*const ()>,
6119}
6120unsafe impl Send for CAN_MO60 {}
6121impl CAN_MO60 {
6122 #[doc = r"Pointer to the register block"]
6123 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_5780 as *const _;
6124 #[doc = r"Return the pointer to the register block"]
6125 #[inline(always)]
6126 pub const fn ptr() -> *const can_mo0::RegisterBlock {
6127 Self::PTR
6128 }
6129 #[doc = r" Steal an instance of this peripheral"]
6130 #[doc = r""]
6131 #[doc = r" # Safety"]
6132 #[doc = r""]
6133 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6134 #[doc = r" that may race with any existing instances, for example by only"]
6135 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6136 #[doc = r" original peripheral and using critical sections to coordinate"]
6137 #[doc = r" access between multiple new instances."]
6138 #[doc = r""]
6139 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6140 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6141 #[doc = r" no stolen instances are passed to such software."]
6142 pub unsafe fn steal() -> Self {
6143 Self { _marker: PhantomData }
6144 }
6145}
6146impl Deref for CAN_MO60 {
6147 type Target = can_mo0::RegisterBlock;
6148 #[inline(always)]
6149 fn deref(&self) -> &Self::Target {
6150 unsafe { &*Self::PTR }
6151 }
6152}
6153impl core::fmt::Debug for CAN_MO60 {
6154 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6155 f.debug_struct("CAN_MO60").finish()
6156 }
6157}
6158#[doc = "Controller Area Networks"]
6159pub use self::can_mo0 as can_mo60;
6160#[doc = "Controller Area Networks"]
6161pub struct CAN_MO61 {
6162 _marker: PhantomData<*const ()>,
6163}
6164unsafe impl Send for CAN_MO61 {}
6165impl CAN_MO61 {
6166 #[doc = r"Pointer to the register block"]
6167 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_57a0 as *const _;
6168 #[doc = r"Return the pointer to the register block"]
6169 #[inline(always)]
6170 pub const fn ptr() -> *const can_mo0::RegisterBlock {
6171 Self::PTR
6172 }
6173 #[doc = r" Steal an instance of this peripheral"]
6174 #[doc = r""]
6175 #[doc = r" # Safety"]
6176 #[doc = r""]
6177 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6178 #[doc = r" that may race with any existing instances, for example by only"]
6179 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6180 #[doc = r" original peripheral and using critical sections to coordinate"]
6181 #[doc = r" access between multiple new instances."]
6182 #[doc = r""]
6183 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6184 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6185 #[doc = r" no stolen instances are passed to such software."]
6186 pub unsafe fn steal() -> Self {
6187 Self { _marker: PhantomData }
6188 }
6189}
6190impl Deref for CAN_MO61 {
6191 type Target = can_mo0::RegisterBlock;
6192 #[inline(always)]
6193 fn deref(&self) -> &Self::Target {
6194 unsafe { &*Self::PTR }
6195 }
6196}
6197impl core::fmt::Debug for CAN_MO61 {
6198 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6199 f.debug_struct("CAN_MO61").finish()
6200 }
6201}
6202#[doc = "Controller Area Networks"]
6203pub use self::can_mo0 as can_mo61;
6204#[doc = "Controller Area Networks"]
6205pub struct CAN_MO62 {
6206 _marker: PhantomData<*const ()>,
6207}
6208unsafe impl Send for CAN_MO62 {}
6209impl CAN_MO62 {
6210 #[doc = r"Pointer to the register block"]
6211 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_57c0 as *const _;
6212 #[doc = r"Return the pointer to the register block"]
6213 #[inline(always)]
6214 pub const fn ptr() -> *const can_mo0::RegisterBlock {
6215 Self::PTR
6216 }
6217 #[doc = r" Steal an instance of this peripheral"]
6218 #[doc = r""]
6219 #[doc = r" # Safety"]
6220 #[doc = r""]
6221 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6222 #[doc = r" that may race with any existing instances, for example by only"]
6223 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6224 #[doc = r" original peripheral and using critical sections to coordinate"]
6225 #[doc = r" access between multiple new instances."]
6226 #[doc = r""]
6227 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6228 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6229 #[doc = r" no stolen instances are passed to such software."]
6230 pub unsafe fn steal() -> Self {
6231 Self { _marker: PhantomData }
6232 }
6233}
6234impl Deref for CAN_MO62 {
6235 type Target = can_mo0::RegisterBlock;
6236 #[inline(always)]
6237 fn deref(&self) -> &Self::Target {
6238 unsafe { &*Self::PTR }
6239 }
6240}
6241impl core::fmt::Debug for CAN_MO62 {
6242 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6243 f.debug_struct("CAN_MO62").finish()
6244 }
6245}
6246#[doc = "Controller Area Networks"]
6247pub use self::can_mo0 as can_mo62;
6248#[doc = "Controller Area Networks"]
6249pub struct CAN_MO63 {
6250 _marker: PhantomData<*const ()>,
6251}
6252unsafe impl Send for CAN_MO63 {}
6253impl CAN_MO63 {
6254 #[doc = r"Pointer to the register block"]
6255 pub const PTR: *const can_mo0::RegisterBlock = 0x4801_57e0 as *const _;
6256 #[doc = r"Return the pointer to the register block"]
6257 #[inline(always)]
6258 pub const fn ptr() -> *const can_mo0::RegisterBlock {
6259 Self::PTR
6260 }
6261 #[doc = r" Steal an instance of this peripheral"]
6262 #[doc = r""]
6263 #[doc = r" # Safety"]
6264 #[doc = r""]
6265 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6266 #[doc = r" that may race with any existing instances, for example by only"]
6267 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6268 #[doc = r" original peripheral and using critical sections to coordinate"]
6269 #[doc = r" access between multiple new instances."]
6270 #[doc = r""]
6271 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6272 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6273 #[doc = r" no stolen instances are passed to such software."]
6274 pub unsafe fn steal() -> Self {
6275 Self { _marker: PhantomData }
6276 }
6277}
6278impl Deref for CAN_MO63 {
6279 type Target = can_mo0::RegisterBlock;
6280 #[inline(always)]
6281 fn deref(&self) -> &Self::Target {
6282 unsafe { &*Self::PTR }
6283 }
6284}
6285impl core::fmt::Debug for CAN_MO63 {
6286 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6287 f.debug_struct("CAN_MO63").finish()
6288 }
6289}
6290#[doc = "Controller Area Networks"]
6291pub use self::can_mo0 as can_mo63;
6292#[doc = "Analog to Digital Converter"]
6293pub struct VADC {
6294 _marker: PhantomData<*const ()>,
6295}
6296unsafe impl Send for VADC {}
6297impl VADC {
6298 #[doc = r"Pointer to the register block"]
6299 pub const PTR: *const vadc::RegisterBlock = 0x4000_4000 as *const _;
6300 #[doc = r"Return the pointer to the register block"]
6301 #[inline(always)]
6302 pub const fn ptr() -> *const vadc::RegisterBlock {
6303 Self::PTR
6304 }
6305 #[doc = r" Steal an instance of this peripheral"]
6306 #[doc = r""]
6307 #[doc = r" # Safety"]
6308 #[doc = r""]
6309 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6310 #[doc = r" that may race with any existing instances, for example by only"]
6311 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6312 #[doc = r" original peripheral and using critical sections to coordinate"]
6313 #[doc = r" access between multiple new instances."]
6314 #[doc = r""]
6315 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6316 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6317 #[doc = r" no stolen instances are passed to such software."]
6318 pub unsafe fn steal() -> Self {
6319 Self { _marker: PhantomData }
6320 }
6321}
6322impl Deref for VADC {
6323 type Target = vadc::RegisterBlock;
6324 #[inline(always)]
6325 fn deref(&self) -> &Self::Target {
6326 unsafe { &*Self::PTR }
6327 }
6328}
6329impl core::fmt::Debug for VADC {
6330 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6331 f.debug_struct("VADC").finish()
6332 }
6333}
6334#[doc = "Analog to Digital Converter"]
6335pub mod vadc;
6336#[doc = "Analog to Digital Converter"]
6337pub struct VADC_G0 {
6338 _marker: PhantomData<*const ()>,
6339}
6340unsafe impl Send for VADC_G0 {}
6341impl VADC_G0 {
6342 #[doc = r"Pointer to the register block"]
6343 pub const PTR: *const vadc_g0::RegisterBlock = 0x4000_4400 as *const _;
6344 #[doc = r"Return the pointer to the register block"]
6345 #[inline(always)]
6346 pub const fn ptr() -> *const vadc_g0::RegisterBlock {
6347 Self::PTR
6348 }
6349 #[doc = r" Steal an instance of this peripheral"]
6350 #[doc = r""]
6351 #[doc = r" # Safety"]
6352 #[doc = r""]
6353 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6354 #[doc = r" that may race with any existing instances, for example by only"]
6355 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6356 #[doc = r" original peripheral and using critical sections to coordinate"]
6357 #[doc = r" access between multiple new instances."]
6358 #[doc = r""]
6359 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6360 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6361 #[doc = r" no stolen instances are passed to such software."]
6362 pub unsafe fn steal() -> Self {
6363 Self { _marker: PhantomData }
6364 }
6365}
6366impl Deref for VADC_G0 {
6367 type Target = vadc_g0::RegisterBlock;
6368 #[inline(always)]
6369 fn deref(&self) -> &Self::Target {
6370 unsafe { &*Self::PTR }
6371 }
6372}
6373impl core::fmt::Debug for VADC_G0 {
6374 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6375 f.debug_struct("VADC_G0").finish()
6376 }
6377}
6378#[doc = "Analog to Digital Converter"]
6379pub mod vadc_g0;
6380#[doc = "Analog to Digital Converter"]
6381pub struct VADC_G1 {
6382 _marker: PhantomData<*const ()>,
6383}
6384unsafe impl Send for VADC_G1 {}
6385impl VADC_G1 {
6386 #[doc = r"Pointer to the register block"]
6387 pub const PTR: *const vadc_g0::RegisterBlock = 0x4000_4800 as *const _;
6388 #[doc = r"Return the pointer to the register block"]
6389 #[inline(always)]
6390 pub const fn ptr() -> *const vadc_g0::RegisterBlock {
6391 Self::PTR
6392 }
6393 #[doc = r" Steal an instance of this peripheral"]
6394 #[doc = r""]
6395 #[doc = r" # Safety"]
6396 #[doc = r""]
6397 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6398 #[doc = r" that may race with any existing instances, for example by only"]
6399 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6400 #[doc = r" original peripheral and using critical sections to coordinate"]
6401 #[doc = r" access between multiple new instances."]
6402 #[doc = r""]
6403 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6404 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6405 #[doc = r" no stolen instances are passed to such software."]
6406 pub unsafe fn steal() -> Self {
6407 Self { _marker: PhantomData }
6408 }
6409}
6410impl Deref for VADC_G1 {
6411 type Target = vadc_g0::RegisterBlock;
6412 #[inline(always)]
6413 fn deref(&self) -> &Self::Target {
6414 unsafe { &*Self::PTR }
6415 }
6416}
6417impl core::fmt::Debug for VADC_G1 {
6418 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6419 f.debug_struct("VADC_G1").finish()
6420 }
6421}
6422#[doc = "Analog to Digital Converter"]
6423pub use self::vadc_g0 as vadc_g1;
6424#[doc = "Analog to Digital Converter"]
6425pub struct VADC_G2 {
6426 _marker: PhantomData<*const ()>,
6427}
6428unsafe impl Send for VADC_G2 {}
6429impl VADC_G2 {
6430 #[doc = r"Pointer to the register block"]
6431 pub const PTR: *const vadc_g0::RegisterBlock = 0x4000_4c00 as *const _;
6432 #[doc = r"Return the pointer to the register block"]
6433 #[inline(always)]
6434 pub const fn ptr() -> *const vadc_g0::RegisterBlock {
6435 Self::PTR
6436 }
6437 #[doc = r" Steal an instance of this peripheral"]
6438 #[doc = r""]
6439 #[doc = r" # Safety"]
6440 #[doc = r""]
6441 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6442 #[doc = r" that may race with any existing instances, for example by only"]
6443 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6444 #[doc = r" original peripheral and using critical sections to coordinate"]
6445 #[doc = r" access between multiple new instances."]
6446 #[doc = r""]
6447 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6448 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6449 #[doc = r" no stolen instances are passed to such software."]
6450 pub unsafe fn steal() -> Self {
6451 Self { _marker: PhantomData }
6452 }
6453}
6454impl Deref for VADC_G2 {
6455 type Target = vadc_g0::RegisterBlock;
6456 #[inline(always)]
6457 fn deref(&self) -> &Self::Target {
6458 unsafe { &*Self::PTR }
6459 }
6460}
6461impl core::fmt::Debug for VADC_G2 {
6462 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6463 f.debug_struct("VADC_G2").finish()
6464 }
6465}
6466#[doc = "Analog to Digital Converter"]
6467pub use self::vadc_g0 as vadc_g2;
6468#[doc = "Analog to Digital Converter"]
6469pub struct VADC_G3 {
6470 _marker: PhantomData<*const ()>,
6471}
6472unsafe impl Send for VADC_G3 {}
6473impl VADC_G3 {
6474 #[doc = r"Pointer to the register block"]
6475 pub const PTR: *const vadc_g0::RegisterBlock = 0x4000_5000 as *const _;
6476 #[doc = r"Return the pointer to the register block"]
6477 #[inline(always)]
6478 pub const fn ptr() -> *const vadc_g0::RegisterBlock {
6479 Self::PTR
6480 }
6481 #[doc = r" Steal an instance of this peripheral"]
6482 #[doc = r""]
6483 #[doc = r" # Safety"]
6484 #[doc = r""]
6485 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6486 #[doc = r" that may race with any existing instances, for example by only"]
6487 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6488 #[doc = r" original peripheral and using critical sections to coordinate"]
6489 #[doc = r" access between multiple new instances."]
6490 #[doc = r""]
6491 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6492 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6493 #[doc = r" no stolen instances are passed to such software."]
6494 pub unsafe fn steal() -> Self {
6495 Self { _marker: PhantomData }
6496 }
6497}
6498impl Deref for VADC_G3 {
6499 type Target = vadc_g0::RegisterBlock;
6500 #[inline(always)]
6501 fn deref(&self) -> &Self::Target {
6502 unsafe { &*Self::PTR }
6503 }
6504}
6505impl core::fmt::Debug for VADC_G3 {
6506 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6507 f.debug_struct("VADC_G3").finish()
6508 }
6509}
6510#[doc = "Analog to Digital Converter"]
6511pub use self::vadc_g0 as vadc_g3;
6512#[doc = "Delta Sigma Demodulator"]
6513pub struct DSD {
6514 _marker: PhantomData<*const ()>,
6515}
6516unsafe impl Send for DSD {}
6517impl DSD {
6518 #[doc = r"Pointer to the register block"]
6519 pub const PTR: *const dsd::RegisterBlock = 0x4000_8000 as *const _;
6520 #[doc = r"Return the pointer to the register block"]
6521 #[inline(always)]
6522 pub const fn ptr() -> *const dsd::RegisterBlock {
6523 Self::PTR
6524 }
6525 #[doc = r" Steal an instance of this peripheral"]
6526 #[doc = r""]
6527 #[doc = r" # Safety"]
6528 #[doc = r""]
6529 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6530 #[doc = r" that may race with any existing instances, for example by only"]
6531 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6532 #[doc = r" original peripheral and using critical sections to coordinate"]
6533 #[doc = r" access between multiple new instances."]
6534 #[doc = r""]
6535 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6536 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6537 #[doc = r" no stolen instances are passed to such software."]
6538 pub unsafe fn steal() -> Self {
6539 Self { _marker: PhantomData }
6540 }
6541}
6542impl Deref for DSD {
6543 type Target = dsd::RegisterBlock;
6544 #[inline(always)]
6545 fn deref(&self) -> &Self::Target {
6546 unsafe { &*Self::PTR }
6547 }
6548}
6549impl core::fmt::Debug for DSD {
6550 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6551 f.debug_struct("DSD").finish()
6552 }
6553}
6554#[doc = "Delta Sigma Demodulator"]
6555pub mod dsd;
6556#[doc = "Delta Sigma Demodulator"]
6557pub struct DSD_CH0 {
6558 _marker: PhantomData<*const ()>,
6559}
6560unsafe impl Send for DSD_CH0 {}
6561impl DSD_CH0 {
6562 #[doc = r"Pointer to the register block"]
6563 pub const PTR: *const dsd_ch0::RegisterBlock = 0x4000_8100 as *const _;
6564 #[doc = r"Return the pointer to the register block"]
6565 #[inline(always)]
6566 pub const fn ptr() -> *const dsd_ch0::RegisterBlock {
6567 Self::PTR
6568 }
6569 #[doc = r" Steal an instance of this peripheral"]
6570 #[doc = r""]
6571 #[doc = r" # Safety"]
6572 #[doc = r""]
6573 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6574 #[doc = r" that may race with any existing instances, for example by only"]
6575 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6576 #[doc = r" original peripheral and using critical sections to coordinate"]
6577 #[doc = r" access between multiple new instances."]
6578 #[doc = r""]
6579 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6580 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6581 #[doc = r" no stolen instances are passed to such software."]
6582 pub unsafe fn steal() -> Self {
6583 Self { _marker: PhantomData }
6584 }
6585}
6586impl Deref for DSD_CH0 {
6587 type Target = dsd_ch0::RegisterBlock;
6588 #[inline(always)]
6589 fn deref(&self) -> &Self::Target {
6590 unsafe { &*Self::PTR }
6591 }
6592}
6593impl core::fmt::Debug for DSD_CH0 {
6594 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6595 f.debug_struct("DSD_CH0").finish()
6596 }
6597}
6598#[doc = "Delta Sigma Demodulator"]
6599pub mod dsd_ch0;
6600#[doc = "Delta Sigma Demodulator"]
6601pub struct DSD_CH1 {
6602 _marker: PhantomData<*const ()>,
6603}
6604unsafe impl Send for DSD_CH1 {}
6605impl DSD_CH1 {
6606 #[doc = r"Pointer to the register block"]
6607 pub const PTR: *const dsd_ch0::RegisterBlock = 0x4000_8200 as *const _;
6608 #[doc = r"Return the pointer to the register block"]
6609 #[inline(always)]
6610 pub const fn ptr() -> *const dsd_ch0::RegisterBlock {
6611 Self::PTR
6612 }
6613 #[doc = r" Steal an instance of this peripheral"]
6614 #[doc = r""]
6615 #[doc = r" # Safety"]
6616 #[doc = r""]
6617 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6618 #[doc = r" that may race with any existing instances, for example by only"]
6619 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6620 #[doc = r" original peripheral and using critical sections to coordinate"]
6621 #[doc = r" access between multiple new instances."]
6622 #[doc = r""]
6623 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6624 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6625 #[doc = r" no stolen instances are passed to such software."]
6626 pub unsafe fn steal() -> Self {
6627 Self { _marker: PhantomData }
6628 }
6629}
6630impl Deref for DSD_CH1 {
6631 type Target = dsd_ch0::RegisterBlock;
6632 #[inline(always)]
6633 fn deref(&self) -> &Self::Target {
6634 unsafe { &*Self::PTR }
6635 }
6636}
6637impl core::fmt::Debug for DSD_CH1 {
6638 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6639 f.debug_struct("DSD_CH1").finish()
6640 }
6641}
6642#[doc = "Delta Sigma Demodulator"]
6643pub use self::dsd_ch0 as dsd_ch1;
6644#[doc = "Delta Sigma Demodulator"]
6645pub struct DSD_CH2 {
6646 _marker: PhantomData<*const ()>,
6647}
6648unsafe impl Send for DSD_CH2 {}
6649impl DSD_CH2 {
6650 #[doc = r"Pointer to the register block"]
6651 pub const PTR: *const dsd_ch0::RegisterBlock = 0x4000_8300 as *const _;
6652 #[doc = r"Return the pointer to the register block"]
6653 #[inline(always)]
6654 pub const fn ptr() -> *const dsd_ch0::RegisterBlock {
6655 Self::PTR
6656 }
6657 #[doc = r" Steal an instance of this peripheral"]
6658 #[doc = r""]
6659 #[doc = r" # Safety"]
6660 #[doc = r""]
6661 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6662 #[doc = r" that may race with any existing instances, for example by only"]
6663 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6664 #[doc = r" original peripheral and using critical sections to coordinate"]
6665 #[doc = r" access between multiple new instances."]
6666 #[doc = r""]
6667 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6668 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6669 #[doc = r" no stolen instances are passed to such software."]
6670 pub unsafe fn steal() -> Self {
6671 Self { _marker: PhantomData }
6672 }
6673}
6674impl Deref for DSD_CH2 {
6675 type Target = dsd_ch0::RegisterBlock;
6676 #[inline(always)]
6677 fn deref(&self) -> &Self::Target {
6678 unsafe { &*Self::PTR }
6679 }
6680}
6681impl core::fmt::Debug for DSD_CH2 {
6682 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6683 f.debug_struct("DSD_CH2").finish()
6684 }
6685}
6686#[doc = "Delta Sigma Demodulator"]
6687pub use self::dsd_ch0 as dsd_ch2;
6688#[doc = "Delta Sigma Demodulator"]
6689pub struct DSD_CH3 {
6690 _marker: PhantomData<*const ()>,
6691}
6692unsafe impl Send for DSD_CH3 {}
6693impl DSD_CH3 {
6694 #[doc = r"Pointer to the register block"]
6695 pub const PTR: *const dsd_ch0::RegisterBlock = 0x4000_8400 as *const _;
6696 #[doc = r"Return the pointer to the register block"]
6697 #[inline(always)]
6698 pub const fn ptr() -> *const dsd_ch0::RegisterBlock {
6699 Self::PTR
6700 }
6701 #[doc = r" Steal an instance of this peripheral"]
6702 #[doc = r""]
6703 #[doc = r" # Safety"]
6704 #[doc = r""]
6705 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6706 #[doc = r" that may race with any existing instances, for example by only"]
6707 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6708 #[doc = r" original peripheral and using critical sections to coordinate"]
6709 #[doc = r" access between multiple new instances."]
6710 #[doc = r""]
6711 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6712 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6713 #[doc = r" no stolen instances are passed to such software."]
6714 pub unsafe fn steal() -> Self {
6715 Self { _marker: PhantomData }
6716 }
6717}
6718impl Deref for DSD_CH3 {
6719 type Target = dsd_ch0::RegisterBlock;
6720 #[inline(always)]
6721 fn deref(&self) -> &Self::Target {
6722 unsafe { &*Self::PTR }
6723 }
6724}
6725impl core::fmt::Debug for DSD_CH3 {
6726 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6727 f.debug_struct("DSD_CH3").finish()
6728 }
6729}
6730#[doc = "Delta Sigma Demodulator"]
6731pub use self::dsd_ch0 as dsd_ch3;
6732#[doc = "Digital to Analog Converter"]
6733pub struct DAC {
6734 _marker: PhantomData<*const ()>,
6735}
6736unsafe impl Send for DAC {}
6737impl DAC {
6738 #[doc = r"Pointer to the register block"]
6739 pub const PTR: *const dac::RegisterBlock = 0x4801_8000 as *const _;
6740 #[doc = r"Return the pointer to the register block"]
6741 #[inline(always)]
6742 pub const fn ptr() -> *const dac::RegisterBlock {
6743 Self::PTR
6744 }
6745 #[doc = r" Steal an instance of this peripheral"]
6746 #[doc = r""]
6747 #[doc = r" # Safety"]
6748 #[doc = r""]
6749 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6750 #[doc = r" that may race with any existing instances, for example by only"]
6751 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6752 #[doc = r" original peripheral and using critical sections to coordinate"]
6753 #[doc = r" access between multiple new instances."]
6754 #[doc = r""]
6755 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6756 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6757 #[doc = r" no stolen instances are passed to such software."]
6758 pub unsafe fn steal() -> Self {
6759 Self { _marker: PhantomData }
6760 }
6761}
6762impl Deref for DAC {
6763 type Target = dac::RegisterBlock;
6764 #[inline(always)]
6765 fn deref(&self) -> &Self::Target {
6766 unsafe { &*Self::PTR }
6767 }
6768}
6769impl core::fmt::Debug for DAC {
6770 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6771 f.debug_struct("DAC").finish()
6772 }
6773}
6774#[doc = "Digital to Analog Converter"]
6775pub mod dac;
6776#[doc = "Capture Compare Unit 4 - Unit 0"]
6777pub struct CCU40 {
6778 _marker: PhantomData<*const ()>,
6779}
6780unsafe impl Send for CCU40 {}
6781impl CCU40 {
6782 #[doc = r"Pointer to the register block"]
6783 pub const PTR: *const ccu40::RegisterBlock = 0x4000_c000 as *const _;
6784 #[doc = r"Return the pointer to the register block"]
6785 #[inline(always)]
6786 pub const fn ptr() -> *const ccu40::RegisterBlock {
6787 Self::PTR
6788 }
6789 #[doc = r" Steal an instance of this peripheral"]
6790 #[doc = r""]
6791 #[doc = r" # Safety"]
6792 #[doc = r""]
6793 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6794 #[doc = r" that may race with any existing instances, for example by only"]
6795 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6796 #[doc = r" original peripheral and using critical sections to coordinate"]
6797 #[doc = r" access between multiple new instances."]
6798 #[doc = r""]
6799 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6800 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6801 #[doc = r" no stolen instances are passed to such software."]
6802 pub unsafe fn steal() -> Self {
6803 Self { _marker: PhantomData }
6804 }
6805}
6806impl Deref for CCU40 {
6807 type Target = ccu40::RegisterBlock;
6808 #[inline(always)]
6809 fn deref(&self) -> &Self::Target {
6810 unsafe { &*Self::PTR }
6811 }
6812}
6813impl core::fmt::Debug for CCU40 {
6814 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6815 f.debug_struct("CCU40").finish()
6816 }
6817}
6818#[doc = "Capture Compare Unit 4 - Unit 0"]
6819pub mod ccu40;
6820#[doc = "Capture Compare Unit 4 - Unit 1"]
6821pub struct CCU41 {
6822 _marker: PhantomData<*const ()>,
6823}
6824unsafe impl Send for CCU41 {}
6825impl CCU41 {
6826 #[doc = r"Pointer to the register block"]
6827 pub const PTR: *const ccu40::RegisterBlock = 0x4001_0000 as *const _;
6828 #[doc = r"Return the pointer to the register block"]
6829 #[inline(always)]
6830 pub const fn ptr() -> *const ccu40::RegisterBlock {
6831 Self::PTR
6832 }
6833 #[doc = r" Steal an instance of this peripheral"]
6834 #[doc = r""]
6835 #[doc = r" # Safety"]
6836 #[doc = r""]
6837 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6838 #[doc = r" that may race with any existing instances, for example by only"]
6839 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6840 #[doc = r" original peripheral and using critical sections to coordinate"]
6841 #[doc = r" access between multiple new instances."]
6842 #[doc = r""]
6843 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6844 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6845 #[doc = r" no stolen instances are passed to such software."]
6846 pub unsafe fn steal() -> Self {
6847 Self { _marker: PhantomData }
6848 }
6849}
6850impl Deref for CCU41 {
6851 type Target = ccu40::RegisterBlock;
6852 #[inline(always)]
6853 fn deref(&self) -> &Self::Target {
6854 unsafe { &*Self::PTR }
6855 }
6856}
6857impl core::fmt::Debug for CCU41 {
6858 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6859 f.debug_struct("CCU41").finish()
6860 }
6861}
6862#[doc = "Capture Compare Unit 4 - Unit 1"]
6863pub use self::ccu40 as ccu41;
6864#[doc = "Capture Compare Unit 4 - Unit 2"]
6865pub struct CCU42 {
6866 _marker: PhantomData<*const ()>,
6867}
6868unsafe impl Send for CCU42 {}
6869impl CCU42 {
6870 #[doc = r"Pointer to the register block"]
6871 pub const PTR: *const ccu40::RegisterBlock = 0x4001_4000 as *const _;
6872 #[doc = r"Return the pointer to the register block"]
6873 #[inline(always)]
6874 pub const fn ptr() -> *const ccu40::RegisterBlock {
6875 Self::PTR
6876 }
6877 #[doc = r" Steal an instance of this peripheral"]
6878 #[doc = r""]
6879 #[doc = r" # Safety"]
6880 #[doc = r""]
6881 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6882 #[doc = r" that may race with any existing instances, for example by only"]
6883 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6884 #[doc = r" original peripheral and using critical sections to coordinate"]
6885 #[doc = r" access between multiple new instances."]
6886 #[doc = r""]
6887 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6888 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6889 #[doc = r" no stolen instances are passed to such software."]
6890 pub unsafe fn steal() -> Self {
6891 Self { _marker: PhantomData }
6892 }
6893}
6894impl Deref for CCU42 {
6895 type Target = ccu40::RegisterBlock;
6896 #[inline(always)]
6897 fn deref(&self) -> &Self::Target {
6898 unsafe { &*Self::PTR }
6899 }
6900}
6901impl core::fmt::Debug for CCU42 {
6902 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6903 f.debug_struct("CCU42").finish()
6904 }
6905}
6906#[doc = "Capture Compare Unit 4 - Unit 2"]
6907pub use self::ccu40 as ccu42;
6908#[doc = "Capture Compare Unit 4 - Unit 3"]
6909pub struct CCU43 {
6910 _marker: PhantomData<*const ()>,
6911}
6912unsafe impl Send for CCU43 {}
6913impl CCU43 {
6914 #[doc = r"Pointer to the register block"]
6915 pub const PTR: *const ccu40::RegisterBlock = 0x4800_4000 as *const _;
6916 #[doc = r"Return the pointer to the register block"]
6917 #[inline(always)]
6918 pub const fn ptr() -> *const ccu40::RegisterBlock {
6919 Self::PTR
6920 }
6921 #[doc = r" Steal an instance of this peripheral"]
6922 #[doc = r""]
6923 #[doc = r" # Safety"]
6924 #[doc = r""]
6925 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6926 #[doc = r" that may race with any existing instances, for example by only"]
6927 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6928 #[doc = r" original peripheral and using critical sections to coordinate"]
6929 #[doc = r" access between multiple new instances."]
6930 #[doc = r""]
6931 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6932 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6933 #[doc = r" no stolen instances are passed to such software."]
6934 pub unsafe fn steal() -> Self {
6935 Self { _marker: PhantomData }
6936 }
6937}
6938impl Deref for CCU43 {
6939 type Target = ccu40::RegisterBlock;
6940 #[inline(always)]
6941 fn deref(&self) -> &Self::Target {
6942 unsafe { &*Self::PTR }
6943 }
6944}
6945impl core::fmt::Debug for CCU43 {
6946 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6947 f.debug_struct("CCU43").finish()
6948 }
6949}
6950#[doc = "Capture Compare Unit 4 - Unit 3"]
6951pub use self::ccu40 as ccu43;
6952#[doc = "Capture Compare Unit 4 - Unit 0"]
6953pub struct CCU40_CC40 {
6954 _marker: PhantomData<*const ()>,
6955}
6956unsafe impl Send for CCU40_CC40 {}
6957impl CCU40_CC40 {
6958 #[doc = r"Pointer to the register block"]
6959 pub const PTR: *const ccu40_cc40::RegisterBlock = 0x4000_c100 as *const _;
6960 #[doc = r"Return the pointer to the register block"]
6961 #[inline(always)]
6962 pub const fn ptr() -> *const ccu40_cc40::RegisterBlock {
6963 Self::PTR
6964 }
6965 #[doc = r" Steal an instance of this peripheral"]
6966 #[doc = r""]
6967 #[doc = r" # Safety"]
6968 #[doc = r""]
6969 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6970 #[doc = r" that may race with any existing instances, for example by only"]
6971 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6972 #[doc = r" original peripheral and using critical sections to coordinate"]
6973 #[doc = r" access between multiple new instances."]
6974 #[doc = r""]
6975 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6976 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6977 #[doc = r" no stolen instances are passed to such software."]
6978 pub unsafe fn steal() -> Self {
6979 Self { _marker: PhantomData }
6980 }
6981}
6982impl Deref for CCU40_CC40 {
6983 type Target = ccu40_cc40::RegisterBlock;
6984 #[inline(always)]
6985 fn deref(&self) -> &Self::Target {
6986 unsafe { &*Self::PTR }
6987 }
6988}
6989impl core::fmt::Debug for CCU40_CC40 {
6990 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6991 f.debug_struct("CCU40_CC40").finish()
6992 }
6993}
6994#[doc = "Capture Compare Unit 4 - Unit 0"]
6995pub mod ccu40_cc40;
6996#[doc = "Capture Compare Unit 4 - Unit 0"]
6997pub struct CCU40_CC41 {
6998 _marker: PhantomData<*const ()>,
6999}
7000unsafe impl Send for CCU40_CC41 {}
7001impl CCU40_CC41 {
7002 #[doc = r"Pointer to the register block"]
7003 pub const PTR: *const ccu40_cc40::RegisterBlock = 0x4000_c200 as *const _;
7004 #[doc = r"Return the pointer to the register block"]
7005 #[inline(always)]
7006 pub const fn ptr() -> *const ccu40_cc40::RegisterBlock {
7007 Self::PTR
7008 }
7009 #[doc = r" Steal an instance of this peripheral"]
7010 #[doc = r""]
7011 #[doc = r" # Safety"]
7012 #[doc = r""]
7013 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7014 #[doc = r" that may race with any existing instances, for example by only"]
7015 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7016 #[doc = r" original peripheral and using critical sections to coordinate"]
7017 #[doc = r" access between multiple new instances."]
7018 #[doc = r""]
7019 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7020 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7021 #[doc = r" no stolen instances are passed to such software."]
7022 pub unsafe fn steal() -> Self {
7023 Self { _marker: PhantomData }
7024 }
7025}
7026impl Deref for CCU40_CC41 {
7027 type Target = ccu40_cc40::RegisterBlock;
7028 #[inline(always)]
7029 fn deref(&self) -> &Self::Target {
7030 unsafe { &*Self::PTR }
7031 }
7032}
7033impl core::fmt::Debug for CCU40_CC41 {
7034 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7035 f.debug_struct("CCU40_CC41").finish()
7036 }
7037}
7038#[doc = "Capture Compare Unit 4 - Unit 0"]
7039pub use self::ccu40_cc40 as ccu40_cc41;
7040#[doc = "Capture Compare Unit 4 - Unit 0"]
7041pub struct CCU40_CC42 {
7042 _marker: PhantomData<*const ()>,
7043}
7044unsafe impl Send for CCU40_CC42 {}
7045impl CCU40_CC42 {
7046 #[doc = r"Pointer to the register block"]
7047 pub const PTR: *const ccu40_cc40::RegisterBlock = 0x4000_c300 as *const _;
7048 #[doc = r"Return the pointer to the register block"]
7049 #[inline(always)]
7050 pub const fn ptr() -> *const ccu40_cc40::RegisterBlock {
7051 Self::PTR
7052 }
7053 #[doc = r" Steal an instance of this peripheral"]
7054 #[doc = r""]
7055 #[doc = r" # Safety"]
7056 #[doc = r""]
7057 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7058 #[doc = r" that may race with any existing instances, for example by only"]
7059 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7060 #[doc = r" original peripheral and using critical sections to coordinate"]
7061 #[doc = r" access between multiple new instances."]
7062 #[doc = r""]
7063 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7064 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7065 #[doc = r" no stolen instances are passed to such software."]
7066 pub unsafe fn steal() -> Self {
7067 Self { _marker: PhantomData }
7068 }
7069}
7070impl Deref for CCU40_CC42 {
7071 type Target = ccu40_cc40::RegisterBlock;
7072 #[inline(always)]
7073 fn deref(&self) -> &Self::Target {
7074 unsafe { &*Self::PTR }
7075 }
7076}
7077impl core::fmt::Debug for CCU40_CC42 {
7078 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7079 f.debug_struct("CCU40_CC42").finish()
7080 }
7081}
7082#[doc = "Capture Compare Unit 4 - Unit 0"]
7083pub use self::ccu40_cc40 as ccu40_cc42;
7084#[doc = "Capture Compare Unit 4 - Unit 0"]
7085pub struct CCU40_CC43 {
7086 _marker: PhantomData<*const ()>,
7087}
7088unsafe impl Send for CCU40_CC43 {}
7089impl CCU40_CC43 {
7090 #[doc = r"Pointer to the register block"]
7091 pub const PTR: *const ccu40_cc40::RegisterBlock = 0x4000_c400 as *const _;
7092 #[doc = r"Return the pointer to the register block"]
7093 #[inline(always)]
7094 pub const fn ptr() -> *const ccu40_cc40::RegisterBlock {
7095 Self::PTR
7096 }
7097 #[doc = r" Steal an instance of this peripheral"]
7098 #[doc = r""]
7099 #[doc = r" # Safety"]
7100 #[doc = r""]
7101 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7102 #[doc = r" that may race with any existing instances, for example by only"]
7103 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7104 #[doc = r" original peripheral and using critical sections to coordinate"]
7105 #[doc = r" access between multiple new instances."]
7106 #[doc = r""]
7107 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7108 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7109 #[doc = r" no stolen instances are passed to such software."]
7110 pub unsafe fn steal() -> Self {
7111 Self { _marker: PhantomData }
7112 }
7113}
7114impl Deref for CCU40_CC43 {
7115 type Target = ccu40_cc40::RegisterBlock;
7116 #[inline(always)]
7117 fn deref(&self) -> &Self::Target {
7118 unsafe { &*Self::PTR }
7119 }
7120}
7121impl core::fmt::Debug for CCU40_CC43 {
7122 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7123 f.debug_struct("CCU40_CC43").finish()
7124 }
7125}
7126#[doc = "Capture Compare Unit 4 - Unit 0"]
7127pub use self::ccu40_cc40 as ccu40_cc43;
7128#[doc = "Capture Compare Unit 4 - Unit 1"]
7129pub struct CCU41_CC40 {
7130 _marker: PhantomData<*const ()>,
7131}
7132unsafe impl Send for CCU41_CC40 {}
7133impl CCU41_CC40 {
7134 #[doc = r"Pointer to the register block"]
7135 pub const PTR: *const ccu40_cc40::RegisterBlock = 0x4001_0100 as *const _;
7136 #[doc = r"Return the pointer to the register block"]
7137 #[inline(always)]
7138 pub const fn ptr() -> *const ccu40_cc40::RegisterBlock {
7139 Self::PTR
7140 }
7141 #[doc = r" Steal an instance of this peripheral"]
7142 #[doc = r""]
7143 #[doc = r" # Safety"]
7144 #[doc = r""]
7145 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7146 #[doc = r" that may race with any existing instances, for example by only"]
7147 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7148 #[doc = r" original peripheral and using critical sections to coordinate"]
7149 #[doc = r" access between multiple new instances."]
7150 #[doc = r""]
7151 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7152 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7153 #[doc = r" no stolen instances are passed to such software."]
7154 pub unsafe fn steal() -> Self {
7155 Self { _marker: PhantomData }
7156 }
7157}
7158impl Deref for CCU41_CC40 {
7159 type Target = ccu40_cc40::RegisterBlock;
7160 #[inline(always)]
7161 fn deref(&self) -> &Self::Target {
7162 unsafe { &*Self::PTR }
7163 }
7164}
7165impl core::fmt::Debug for CCU41_CC40 {
7166 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7167 f.debug_struct("CCU41_CC40").finish()
7168 }
7169}
7170#[doc = "Capture Compare Unit 4 - Unit 1"]
7171pub use self::ccu40_cc40 as ccu41_cc40;
7172#[doc = "Capture Compare Unit 4 - Unit 1"]
7173pub struct CCU41_CC41 {
7174 _marker: PhantomData<*const ()>,
7175}
7176unsafe impl Send for CCU41_CC41 {}
7177impl CCU41_CC41 {
7178 #[doc = r"Pointer to the register block"]
7179 pub const PTR: *const ccu40_cc40::RegisterBlock = 0x4001_0200 as *const _;
7180 #[doc = r"Return the pointer to the register block"]
7181 #[inline(always)]
7182 pub const fn ptr() -> *const ccu40_cc40::RegisterBlock {
7183 Self::PTR
7184 }
7185 #[doc = r" Steal an instance of this peripheral"]
7186 #[doc = r""]
7187 #[doc = r" # Safety"]
7188 #[doc = r""]
7189 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7190 #[doc = r" that may race with any existing instances, for example by only"]
7191 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7192 #[doc = r" original peripheral and using critical sections to coordinate"]
7193 #[doc = r" access between multiple new instances."]
7194 #[doc = r""]
7195 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7196 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7197 #[doc = r" no stolen instances are passed to such software."]
7198 pub unsafe fn steal() -> Self {
7199 Self { _marker: PhantomData }
7200 }
7201}
7202impl Deref for CCU41_CC41 {
7203 type Target = ccu40_cc40::RegisterBlock;
7204 #[inline(always)]
7205 fn deref(&self) -> &Self::Target {
7206 unsafe { &*Self::PTR }
7207 }
7208}
7209impl core::fmt::Debug for CCU41_CC41 {
7210 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7211 f.debug_struct("CCU41_CC41").finish()
7212 }
7213}
7214#[doc = "Capture Compare Unit 4 - Unit 1"]
7215pub use self::ccu40_cc40 as ccu41_cc41;
7216#[doc = "Capture Compare Unit 4 - Unit 1"]
7217pub struct CCU41_CC42 {
7218 _marker: PhantomData<*const ()>,
7219}
7220unsafe impl Send for CCU41_CC42 {}
7221impl CCU41_CC42 {
7222 #[doc = r"Pointer to the register block"]
7223 pub const PTR: *const ccu40_cc40::RegisterBlock = 0x4001_0300 as *const _;
7224 #[doc = r"Return the pointer to the register block"]
7225 #[inline(always)]
7226 pub const fn ptr() -> *const ccu40_cc40::RegisterBlock {
7227 Self::PTR
7228 }
7229 #[doc = r" Steal an instance of this peripheral"]
7230 #[doc = r""]
7231 #[doc = r" # Safety"]
7232 #[doc = r""]
7233 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7234 #[doc = r" that may race with any existing instances, for example by only"]
7235 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7236 #[doc = r" original peripheral and using critical sections to coordinate"]
7237 #[doc = r" access between multiple new instances."]
7238 #[doc = r""]
7239 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7240 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7241 #[doc = r" no stolen instances are passed to such software."]
7242 pub unsafe fn steal() -> Self {
7243 Self { _marker: PhantomData }
7244 }
7245}
7246impl Deref for CCU41_CC42 {
7247 type Target = ccu40_cc40::RegisterBlock;
7248 #[inline(always)]
7249 fn deref(&self) -> &Self::Target {
7250 unsafe { &*Self::PTR }
7251 }
7252}
7253impl core::fmt::Debug for CCU41_CC42 {
7254 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7255 f.debug_struct("CCU41_CC42").finish()
7256 }
7257}
7258#[doc = "Capture Compare Unit 4 - Unit 1"]
7259pub use self::ccu40_cc40 as ccu41_cc42;
7260#[doc = "Capture Compare Unit 4 - Unit 1"]
7261pub struct CCU41_CC43 {
7262 _marker: PhantomData<*const ()>,
7263}
7264unsafe impl Send for CCU41_CC43 {}
7265impl CCU41_CC43 {
7266 #[doc = r"Pointer to the register block"]
7267 pub const PTR: *const ccu40_cc40::RegisterBlock = 0x4001_0400 as *const _;
7268 #[doc = r"Return the pointer to the register block"]
7269 #[inline(always)]
7270 pub const fn ptr() -> *const ccu40_cc40::RegisterBlock {
7271 Self::PTR
7272 }
7273 #[doc = r" Steal an instance of this peripheral"]
7274 #[doc = r""]
7275 #[doc = r" # Safety"]
7276 #[doc = r""]
7277 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7278 #[doc = r" that may race with any existing instances, for example by only"]
7279 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7280 #[doc = r" original peripheral and using critical sections to coordinate"]
7281 #[doc = r" access between multiple new instances."]
7282 #[doc = r""]
7283 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7284 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7285 #[doc = r" no stolen instances are passed to such software."]
7286 pub unsafe fn steal() -> Self {
7287 Self { _marker: PhantomData }
7288 }
7289}
7290impl Deref for CCU41_CC43 {
7291 type Target = ccu40_cc40::RegisterBlock;
7292 #[inline(always)]
7293 fn deref(&self) -> &Self::Target {
7294 unsafe { &*Self::PTR }
7295 }
7296}
7297impl core::fmt::Debug for CCU41_CC43 {
7298 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7299 f.debug_struct("CCU41_CC43").finish()
7300 }
7301}
7302#[doc = "Capture Compare Unit 4 - Unit 1"]
7303pub use self::ccu40_cc40 as ccu41_cc43;
7304#[doc = "Capture Compare Unit 4 - Unit 2"]
7305pub struct CCU42_CC40 {
7306 _marker: PhantomData<*const ()>,
7307}
7308unsafe impl Send for CCU42_CC40 {}
7309impl CCU42_CC40 {
7310 #[doc = r"Pointer to the register block"]
7311 pub const PTR: *const ccu40_cc40::RegisterBlock = 0x4001_4100 as *const _;
7312 #[doc = r"Return the pointer to the register block"]
7313 #[inline(always)]
7314 pub const fn ptr() -> *const ccu40_cc40::RegisterBlock {
7315 Self::PTR
7316 }
7317 #[doc = r" Steal an instance of this peripheral"]
7318 #[doc = r""]
7319 #[doc = r" # Safety"]
7320 #[doc = r""]
7321 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7322 #[doc = r" that may race with any existing instances, for example by only"]
7323 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7324 #[doc = r" original peripheral and using critical sections to coordinate"]
7325 #[doc = r" access between multiple new instances."]
7326 #[doc = r""]
7327 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7328 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7329 #[doc = r" no stolen instances are passed to such software."]
7330 pub unsafe fn steal() -> Self {
7331 Self { _marker: PhantomData }
7332 }
7333}
7334impl Deref for CCU42_CC40 {
7335 type Target = ccu40_cc40::RegisterBlock;
7336 #[inline(always)]
7337 fn deref(&self) -> &Self::Target {
7338 unsafe { &*Self::PTR }
7339 }
7340}
7341impl core::fmt::Debug for CCU42_CC40 {
7342 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7343 f.debug_struct("CCU42_CC40").finish()
7344 }
7345}
7346#[doc = "Capture Compare Unit 4 - Unit 2"]
7347pub use self::ccu40_cc40 as ccu42_cc40;
7348#[doc = "Capture Compare Unit 4 - Unit 2"]
7349pub struct CCU42_CC41 {
7350 _marker: PhantomData<*const ()>,
7351}
7352unsafe impl Send for CCU42_CC41 {}
7353impl CCU42_CC41 {
7354 #[doc = r"Pointer to the register block"]
7355 pub const PTR: *const ccu40_cc40::RegisterBlock = 0x4001_4200 as *const _;
7356 #[doc = r"Return the pointer to the register block"]
7357 #[inline(always)]
7358 pub const fn ptr() -> *const ccu40_cc40::RegisterBlock {
7359 Self::PTR
7360 }
7361 #[doc = r" Steal an instance of this peripheral"]
7362 #[doc = r""]
7363 #[doc = r" # Safety"]
7364 #[doc = r""]
7365 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7366 #[doc = r" that may race with any existing instances, for example by only"]
7367 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7368 #[doc = r" original peripheral and using critical sections to coordinate"]
7369 #[doc = r" access between multiple new instances."]
7370 #[doc = r""]
7371 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7372 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7373 #[doc = r" no stolen instances are passed to such software."]
7374 pub unsafe fn steal() -> Self {
7375 Self { _marker: PhantomData }
7376 }
7377}
7378impl Deref for CCU42_CC41 {
7379 type Target = ccu40_cc40::RegisterBlock;
7380 #[inline(always)]
7381 fn deref(&self) -> &Self::Target {
7382 unsafe { &*Self::PTR }
7383 }
7384}
7385impl core::fmt::Debug for CCU42_CC41 {
7386 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7387 f.debug_struct("CCU42_CC41").finish()
7388 }
7389}
7390#[doc = "Capture Compare Unit 4 - Unit 2"]
7391pub use self::ccu40_cc40 as ccu42_cc41;
7392#[doc = "Capture Compare Unit 4 - Unit 2"]
7393pub struct CCU42_CC42 {
7394 _marker: PhantomData<*const ()>,
7395}
7396unsafe impl Send for CCU42_CC42 {}
7397impl CCU42_CC42 {
7398 #[doc = r"Pointer to the register block"]
7399 pub const PTR: *const ccu40_cc40::RegisterBlock = 0x4001_4300 as *const _;
7400 #[doc = r"Return the pointer to the register block"]
7401 #[inline(always)]
7402 pub const fn ptr() -> *const ccu40_cc40::RegisterBlock {
7403 Self::PTR
7404 }
7405 #[doc = r" Steal an instance of this peripheral"]
7406 #[doc = r""]
7407 #[doc = r" # Safety"]
7408 #[doc = r""]
7409 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7410 #[doc = r" that may race with any existing instances, for example by only"]
7411 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7412 #[doc = r" original peripheral and using critical sections to coordinate"]
7413 #[doc = r" access between multiple new instances."]
7414 #[doc = r""]
7415 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7416 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7417 #[doc = r" no stolen instances are passed to such software."]
7418 pub unsafe fn steal() -> Self {
7419 Self { _marker: PhantomData }
7420 }
7421}
7422impl Deref for CCU42_CC42 {
7423 type Target = ccu40_cc40::RegisterBlock;
7424 #[inline(always)]
7425 fn deref(&self) -> &Self::Target {
7426 unsafe { &*Self::PTR }
7427 }
7428}
7429impl core::fmt::Debug for CCU42_CC42 {
7430 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7431 f.debug_struct("CCU42_CC42").finish()
7432 }
7433}
7434#[doc = "Capture Compare Unit 4 - Unit 2"]
7435pub use self::ccu40_cc40 as ccu42_cc42;
7436#[doc = "Capture Compare Unit 4 - Unit 2"]
7437pub struct CCU42_CC43 {
7438 _marker: PhantomData<*const ()>,
7439}
7440unsafe impl Send for CCU42_CC43 {}
7441impl CCU42_CC43 {
7442 #[doc = r"Pointer to the register block"]
7443 pub const PTR: *const ccu40_cc40::RegisterBlock = 0x4001_4400 as *const _;
7444 #[doc = r"Return the pointer to the register block"]
7445 #[inline(always)]
7446 pub const fn ptr() -> *const ccu40_cc40::RegisterBlock {
7447 Self::PTR
7448 }
7449 #[doc = r" Steal an instance of this peripheral"]
7450 #[doc = r""]
7451 #[doc = r" # Safety"]
7452 #[doc = r""]
7453 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7454 #[doc = r" that may race with any existing instances, for example by only"]
7455 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7456 #[doc = r" original peripheral and using critical sections to coordinate"]
7457 #[doc = r" access between multiple new instances."]
7458 #[doc = r""]
7459 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7460 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7461 #[doc = r" no stolen instances are passed to such software."]
7462 pub unsafe fn steal() -> Self {
7463 Self { _marker: PhantomData }
7464 }
7465}
7466impl Deref for CCU42_CC43 {
7467 type Target = ccu40_cc40::RegisterBlock;
7468 #[inline(always)]
7469 fn deref(&self) -> &Self::Target {
7470 unsafe { &*Self::PTR }
7471 }
7472}
7473impl core::fmt::Debug for CCU42_CC43 {
7474 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7475 f.debug_struct("CCU42_CC43").finish()
7476 }
7477}
7478#[doc = "Capture Compare Unit 4 - Unit 2"]
7479pub use self::ccu40_cc40 as ccu42_cc43;
7480#[doc = "Capture Compare Unit 4 - Unit 3"]
7481pub struct CCU43_CC40 {
7482 _marker: PhantomData<*const ()>,
7483}
7484unsafe impl Send for CCU43_CC40 {}
7485impl CCU43_CC40 {
7486 #[doc = r"Pointer to the register block"]
7487 pub const PTR: *const ccu40_cc40::RegisterBlock = 0x4800_4100 as *const _;
7488 #[doc = r"Return the pointer to the register block"]
7489 #[inline(always)]
7490 pub const fn ptr() -> *const ccu40_cc40::RegisterBlock {
7491 Self::PTR
7492 }
7493 #[doc = r" Steal an instance of this peripheral"]
7494 #[doc = r""]
7495 #[doc = r" # Safety"]
7496 #[doc = r""]
7497 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7498 #[doc = r" that may race with any existing instances, for example by only"]
7499 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7500 #[doc = r" original peripheral and using critical sections to coordinate"]
7501 #[doc = r" access between multiple new instances."]
7502 #[doc = r""]
7503 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7504 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7505 #[doc = r" no stolen instances are passed to such software."]
7506 pub unsafe fn steal() -> Self {
7507 Self { _marker: PhantomData }
7508 }
7509}
7510impl Deref for CCU43_CC40 {
7511 type Target = ccu40_cc40::RegisterBlock;
7512 #[inline(always)]
7513 fn deref(&self) -> &Self::Target {
7514 unsafe { &*Self::PTR }
7515 }
7516}
7517impl core::fmt::Debug for CCU43_CC40 {
7518 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7519 f.debug_struct("CCU43_CC40").finish()
7520 }
7521}
7522#[doc = "Capture Compare Unit 4 - Unit 3"]
7523pub use self::ccu40_cc40 as ccu43_cc40;
7524#[doc = "Capture Compare Unit 4 - Unit 3"]
7525pub struct CCU43_CC41 {
7526 _marker: PhantomData<*const ()>,
7527}
7528unsafe impl Send for CCU43_CC41 {}
7529impl CCU43_CC41 {
7530 #[doc = r"Pointer to the register block"]
7531 pub const PTR: *const ccu40_cc40::RegisterBlock = 0x4800_4200 as *const _;
7532 #[doc = r"Return the pointer to the register block"]
7533 #[inline(always)]
7534 pub const fn ptr() -> *const ccu40_cc40::RegisterBlock {
7535 Self::PTR
7536 }
7537 #[doc = r" Steal an instance of this peripheral"]
7538 #[doc = r""]
7539 #[doc = r" # Safety"]
7540 #[doc = r""]
7541 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7542 #[doc = r" that may race with any existing instances, for example by only"]
7543 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7544 #[doc = r" original peripheral and using critical sections to coordinate"]
7545 #[doc = r" access between multiple new instances."]
7546 #[doc = r""]
7547 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7548 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7549 #[doc = r" no stolen instances are passed to such software."]
7550 pub unsafe fn steal() -> Self {
7551 Self { _marker: PhantomData }
7552 }
7553}
7554impl Deref for CCU43_CC41 {
7555 type Target = ccu40_cc40::RegisterBlock;
7556 #[inline(always)]
7557 fn deref(&self) -> &Self::Target {
7558 unsafe { &*Self::PTR }
7559 }
7560}
7561impl core::fmt::Debug for CCU43_CC41 {
7562 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7563 f.debug_struct("CCU43_CC41").finish()
7564 }
7565}
7566#[doc = "Capture Compare Unit 4 - Unit 3"]
7567pub use self::ccu40_cc40 as ccu43_cc41;
7568#[doc = "Capture Compare Unit 4 - Unit 3"]
7569pub struct CCU43_CC42 {
7570 _marker: PhantomData<*const ()>,
7571}
7572unsafe impl Send for CCU43_CC42 {}
7573impl CCU43_CC42 {
7574 #[doc = r"Pointer to the register block"]
7575 pub const PTR: *const ccu40_cc40::RegisterBlock = 0x4800_4300 as *const _;
7576 #[doc = r"Return the pointer to the register block"]
7577 #[inline(always)]
7578 pub const fn ptr() -> *const ccu40_cc40::RegisterBlock {
7579 Self::PTR
7580 }
7581 #[doc = r" Steal an instance of this peripheral"]
7582 #[doc = r""]
7583 #[doc = r" # Safety"]
7584 #[doc = r""]
7585 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7586 #[doc = r" that may race with any existing instances, for example by only"]
7587 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7588 #[doc = r" original peripheral and using critical sections to coordinate"]
7589 #[doc = r" access between multiple new instances."]
7590 #[doc = r""]
7591 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7592 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7593 #[doc = r" no stolen instances are passed to such software."]
7594 pub unsafe fn steal() -> Self {
7595 Self { _marker: PhantomData }
7596 }
7597}
7598impl Deref for CCU43_CC42 {
7599 type Target = ccu40_cc40::RegisterBlock;
7600 #[inline(always)]
7601 fn deref(&self) -> &Self::Target {
7602 unsafe { &*Self::PTR }
7603 }
7604}
7605impl core::fmt::Debug for CCU43_CC42 {
7606 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7607 f.debug_struct("CCU43_CC42").finish()
7608 }
7609}
7610#[doc = "Capture Compare Unit 4 - Unit 3"]
7611pub use self::ccu40_cc40 as ccu43_cc42;
7612#[doc = "Capture Compare Unit 4 - Unit 3"]
7613pub struct CCU43_CC43 {
7614 _marker: PhantomData<*const ()>,
7615}
7616unsafe impl Send for CCU43_CC43 {}
7617impl CCU43_CC43 {
7618 #[doc = r"Pointer to the register block"]
7619 pub const PTR: *const ccu40_cc40::RegisterBlock = 0x4800_4400 as *const _;
7620 #[doc = r"Return the pointer to the register block"]
7621 #[inline(always)]
7622 pub const fn ptr() -> *const ccu40_cc40::RegisterBlock {
7623 Self::PTR
7624 }
7625 #[doc = r" Steal an instance of this peripheral"]
7626 #[doc = r""]
7627 #[doc = r" # Safety"]
7628 #[doc = r""]
7629 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7630 #[doc = r" that may race with any existing instances, for example by only"]
7631 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7632 #[doc = r" original peripheral and using critical sections to coordinate"]
7633 #[doc = r" access between multiple new instances."]
7634 #[doc = r""]
7635 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7636 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7637 #[doc = r" no stolen instances are passed to such software."]
7638 pub unsafe fn steal() -> Self {
7639 Self { _marker: PhantomData }
7640 }
7641}
7642impl Deref for CCU43_CC43 {
7643 type Target = ccu40_cc40::RegisterBlock;
7644 #[inline(always)]
7645 fn deref(&self) -> &Self::Target {
7646 unsafe { &*Self::PTR }
7647 }
7648}
7649impl core::fmt::Debug for CCU43_CC43 {
7650 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7651 f.debug_struct("CCU43_CC43").finish()
7652 }
7653}
7654#[doc = "Capture Compare Unit 4 - Unit 3"]
7655pub use self::ccu40_cc40 as ccu43_cc43;
7656#[doc = "Capture Compare Unit 8 - Unit 0"]
7657pub struct CCU80 {
7658 _marker: PhantomData<*const ()>,
7659}
7660unsafe impl Send for CCU80 {}
7661impl CCU80 {
7662 #[doc = r"Pointer to the register block"]
7663 pub const PTR: *const ccu80::RegisterBlock = 0x4002_0000 as *const _;
7664 #[doc = r"Return the pointer to the register block"]
7665 #[inline(always)]
7666 pub const fn ptr() -> *const ccu80::RegisterBlock {
7667 Self::PTR
7668 }
7669 #[doc = r" Steal an instance of this peripheral"]
7670 #[doc = r""]
7671 #[doc = r" # Safety"]
7672 #[doc = r""]
7673 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7674 #[doc = r" that may race with any existing instances, for example by only"]
7675 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7676 #[doc = r" original peripheral and using critical sections to coordinate"]
7677 #[doc = r" access between multiple new instances."]
7678 #[doc = r""]
7679 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7680 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7681 #[doc = r" no stolen instances are passed to such software."]
7682 pub unsafe fn steal() -> Self {
7683 Self { _marker: PhantomData }
7684 }
7685}
7686impl Deref for CCU80 {
7687 type Target = ccu80::RegisterBlock;
7688 #[inline(always)]
7689 fn deref(&self) -> &Self::Target {
7690 unsafe { &*Self::PTR }
7691 }
7692}
7693impl core::fmt::Debug for CCU80 {
7694 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7695 f.debug_struct("CCU80").finish()
7696 }
7697}
7698#[doc = "Capture Compare Unit 8 - Unit 0"]
7699pub mod ccu80;
7700#[doc = "Capture Compare Unit 8 - Unit 1"]
7701pub struct CCU81 {
7702 _marker: PhantomData<*const ()>,
7703}
7704unsafe impl Send for CCU81 {}
7705impl CCU81 {
7706 #[doc = r"Pointer to the register block"]
7707 pub const PTR: *const ccu80::RegisterBlock = 0x4002_4000 as *const _;
7708 #[doc = r"Return the pointer to the register block"]
7709 #[inline(always)]
7710 pub const fn ptr() -> *const ccu80::RegisterBlock {
7711 Self::PTR
7712 }
7713 #[doc = r" Steal an instance of this peripheral"]
7714 #[doc = r""]
7715 #[doc = r" # Safety"]
7716 #[doc = r""]
7717 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7718 #[doc = r" that may race with any existing instances, for example by only"]
7719 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7720 #[doc = r" original peripheral and using critical sections to coordinate"]
7721 #[doc = r" access between multiple new instances."]
7722 #[doc = r""]
7723 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7724 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7725 #[doc = r" no stolen instances are passed to such software."]
7726 pub unsafe fn steal() -> Self {
7727 Self { _marker: PhantomData }
7728 }
7729}
7730impl Deref for CCU81 {
7731 type Target = ccu80::RegisterBlock;
7732 #[inline(always)]
7733 fn deref(&self) -> &Self::Target {
7734 unsafe { &*Self::PTR }
7735 }
7736}
7737impl core::fmt::Debug for CCU81 {
7738 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7739 f.debug_struct("CCU81").finish()
7740 }
7741}
7742#[doc = "Capture Compare Unit 8 - Unit 1"]
7743pub use self::ccu80 as ccu81;
7744#[doc = "Capture Compare Unit 8 - Unit 0"]
7745pub struct CCU80_CC80 {
7746 _marker: PhantomData<*const ()>,
7747}
7748unsafe impl Send for CCU80_CC80 {}
7749impl CCU80_CC80 {
7750 #[doc = r"Pointer to the register block"]
7751 pub const PTR: *const ccu80_cc80::RegisterBlock = 0x4002_0100 as *const _;
7752 #[doc = r"Return the pointer to the register block"]
7753 #[inline(always)]
7754 pub const fn ptr() -> *const ccu80_cc80::RegisterBlock {
7755 Self::PTR
7756 }
7757 #[doc = r" Steal an instance of this peripheral"]
7758 #[doc = r""]
7759 #[doc = r" # Safety"]
7760 #[doc = r""]
7761 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7762 #[doc = r" that may race with any existing instances, for example by only"]
7763 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7764 #[doc = r" original peripheral and using critical sections to coordinate"]
7765 #[doc = r" access between multiple new instances."]
7766 #[doc = r""]
7767 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7768 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7769 #[doc = r" no stolen instances are passed to such software."]
7770 pub unsafe fn steal() -> Self {
7771 Self { _marker: PhantomData }
7772 }
7773}
7774impl Deref for CCU80_CC80 {
7775 type Target = ccu80_cc80::RegisterBlock;
7776 #[inline(always)]
7777 fn deref(&self) -> &Self::Target {
7778 unsafe { &*Self::PTR }
7779 }
7780}
7781impl core::fmt::Debug for CCU80_CC80 {
7782 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7783 f.debug_struct("CCU80_CC80").finish()
7784 }
7785}
7786#[doc = "Capture Compare Unit 8 - Unit 0"]
7787pub mod ccu80_cc80;
7788#[doc = "Capture Compare Unit 8 - Unit 0"]
7789pub struct CCU80_CC81 {
7790 _marker: PhantomData<*const ()>,
7791}
7792unsafe impl Send for CCU80_CC81 {}
7793impl CCU80_CC81 {
7794 #[doc = r"Pointer to the register block"]
7795 pub const PTR: *const ccu80_cc80::RegisterBlock = 0x4002_0200 as *const _;
7796 #[doc = r"Return the pointer to the register block"]
7797 #[inline(always)]
7798 pub const fn ptr() -> *const ccu80_cc80::RegisterBlock {
7799 Self::PTR
7800 }
7801 #[doc = r" Steal an instance of this peripheral"]
7802 #[doc = r""]
7803 #[doc = r" # Safety"]
7804 #[doc = r""]
7805 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7806 #[doc = r" that may race with any existing instances, for example by only"]
7807 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7808 #[doc = r" original peripheral and using critical sections to coordinate"]
7809 #[doc = r" access between multiple new instances."]
7810 #[doc = r""]
7811 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7812 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7813 #[doc = r" no stolen instances are passed to such software."]
7814 pub unsafe fn steal() -> Self {
7815 Self { _marker: PhantomData }
7816 }
7817}
7818impl Deref for CCU80_CC81 {
7819 type Target = ccu80_cc80::RegisterBlock;
7820 #[inline(always)]
7821 fn deref(&self) -> &Self::Target {
7822 unsafe { &*Self::PTR }
7823 }
7824}
7825impl core::fmt::Debug for CCU80_CC81 {
7826 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7827 f.debug_struct("CCU80_CC81").finish()
7828 }
7829}
7830#[doc = "Capture Compare Unit 8 - Unit 0"]
7831pub use self::ccu80_cc80 as ccu80_cc81;
7832#[doc = "Capture Compare Unit 8 - Unit 0"]
7833pub struct CCU80_CC82 {
7834 _marker: PhantomData<*const ()>,
7835}
7836unsafe impl Send for CCU80_CC82 {}
7837impl CCU80_CC82 {
7838 #[doc = r"Pointer to the register block"]
7839 pub const PTR: *const ccu80_cc80::RegisterBlock = 0x4002_0300 as *const _;
7840 #[doc = r"Return the pointer to the register block"]
7841 #[inline(always)]
7842 pub const fn ptr() -> *const ccu80_cc80::RegisterBlock {
7843 Self::PTR
7844 }
7845 #[doc = r" Steal an instance of this peripheral"]
7846 #[doc = r""]
7847 #[doc = r" # Safety"]
7848 #[doc = r""]
7849 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7850 #[doc = r" that may race with any existing instances, for example by only"]
7851 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7852 #[doc = r" original peripheral and using critical sections to coordinate"]
7853 #[doc = r" access between multiple new instances."]
7854 #[doc = r""]
7855 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7856 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7857 #[doc = r" no stolen instances are passed to such software."]
7858 pub unsafe fn steal() -> Self {
7859 Self { _marker: PhantomData }
7860 }
7861}
7862impl Deref for CCU80_CC82 {
7863 type Target = ccu80_cc80::RegisterBlock;
7864 #[inline(always)]
7865 fn deref(&self) -> &Self::Target {
7866 unsafe { &*Self::PTR }
7867 }
7868}
7869impl core::fmt::Debug for CCU80_CC82 {
7870 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7871 f.debug_struct("CCU80_CC82").finish()
7872 }
7873}
7874#[doc = "Capture Compare Unit 8 - Unit 0"]
7875pub use self::ccu80_cc80 as ccu80_cc82;
7876#[doc = "Capture Compare Unit 8 - Unit 0"]
7877pub struct CCU80_CC83 {
7878 _marker: PhantomData<*const ()>,
7879}
7880unsafe impl Send for CCU80_CC83 {}
7881impl CCU80_CC83 {
7882 #[doc = r"Pointer to the register block"]
7883 pub const PTR: *const ccu80_cc80::RegisterBlock = 0x4002_0400 as *const _;
7884 #[doc = r"Return the pointer to the register block"]
7885 #[inline(always)]
7886 pub const fn ptr() -> *const ccu80_cc80::RegisterBlock {
7887 Self::PTR
7888 }
7889 #[doc = r" Steal an instance of this peripheral"]
7890 #[doc = r""]
7891 #[doc = r" # Safety"]
7892 #[doc = r""]
7893 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7894 #[doc = r" that may race with any existing instances, for example by only"]
7895 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7896 #[doc = r" original peripheral and using critical sections to coordinate"]
7897 #[doc = r" access between multiple new instances."]
7898 #[doc = r""]
7899 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7900 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7901 #[doc = r" no stolen instances are passed to such software."]
7902 pub unsafe fn steal() -> Self {
7903 Self { _marker: PhantomData }
7904 }
7905}
7906impl Deref for CCU80_CC83 {
7907 type Target = ccu80_cc80::RegisterBlock;
7908 #[inline(always)]
7909 fn deref(&self) -> &Self::Target {
7910 unsafe { &*Self::PTR }
7911 }
7912}
7913impl core::fmt::Debug for CCU80_CC83 {
7914 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7915 f.debug_struct("CCU80_CC83").finish()
7916 }
7917}
7918#[doc = "Capture Compare Unit 8 - Unit 0"]
7919pub use self::ccu80_cc80 as ccu80_cc83;
7920#[doc = "Capture Compare Unit 8 - Unit 1"]
7921pub struct CCU81_CC80 {
7922 _marker: PhantomData<*const ()>,
7923}
7924unsafe impl Send for CCU81_CC80 {}
7925impl CCU81_CC80 {
7926 #[doc = r"Pointer to the register block"]
7927 pub const PTR: *const ccu80_cc80::RegisterBlock = 0x4002_4100 as *const _;
7928 #[doc = r"Return the pointer to the register block"]
7929 #[inline(always)]
7930 pub const fn ptr() -> *const ccu80_cc80::RegisterBlock {
7931 Self::PTR
7932 }
7933 #[doc = r" Steal an instance of this peripheral"]
7934 #[doc = r""]
7935 #[doc = r" # Safety"]
7936 #[doc = r""]
7937 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7938 #[doc = r" that may race with any existing instances, for example by only"]
7939 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7940 #[doc = r" original peripheral and using critical sections to coordinate"]
7941 #[doc = r" access between multiple new instances."]
7942 #[doc = r""]
7943 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7944 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7945 #[doc = r" no stolen instances are passed to such software."]
7946 pub unsafe fn steal() -> Self {
7947 Self { _marker: PhantomData }
7948 }
7949}
7950impl Deref for CCU81_CC80 {
7951 type Target = ccu80_cc80::RegisterBlock;
7952 #[inline(always)]
7953 fn deref(&self) -> &Self::Target {
7954 unsafe { &*Self::PTR }
7955 }
7956}
7957impl core::fmt::Debug for CCU81_CC80 {
7958 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7959 f.debug_struct("CCU81_CC80").finish()
7960 }
7961}
7962#[doc = "Capture Compare Unit 8 - Unit 1"]
7963pub use self::ccu80_cc80 as ccu81_cc80;
7964#[doc = "Capture Compare Unit 8 - Unit 1"]
7965pub struct CCU81_CC81 {
7966 _marker: PhantomData<*const ()>,
7967}
7968unsafe impl Send for CCU81_CC81 {}
7969impl CCU81_CC81 {
7970 #[doc = r"Pointer to the register block"]
7971 pub const PTR: *const ccu80_cc80::RegisterBlock = 0x4002_4200 as *const _;
7972 #[doc = r"Return the pointer to the register block"]
7973 #[inline(always)]
7974 pub const fn ptr() -> *const ccu80_cc80::RegisterBlock {
7975 Self::PTR
7976 }
7977 #[doc = r" Steal an instance of this peripheral"]
7978 #[doc = r""]
7979 #[doc = r" # Safety"]
7980 #[doc = r""]
7981 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7982 #[doc = r" that may race with any existing instances, for example by only"]
7983 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7984 #[doc = r" original peripheral and using critical sections to coordinate"]
7985 #[doc = r" access between multiple new instances."]
7986 #[doc = r""]
7987 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7988 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7989 #[doc = r" no stolen instances are passed to such software."]
7990 pub unsafe fn steal() -> Self {
7991 Self { _marker: PhantomData }
7992 }
7993}
7994impl Deref for CCU81_CC81 {
7995 type Target = ccu80_cc80::RegisterBlock;
7996 #[inline(always)]
7997 fn deref(&self) -> &Self::Target {
7998 unsafe { &*Self::PTR }
7999 }
8000}
8001impl core::fmt::Debug for CCU81_CC81 {
8002 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
8003 f.debug_struct("CCU81_CC81").finish()
8004 }
8005}
8006#[doc = "Capture Compare Unit 8 - Unit 1"]
8007pub use self::ccu80_cc80 as ccu81_cc81;
8008#[doc = "Capture Compare Unit 8 - Unit 1"]
8009pub struct CCU81_CC82 {
8010 _marker: PhantomData<*const ()>,
8011}
8012unsafe impl Send for CCU81_CC82 {}
8013impl CCU81_CC82 {
8014 #[doc = r"Pointer to the register block"]
8015 pub const PTR: *const ccu80_cc80::RegisterBlock = 0x4002_4300 as *const _;
8016 #[doc = r"Return the pointer to the register block"]
8017 #[inline(always)]
8018 pub const fn ptr() -> *const ccu80_cc80::RegisterBlock {
8019 Self::PTR
8020 }
8021 #[doc = r" Steal an instance of this peripheral"]
8022 #[doc = r""]
8023 #[doc = r" # Safety"]
8024 #[doc = r""]
8025 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
8026 #[doc = r" that may race with any existing instances, for example by only"]
8027 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
8028 #[doc = r" original peripheral and using critical sections to coordinate"]
8029 #[doc = r" access between multiple new instances."]
8030 #[doc = r""]
8031 #[doc = r" Additionally, other software such as HALs may rely on only one"]
8032 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
8033 #[doc = r" no stolen instances are passed to such software."]
8034 pub unsafe fn steal() -> Self {
8035 Self { _marker: PhantomData }
8036 }
8037}
8038impl Deref for CCU81_CC82 {
8039 type Target = ccu80_cc80::RegisterBlock;
8040 #[inline(always)]
8041 fn deref(&self) -> &Self::Target {
8042 unsafe { &*Self::PTR }
8043 }
8044}
8045impl core::fmt::Debug for CCU81_CC82 {
8046 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
8047 f.debug_struct("CCU81_CC82").finish()
8048 }
8049}
8050#[doc = "Capture Compare Unit 8 - Unit 1"]
8051pub use self::ccu80_cc80 as ccu81_cc82;
8052#[doc = "Capture Compare Unit 8 - Unit 1"]
8053pub struct CCU81_CC83 {
8054 _marker: PhantomData<*const ()>,
8055}
8056unsafe impl Send for CCU81_CC83 {}
8057impl CCU81_CC83 {
8058 #[doc = r"Pointer to the register block"]
8059 pub const PTR: *const ccu80_cc80::RegisterBlock = 0x4002_4400 as *const _;
8060 #[doc = r"Return the pointer to the register block"]
8061 #[inline(always)]
8062 pub const fn ptr() -> *const ccu80_cc80::RegisterBlock {
8063 Self::PTR
8064 }
8065 #[doc = r" Steal an instance of this peripheral"]
8066 #[doc = r""]
8067 #[doc = r" # Safety"]
8068 #[doc = r""]
8069 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
8070 #[doc = r" that may race with any existing instances, for example by only"]
8071 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
8072 #[doc = r" original peripheral and using critical sections to coordinate"]
8073 #[doc = r" access between multiple new instances."]
8074 #[doc = r""]
8075 #[doc = r" Additionally, other software such as HALs may rely on only one"]
8076 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
8077 #[doc = r" no stolen instances are passed to such software."]
8078 pub unsafe fn steal() -> Self {
8079 Self { _marker: PhantomData }
8080 }
8081}
8082impl Deref for CCU81_CC83 {
8083 type Target = ccu80_cc80::RegisterBlock;
8084 #[inline(always)]
8085 fn deref(&self) -> &Self::Target {
8086 unsafe { &*Self::PTR }
8087 }
8088}
8089impl core::fmt::Debug for CCU81_CC83 {
8090 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
8091 f.debug_struct("CCU81_CC83").finish()
8092 }
8093}
8094#[doc = "Capture Compare Unit 8 - Unit 1"]
8095pub use self::ccu80_cc80 as ccu81_cc83;
8096#[doc = "High Resolution PWM Unit"]
8097pub struct HRPWM0 {
8098 _marker: PhantomData<*const ()>,
8099}
8100unsafe impl Send for HRPWM0 {}
8101impl HRPWM0 {
8102 #[doc = r"Pointer to the register block"]
8103 pub const PTR: *const hrpwm0::RegisterBlock = 0x4002_0900 as *const _;
8104 #[doc = r"Return the pointer to the register block"]
8105 #[inline(always)]
8106 pub const fn ptr() -> *const hrpwm0::RegisterBlock {
8107 Self::PTR
8108 }
8109 #[doc = r" Steal an instance of this peripheral"]
8110 #[doc = r""]
8111 #[doc = r" # Safety"]
8112 #[doc = r""]
8113 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
8114 #[doc = r" that may race with any existing instances, for example by only"]
8115 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
8116 #[doc = r" original peripheral and using critical sections to coordinate"]
8117 #[doc = r" access between multiple new instances."]
8118 #[doc = r""]
8119 #[doc = r" Additionally, other software such as HALs may rely on only one"]
8120 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
8121 #[doc = r" no stolen instances are passed to such software."]
8122 pub unsafe fn steal() -> Self {
8123 Self { _marker: PhantomData }
8124 }
8125}
8126impl Deref for HRPWM0 {
8127 type Target = hrpwm0::RegisterBlock;
8128 #[inline(always)]
8129 fn deref(&self) -> &Self::Target {
8130 unsafe { &*Self::PTR }
8131 }
8132}
8133impl core::fmt::Debug for HRPWM0 {
8134 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
8135 f.debug_struct("HRPWM0").finish()
8136 }
8137}
8138#[doc = "High Resolution PWM Unit"]
8139pub mod hrpwm0;
8140#[doc = "High Resolution PWM Unit"]
8141pub struct HRPWM0_CSG0 {
8142 _marker: PhantomData<*const ()>,
8143}
8144unsafe impl Send for HRPWM0_CSG0 {}
8145impl HRPWM0_CSG0 {
8146 #[doc = r"Pointer to the register block"]
8147 pub const PTR: *const hrpwm0_csg0::RegisterBlock = 0x4002_0a00 as *const _;
8148 #[doc = r"Return the pointer to the register block"]
8149 #[inline(always)]
8150 pub const fn ptr() -> *const hrpwm0_csg0::RegisterBlock {
8151 Self::PTR
8152 }
8153 #[doc = r" Steal an instance of this peripheral"]
8154 #[doc = r""]
8155 #[doc = r" # Safety"]
8156 #[doc = r""]
8157 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
8158 #[doc = r" that may race with any existing instances, for example by only"]
8159 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
8160 #[doc = r" original peripheral and using critical sections to coordinate"]
8161 #[doc = r" access between multiple new instances."]
8162 #[doc = r""]
8163 #[doc = r" Additionally, other software such as HALs may rely on only one"]
8164 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
8165 #[doc = r" no stolen instances are passed to such software."]
8166 pub unsafe fn steal() -> Self {
8167 Self { _marker: PhantomData }
8168 }
8169}
8170impl Deref for HRPWM0_CSG0 {
8171 type Target = hrpwm0_csg0::RegisterBlock;
8172 #[inline(always)]
8173 fn deref(&self) -> &Self::Target {
8174 unsafe { &*Self::PTR }
8175 }
8176}
8177impl core::fmt::Debug for HRPWM0_CSG0 {
8178 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
8179 f.debug_struct("HRPWM0_CSG0").finish()
8180 }
8181}
8182#[doc = "High Resolution PWM Unit"]
8183pub mod hrpwm0_csg0;
8184#[doc = "High Resolution PWM Unit"]
8185pub struct HRPWM0_CSG1 {
8186 _marker: PhantomData<*const ()>,
8187}
8188unsafe impl Send for HRPWM0_CSG1 {}
8189impl HRPWM0_CSG1 {
8190 #[doc = r"Pointer to the register block"]
8191 pub const PTR: *const hrpwm0_csg0::RegisterBlock = 0x4002_0b00 as *const _;
8192 #[doc = r"Return the pointer to the register block"]
8193 #[inline(always)]
8194 pub const fn ptr() -> *const hrpwm0_csg0::RegisterBlock {
8195 Self::PTR
8196 }
8197 #[doc = r" Steal an instance of this peripheral"]
8198 #[doc = r""]
8199 #[doc = r" # Safety"]
8200 #[doc = r""]
8201 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
8202 #[doc = r" that may race with any existing instances, for example by only"]
8203 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
8204 #[doc = r" original peripheral and using critical sections to coordinate"]
8205 #[doc = r" access between multiple new instances."]
8206 #[doc = r""]
8207 #[doc = r" Additionally, other software such as HALs may rely on only one"]
8208 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
8209 #[doc = r" no stolen instances are passed to such software."]
8210 pub unsafe fn steal() -> Self {
8211 Self { _marker: PhantomData }
8212 }
8213}
8214impl Deref for HRPWM0_CSG1 {
8215 type Target = hrpwm0_csg0::RegisterBlock;
8216 #[inline(always)]
8217 fn deref(&self) -> &Self::Target {
8218 unsafe { &*Self::PTR }
8219 }
8220}
8221impl core::fmt::Debug for HRPWM0_CSG1 {
8222 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
8223 f.debug_struct("HRPWM0_CSG1").finish()
8224 }
8225}
8226#[doc = "High Resolution PWM Unit"]
8227pub use self::hrpwm0_csg0 as hrpwm0_csg1;
8228#[doc = "High Resolution PWM Unit"]
8229pub struct HRPWM0_CSG2 {
8230 _marker: PhantomData<*const ()>,
8231}
8232unsafe impl Send for HRPWM0_CSG2 {}
8233impl HRPWM0_CSG2 {
8234 #[doc = r"Pointer to the register block"]
8235 pub const PTR: *const hrpwm0_csg0::RegisterBlock = 0x4002_0c00 as *const _;
8236 #[doc = r"Return the pointer to the register block"]
8237 #[inline(always)]
8238 pub const fn ptr() -> *const hrpwm0_csg0::RegisterBlock {
8239 Self::PTR
8240 }
8241 #[doc = r" Steal an instance of this peripheral"]
8242 #[doc = r""]
8243 #[doc = r" # Safety"]
8244 #[doc = r""]
8245 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
8246 #[doc = r" that may race with any existing instances, for example by only"]
8247 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
8248 #[doc = r" original peripheral and using critical sections to coordinate"]
8249 #[doc = r" access between multiple new instances."]
8250 #[doc = r""]
8251 #[doc = r" Additionally, other software such as HALs may rely on only one"]
8252 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
8253 #[doc = r" no stolen instances are passed to such software."]
8254 pub unsafe fn steal() -> Self {
8255 Self { _marker: PhantomData }
8256 }
8257}
8258impl Deref for HRPWM0_CSG2 {
8259 type Target = hrpwm0_csg0::RegisterBlock;
8260 #[inline(always)]
8261 fn deref(&self) -> &Self::Target {
8262 unsafe { &*Self::PTR }
8263 }
8264}
8265impl core::fmt::Debug for HRPWM0_CSG2 {
8266 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
8267 f.debug_struct("HRPWM0_CSG2").finish()
8268 }
8269}
8270#[doc = "High Resolution PWM Unit"]
8271pub use self::hrpwm0_csg0 as hrpwm0_csg2;
8272#[doc = "High Resolution PWM Unit"]
8273pub struct HRPWM0_HRC0 {
8274 _marker: PhantomData<*const ()>,
8275}
8276unsafe impl Send for HRPWM0_HRC0 {}
8277impl HRPWM0_HRC0 {
8278 #[doc = r"Pointer to the register block"]
8279 pub const PTR: *const hrpwm0_hrc0::RegisterBlock = 0x4002_1300 as *const _;
8280 #[doc = r"Return the pointer to the register block"]
8281 #[inline(always)]
8282 pub const fn ptr() -> *const hrpwm0_hrc0::RegisterBlock {
8283 Self::PTR
8284 }
8285 #[doc = r" Steal an instance of this peripheral"]
8286 #[doc = r""]
8287 #[doc = r" # Safety"]
8288 #[doc = r""]
8289 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
8290 #[doc = r" that may race with any existing instances, for example by only"]
8291 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
8292 #[doc = r" original peripheral and using critical sections to coordinate"]
8293 #[doc = r" access between multiple new instances."]
8294 #[doc = r""]
8295 #[doc = r" Additionally, other software such as HALs may rely on only one"]
8296 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
8297 #[doc = r" no stolen instances are passed to such software."]
8298 pub unsafe fn steal() -> Self {
8299 Self { _marker: PhantomData }
8300 }
8301}
8302impl Deref for HRPWM0_HRC0 {
8303 type Target = hrpwm0_hrc0::RegisterBlock;
8304 #[inline(always)]
8305 fn deref(&self) -> &Self::Target {
8306 unsafe { &*Self::PTR }
8307 }
8308}
8309impl core::fmt::Debug for HRPWM0_HRC0 {
8310 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
8311 f.debug_struct("HRPWM0_HRC0").finish()
8312 }
8313}
8314#[doc = "High Resolution PWM Unit"]
8315pub mod hrpwm0_hrc0;
8316#[doc = "High Resolution PWM Unit"]
8317pub struct HRPWM0_HRC1 {
8318 _marker: PhantomData<*const ()>,
8319}
8320unsafe impl Send for HRPWM0_HRC1 {}
8321impl HRPWM0_HRC1 {
8322 #[doc = r"Pointer to the register block"]
8323 pub const PTR: *const hrpwm0_hrc0::RegisterBlock = 0x4002_1400 as *const _;
8324 #[doc = r"Return the pointer to the register block"]
8325 #[inline(always)]
8326 pub const fn ptr() -> *const hrpwm0_hrc0::RegisterBlock {
8327 Self::PTR
8328 }
8329 #[doc = r" Steal an instance of this peripheral"]
8330 #[doc = r""]
8331 #[doc = r" # Safety"]
8332 #[doc = r""]
8333 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
8334 #[doc = r" that may race with any existing instances, for example by only"]
8335 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
8336 #[doc = r" original peripheral and using critical sections to coordinate"]
8337 #[doc = r" access between multiple new instances."]
8338 #[doc = r""]
8339 #[doc = r" Additionally, other software such as HALs may rely on only one"]
8340 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
8341 #[doc = r" no stolen instances are passed to such software."]
8342 pub unsafe fn steal() -> Self {
8343 Self { _marker: PhantomData }
8344 }
8345}
8346impl Deref for HRPWM0_HRC1 {
8347 type Target = hrpwm0_hrc0::RegisterBlock;
8348 #[inline(always)]
8349 fn deref(&self) -> &Self::Target {
8350 unsafe { &*Self::PTR }
8351 }
8352}
8353impl core::fmt::Debug for HRPWM0_HRC1 {
8354 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
8355 f.debug_struct("HRPWM0_HRC1").finish()
8356 }
8357}
8358#[doc = "High Resolution PWM Unit"]
8359pub use self::hrpwm0_hrc0 as hrpwm0_hrc1;
8360#[doc = "High Resolution PWM Unit"]
8361pub struct HRPWM0_HRC2 {
8362 _marker: PhantomData<*const ()>,
8363}
8364unsafe impl Send for HRPWM0_HRC2 {}
8365impl HRPWM0_HRC2 {
8366 #[doc = r"Pointer to the register block"]
8367 pub const PTR: *const hrpwm0_hrc0::RegisterBlock = 0x4002_1500 as *const _;
8368 #[doc = r"Return the pointer to the register block"]
8369 #[inline(always)]
8370 pub const fn ptr() -> *const hrpwm0_hrc0::RegisterBlock {
8371 Self::PTR
8372 }
8373 #[doc = r" Steal an instance of this peripheral"]
8374 #[doc = r""]
8375 #[doc = r" # Safety"]
8376 #[doc = r""]
8377 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
8378 #[doc = r" that may race with any existing instances, for example by only"]
8379 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
8380 #[doc = r" original peripheral and using critical sections to coordinate"]
8381 #[doc = r" access between multiple new instances."]
8382 #[doc = r""]
8383 #[doc = r" Additionally, other software such as HALs may rely on only one"]
8384 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
8385 #[doc = r" no stolen instances are passed to such software."]
8386 pub unsafe fn steal() -> Self {
8387 Self { _marker: PhantomData }
8388 }
8389}
8390impl Deref for HRPWM0_HRC2 {
8391 type Target = hrpwm0_hrc0::RegisterBlock;
8392 #[inline(always)]
8393 fn deref(&self) -> &Self::Target {
8394 unsafe { &*Self::PTR }
8395 }
8396}
8397impl core::fmt::Debug for HRPWM0_HRC2 {
8398 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
8399 f.debug_struct("HRPWM0_HRC2").finish()
8400 }
8401}
8402#[doc = "High Resolution PWM Unit"]
8403pub use self::hrpwm0_hrc0 as hrpwm0_hrc2;
8404#[doc = "High Resolution PWM Unit"]
8405pub struct HRPWM0_HRC3 {
8406 _marker: PhantomData<*const ()>,
8407}
8408unsafe impl Send for HRPWM0_HRC3 {}
8409impl HRPWM0_HRC3 {
8410 #[doc = r"Pointer to the register block"]
8411 pub const PTR: *const hrpwm0_hrc0::RegisterBlock = 0x4002_1600 as *const _;
8412 #[doc = r"Return the pointer to the register block"]
8413 #[inline(always)]
8414 pub const fn ptr() -> *const hrpwm0_hrc0::RegisterBlock {
8415 Self::PTR
8416 }
8417 #[doc = r" Steal an instance of this peripheral"]
8418 #[doc = r""]
8419 #[doc = r" # Safety"]
8420 #[doc = r""]
8421 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
8422 #[doc = r" that may race with any existing instances, for example by only"]
8423 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
8424 #[doc = r" original peripheral and using critical sections to coordinate"]
8425 #[doc = r" access between multiple new instances."]
8426 #[doc = r""]
8427 #[doc = r" Additionally, other software such as HALs may rely on only one"]
8428 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
8429 #[doc = r" no stolen instances are passed to such software."]
8430 pub unsafe fn steal() -> Self {
8431 Self { _marker: PhantomData }
8432 }
8433}
8434impl Deref for HRPWM0_HRC3 {
8435 type Target = hrpwm0_hrc0::RegisterBlock;
8436 #[inline(always)]
8437 fn deref(&self) -> &Self::Target {
8438 unsafe { &*Self::PTR }
8439 }
8440}
8441impl core::fmt::Debug for HRPWM0_HRC3 {
8442 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
8443 f.debug_struct("HRPWM0_HRC3").finish()
8444 }
8445}
8446#[doc = "High Resolution PWM Unit"]
8447pub use self::hrpwm0_hrc0 as hrpwm0_hrc3;
8448#[doc = "Position Interface 0"]
8449pub struct POSIF0 {
8450 _marker: PhantomData<*const ()>,
8451}
8452unsafe impl Send for POSIF0 {}
8453impl POSIF0 {
8454 #[doc = r"Pointer to the register block"]
8455 pub const PTR: *const posif0::RegisterBlock = 0x4002_8000 as *const _;
8456 #[doc = r"Return the pointer to the register block"]
8457 #[inline(always)]
8458 pub const fn ptr() -> *const posif0::RegisterBlock {
8459 Self::PTR
8460 }
8461 #[doc = r" Steal an instance of this peripheral"]
8462 #[doc = r""]
8463 #[doc = r" # Safety"]
8464 #[doc = r""]
8465 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
8466 #[doc = r" that may race with any existing instances, for example by only"]
8467 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
8468 #[doc = r" original peripheral and using critical sections to coordinate"]
8469 #[doc = r" access between multiple new instances."]
8470 #[doc = r""]
8471 #[doc = r" Additionally, other software such as HALs may rely on only one"]
8472 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
8473 #[doc = r" no stolen instances are passed to such software."]
8474 pub unsafe fn steal() -> Self {
8475 Self { _marker: PhantomData }
8476 }
8477}
8478impl Deref for POSIF0 {
8479 type Target = posif0::RegisterBlock;
8480 #[inline(always)]
8481 fn deref(&self) -> &Self::Target {
8482 unsafe { &*Self::PTR }
8483 }
8484}
8485impl core::fmt::Debug for POSIF0 {
8486 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
8487 f.debug_struct("POSIF0").finish()
8488 }
8489}
8490#[doc = "Position Interface 0"]
8491pub mod posif0;
8492#[doc = "Position Interface 1"]
8493pub struct POSIF1 {
8494 _marker: PhantomData<*const ()>,
8495}
8496unsafe impl Send for POSIF1 {}
8497impl POSIF1 {
8498 #[doc = r"Pointer to the register block"]
8499 pub const PTR: *const posif0::RegisterBlock = 0x4002_c000 as *const _;
8500 #[doc = r"Return the pointer to the register block"]
8501 #[inline(always)]
8502 pub const fn ptr() -> *const posif0::RegisterBlock {
8503 Self::PTR
8504 }
8505 #[doc = r" Steal an instance of this peripheral"]
8506 #[doc = r""]
8507 #[doc = r" # Safety"]
8508 #[doc = r""]
8509 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
8510 #[doc = r" that may race with any existing instances, for example by only"]
8511 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
8512 #[doc = r" original peripheral and using critical sections to coordinate"]
8513 #[doc = r" access between multiple new instances."]
8514 #[doc = r""]
8515 #[doc = r" Additionally, other software such as HALs may rely on only one"]
8516 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
8517 #[doc = r" no stolen instances are passed to such software."]
8518 pub unsafe fn steal() -> Self {
8519 Self { _marker: PhantomData }
8520 }
8521}
8522impl Deref for POSIF1 {
8523 type Target = posif0::RegisterBlock;
8524 #[inline(always)]
8525 fn deref(&self) -> &Self::Target {
8526 unsafe { &*Self::PTR }
8527 }
8528}
8529impl core::fmt::Debug for POSIF1 {
8530 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
8531 f.debug_struct("POSIF1").finish()
8532 }
8533}
8534#[doc = "Position Interface 1"]
8535pub use self::posif0 as posif1;
8536#[doc = "Port 0"]
8537pub struct PORT0 {
8538 _marker: PhantomData<*const ()>,
8539}
8540unsafe impl Send for PORT0 {}
8541impl PORT0 {
8542 #[doc = r"Pointer to the register block"]
8543 pub const PTR: *const port0::RegisterBlock = 0x4802_8000 as *const _;
8544 #[doc = r"Return the pointer to the register block"]
8545 #[inline(always)]
8546 pub const fn ptr() -> *const port0::RegisterBlock {
8547 Self::PTR
8548 }
8549 #[doc = r" Steal an instance of this peripheral"]
8550 #[doc = r""]
8551 #[doc = r" # Safety"]
8552 #[doc = r""]
8553 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
8554 #[doc = r" that may race with any existing instances, for example by only"]
8555 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
8556 #[doc = r" original peripheral and using critical sections to coordinate"]
8557 #[doc = r" access between multiple new instances."]
8558 #[doc = r""]
8559 #[doc = r" Additionally, other software such as HALs may rely on only one"]
8560 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
8561 #[doc = r" no stolen instances are passed to such software."]
8562 pub unsafe fn steal() -> Self {
8563 Self { _marker: PhantomData }
8564 }
8565}
8566impl Deref for PORT0 {
8567 type Target = port0::RegisterBlock;
8568 #[inline(always)]
8569 fn deref(&self) -> &Self::Target {
8570 unsafe { &*Self::PTR }
8571 }
8572}
8573impl core::fmt::Debug for PORT0 {
8574 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
8575 f.debug_struct("PORT0").finish()
8576 }
8577}
8578#[doc = "Port 0"]
8579pub mod port0;
8580#[doc = "Port 1"]
8581pub struct PORT1 {
8582 _marker: PhantomData<*const ()>,
8583}
8584unsafe impl Send for PORT1 {}
8585impl PORT1 {
8586 #[doc = r"Pointer to the register block"]
8587 pub const PTR: *const port1::RegisterBlock = 0x4802_8100 as *const _;
8588 #[doc = r"Return the pointer to the register block"]
8589 #[inline(always)]
8590 pub const fn ptr() -> *const port1::RegisterBlock {
8591 Self::PTR
8592 }
8593 #[doc = r" Steal an instance of this peripheral"]
8594 #[doc = r""]
8595 #[doc = r" # Safety"]
8596 #[doc = r""]
8597 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
8598 #[doc = r" that may race with any existing instances, for example by only"]
8599 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
8600 #[doc = r" original peripheral and using critical sections to coordinate"]
8601 #[doc = r" access between multiple new instances."]
8602 #[doc = r""]
8603 #[doc = r" Additionally, other software such as HALs may rely on only one"]
8604 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
8605 #[doc = r" no stolen instances are passed to such software."]
8606 pub unsafe fn steal() -> Self {
8607 Self { _marker: PhantomData }
8608 }
8609}
8610impl Deref for PORT1 {
8611 type Target = port1::RegisterBlock;
8612 #[inline(always)]
8613 fn deref(&self) -> &Self::Target {
8614 unsafe { &*Self::PTR }
8615 }
8616}
8617impl core::fmt::Debug for PORT1 {
8618 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
8619 f.debug_struct("PORT1").finish()
8620 }
8621}
8622#[doc = "Port 1"]
8623pub mod port1;
8624#[doc = "Port 2"]
8625pub struct PORT2 {
8626 _marker: PhantomData<*const ()>,
8627}
8628unsafe impl Send for PORT2 {}
8629impl PORT2 {
8630 #[doc = r"Pointer to the register block"]
8631 pub const PTR: *const port2::RegisterBlock = 0x4802_8200 as *const _;
8632 #[doc = r"Return the pointer to the register block"]
8633 #[inline(always)]
8634 pub const fn ptr() -> *const port2::RegisterBlock {
8635 Self::PTR
8636 }
8637 #[doc = r" Steal an instance of this peripheral"]
8638 #[doc = r""]
8639 #[doc = r" # Safety"]
8640 #[doc = r""]
8641 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
8642 #[doc = r" that may race with any existing instances, for example by only"]
8643 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
8644 #[doc = r" original peripheral and using critical sections to coordinate"]
8645 #[doc = r" access between multiple new instances."]
8646 #[doc = r""]
8647 #[doc = r" Additionally, other software such as HALs may rely on only one"]
8648 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
8649 #[doc = r" no stolen instances are passed to such software."]
8650 pub unsafe fn steal() -> Self {
8651 Self { _marker: PhantomData }
8652 }
8653}
8654impl Deref for PORT2 {
8655 type Target = port2::RegisterBlock;
8656 #[inline(always)]
8657 fn deref(&self) -> &Self::Target {
8658 unsafe { &*Self::PTR }
8659 }
8660}
8661impl core::fmt::Debug for PORT2 {
8662 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
8663 f.debug_struct("PORT2").finish()
8664 }
8665}
8666#[doc = "Port 2"]
8667pub mod port2;
8668#[doc = "Port 3"]
8669pub struct PORT3 {
8670 _marker: PhantomData<*const ()>,
8671}
8672unsafe impl Send for PORT3 {}
8673impl PORT3 {
8674 #[doc = r"Pointer to the register block"]
8675 pub const PTR: *const port3::RegisterBlock = 0x4802_8300 as *const _;
8676 #[doc = r"Return the pointer to the register block"]
8677 #[inline(always)]
8678 pub const fn ptr() -> *const port3::RegisterBlock {
8679 Self::PTR
8680 }
8681 #[doc = r" Steal an instance of this peripheral"]
8682 #[doc = r""]
8683 #[doc = r" # Safety"]
8684 #[doc = r""]
8685 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
8686 #[doc = r" that may race with any existing instances, for example by only"]
8687 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
8688 #[doc = r" original peripheral and using critical sections to coordinate"]
8689 #[doc = r" access between multiple new instances."]
8690 #[doc = r""]
8691 #[doc = r" Additionally, other software such as HALs may rely on only one"]
8692 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
8693 #[doc = r" no stolen instances are passed to such software."]
8694 pub unsafe fn steal() -> Self {
8695 Self { _marker: PhantomData }
8696 }
8697}
8698impl Deref for PORT3 {
8699 type Target = port3::RegisterBlock;
8700 #[inline(always)]
8701 fn deref(&self) -> &Self::Target {
8702 unsafe { &*Self::PTR }
8703 }
8704}
8705impl core::fmt::Debug for PORT3 {
8706 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
8707 f.debug_struct("PORT3").finish()
8708 }
8709}
8710#[doc = "Port 3"]
8711pub mod port3;
8712#[doc = "Port 4"]
8713pub struct PORT4 {
8714 _marker: PhantomData<*const ()>,
8715}
8716unsafe impl Send for PORT4 {}
8717impl PORT4 {
8718 #[doc = r"Pointer to the register block"]
8719 pub const PTR: *const port4::RegisterBlock = 0x4802_8400 as *const _;
8720 #[doc = r"Return the pointer to the register block"]
8721 #[inline(always)]
8722 pub const fn ptr() -> *const port4::RegisterBlock {
8723 Self::PTR
8724 }
8725 #[doc = r" Steal an instance of this peripheral"]
8726 #[doc = r""]
8727 #[doc = r" # Safety"]
8728 #[doc = r""]
8729 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
8730 #[doc = r" that may race with any existing instances, for example by only"]
8731 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
8732 #[doc = r" original peripheral and using critical sections to coordinate"]
8733 #[doc = r" access between multiple new instances."]
8734 #[doc = r""]
8735 #[doc = r" Additionally, other software such as HALs may rely on only one"]
8736 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
8737 #[doc = r" no stolen instances are passed to such software."]
8738 pub unsafe fn steal() -> Self {
8739 Self { _marker: PhantomData }
8740 }
8741}
8742impl Deref for PORT4 {
8743 type Target = port4::RegisterBlock;
8744 #[inline(always)]
8745 fn deref(&self) -> &Self::Target {
8746 unsafe { &*Self::PTR }
8747 }
8748}
8749impl core::fmt::Debug for PORT4 {
8750 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
8751 f.debug_struct("PORT4").finish()
8752 }
8753}
8754#[doc = "Port 4"]
8755pub mod port4;
8756#[doc = "Port 5"]
8757pub struct PORT5 {
8758 _marker: PhantomData<*const ()>,
8759}
8760unsafe impl Send for PORT5 {}
8761impl PORT5 {
8762 #[doc = r"Pointer to the register block"]
8763 pub const PTR: *const port5::RegisterBlock = 0x4802_8500 as *const _;
8764 #[doc = r"Return the pointer to the register block"]
8765 #[inline(always)]
8766 pub const fn ptr() -> *const port5::RegisterBlock {
8767 Self::PTR
8768 }
8769 #[doc = r" Steal an instance of this peripheral"]
8770 #[doc = r""]
8771 #[doc = r" # Safety"]
8772 #[doc = r""]
8773 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
8774 #[doc = r" that may race with any existing instances, for example by only"]
8775 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
8776 #[doc = r" original peripheral and using critical sections to coordinate"]
8777 #[doc = r" access between multiple new instances."]
8778 #[doc = r""]
8779 #[doc = r" Additionally, other software such as HALs may rely on only one"]
8780 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
8781 #[doc = r" no stolen instances are passed to such software."]
8782 pub unsafe fn steal() -> Self {
8783 Self { _marker: PhantomData }
8784 }
8785}
8786impl Deref for PORT5 {
8787 type Target = port5::RegisterBlock;
8788 #[inline(always)]
8789 fn deref(&self) -> &Self::Target {
8790 unsafe { &*Self::PTR }
8791 }
8792}
8793impl core::fmt::Debug for PORT5 {
8794 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
8795 f.debug_struct("PORT5").finish()
8796 }
8797}
8798#[doc = "Port 5"]
8799pub mod port5;
8800#[doc = "Port 14"]
8801pub struct PORT14 {
8802 _marker: PhantomData<*const ()>,
8803}
8804unsafe impl Send for PORT14 {}
8805impl PORT14 {
8806 #[doc = r"Pointer to the register block"]
8807 pub const PTR: *const port14::RegisterBlock = 0x4802_8e00 as *const _;
8808 #[doc = r"Return the pointer to the register block"]
8809 #[inline(always)]
8810 pub const fn ptr() -> *const port14::RegisterBlock {
8811 Self::PTR
8812 }
8813 #[doc = r" Steal an instance of this peripheral"]
8814 #[doc = r""]
8815 #[doc = r" # Safety"]
8816 #[doc = r""]
8817 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
8818 #[doc = r" that may race with any existing instances, for example by only"]
8819 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
8820 #[doc = r" original peripheral and using critical sections to coordinate"]
8821 #[doc = r" access between multiple new instances."]
8822 #[doc = r""]
8823 #[doc = r" Additionally, other software such as HALs may rely on only one"]
8824 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
8825 #[doc = r" no stolen instances are passed to such software."]
8826 pub unsafe fn steal() -> Self {
8827 Self { _marker: PhantomData }
8828 }
8829}
8830impl Deref for PORT14 {
8831 type Target = port14::RegisterBlock;
8832 #[inline(always)]
8833 fn deref(&self) -> &Self::Target {
8834 unsafe { &*Self::PTR }
8835 }
8836}
8837impl core::fmt::Debug for PORT14 {
8838 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
8839 f.debug_struct("PORT14").finish()
8840 }
8841}
8842#[doc = "Port 14"]
8843pub mod port14;
8844#[doc = "Port 15"]
8845pub struct PORT15 {
8846 _marker: PhantomData<*const ()>,
8847}
8848unsafe impl Send for PORT15 {}
8849impl PORT15 {
8850 #[doc = r"Pointer to the register block"]
8851 pub const PTR: *const port15::RegisterBlock = 0x4802_8f00 as *const _;
8852 #[doc = r"Return the pointer to the register block"]
8853 #[inline(always)]
8854 pub const fn ptr() -> *const port15::RegisterBlock {
8855 Self::PTR
8856 }
8857 #[doc = r" Steal an instance of this peripheral"]
8858 #[doc = r""]
8859 #[doc = r" # Safety"]
8860 #[doc = r""]
8861 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
8862 #[doc = r" that may race with any existing instances, for example by only"]
8863 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
8864 #[doc = r" original peripheral and using critical sections to coordinate"]
8865 #[doc = r" access between multiple new instances."]
8866 #[doc = r""]
8867 #[doc = r" Additionally, other software such as HALs may rely on only one"]
8868 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
8869 #[doc = r" no stolen instances are passed to such software."]
8870 pub unsafe fn steal() -> Self {
8871 Self { _marker: PhantomData }
8872 }
8873}
8874impl Deref for PORT15 {
8875 type Target = port15::RegisterBlock;
8876 #[inline(always)]
8877 fn deref(&self) -> &Self::Target {
8878 unsafe { &*Self::PTR }
8879 }
8880}
8881impl core::fmt::Debug for PORT15 {
8882 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
8883 f.debug_struct("PORT15").finish()
8884 }
8885}
8886#[doc = "Port 15"]
8887pub mod port15;
8888#[no_mangle]
8889static mut DEVICE_PERIPHERALS: bool = false;
8890#[doc = r" All the peripherals."]
8891#[allow(non_snake_case)]
8892pub struct Peripherals {
8893 #[doc = "PPB"]
8894 pub PPB: PPB,
8895 #[doc = "DLR"]
8896 pub DLR: DLR,
8897 #[doc = "ERU0"]
8898 pub ERU0: ERU0,
8899 #[doc = "ERU1"]
8900 pub ERU1: ERU1,
8901 #[doc = "GPDMA0"]
8902 pub GPDMA0: GPDMA0,
8903 #[doc = "GPDMA0_CH0"]
8904 pub GPDMA0_CH0: GPDMA0_CH0,
8905 #[doc = "GPDMA0_CH1"]
8906 pub GPDMA0_CH1: GPDMA0_CH1,
8907 #[doc = "GPDMA0_CH2"]
8908 pub GPDMA0_CH2: GPDMA0_CH2,
8909 #[doc = "GPDMA0_CH3"]
8910 pub GPDMA0_CH3: GPDMA0_CH3,
8911 #[doc = "GPDMA0_CH4"]
8912 pub GPDMA0_CH4: GPDMA0_CH4,
8913 #[doc = "GPDMA0_CH5"]
8914 pub GPDMA0_CH5: GPDMA0_CH5,
8915 #[doc = "GPDMA0_CH6"]
8916 pub GPDMA0_CH6: GPDMA0_CH6,
8917 #[doc = "GPDMA0_CH7"]
8918 pub GPDMA0_CH7: GPDMA0_CH7,
8919 #[doc = "FCE"]
8920 pub FCE: FCE,
8921 #[doc = "FCE_KE0"]
8922 pub FCE_KE0: FCE_KE0,
8923 #[doc = "FCE_KE1"]
8924 pub FCE_KE1: FCE_KE1,
8925 #[doc = "FCE_KE2"]
8926 pub FCE_KE2: FCE_KE2,
8927 #[doc = "FCE_KE3"]
8928 pub FCE_KE3: FCE_KE3,
8929 #[doc = "PBA0"]
8930 pub PBA0: PBA0,
8931 #[doc = "PBA1"]
8932 pub PBA1: PBA1,
8933 #[doc = "FLASH0"]
8934 pub FLASH0: FLASH0,
8935 #[doc = "PREF"]
8936 pub PREF: PREF,
8937 #[doc = "PMU0"]
8938 pub PMU0: PMU0,
8939 #[doc = "WDT"]
8940 pub WDT: WDT,
8941 #[doc = "RTC"]
8942 pub RTC: RTC,
8943 #[doc = "SCU_CLK"]
8944 pub SCU_CLK: SCU_CLK,
8945 #[doc = "SCU_OSC"]
8946 pub SCU_OSC: SCU_OSC,
8947 #[doc = "SCU_PLL"]
8948 pub SCU_PLL: SCU_PLL,
8949 #[doc = "SCU_GENERAL"]
8950 pub SCU_GENERAL: SCU_GENERAL,
8951 #[doc = "SCU_INTERRUPT"]
8952 pub SCU_INTERRUPT: SCU_INTERRUPT,
8953 #[doc = "SCU_PARITY"]
8954 pub SCU_PARITY: SCU_PARITY,
8955 #[doc = "SCU_TRAP"]
8956 pub SCU_TRAP: SCU_TRAP,
8957 #[doc = "SCU_HIBERNATE"]
8958 pub SCU_HIBERNATE: SCU_HIBERNATE,
8959 #[doc = "SCU_POWER"]
8960 pub SCU_POWER: SCU_POWER,
8961 #[doc = "SCU_RESET"]
8962 pub SCU_RESET: SCU_RESET,
8963 #[doc = "LEDTS0"]
8964 pub LEDTS0: LEDTS0,
8965 #[doc = "ETH0_CON"]
8966 pub ETH0_CON: ETH0_CON,
8967 #[doc = "ETH0"]
8968 pub ETH0: ETH0,
8969 #[doc = "USB0"]
8970 pub USB0: USB0,
8971 #[doc = "USB0_EP0"]
8972 pub USB0_EP0: USB0_EP0,
8973 #[doc = "USB0_EP1"]
8974 pub USB0_EP1: USB0_EP1,
8975 #[doc = "USB0_EP2"]
8976 pub USB0_EP2: USB0_EP2,
8977 #[doc = "USB0_EP3"]
8978 pub USB0_EP3: USB0_EP3,
8979 #[doc = "USB0_EP4"]
8980 pub USB0_EP4: USB0_EP4,
8981 #[doc = "USB0_EP5"]
8982 pub USB0_EP5: USB0_EP5,
8983 #[doc = "USB0_EP6"]
8984 pub USB0_EP6: USB0_EP6,
8985 #[doc = "USB0_CH0"]
8986 pub USB0_CH0: USB0_CH0,
8987 #[doc = "USB0_CH1"]
8988 pub USB0_CH1: USB0_CH1,
8989 #[doc = "USB0_CH2"]
8990 pub USB0_CH2: USB0_CH2,
8991 #[doc = "USB0_CH3"]
8992 pub USB0_CH3: USB0_CH3,
8993 #[doc = "USB0_CH4"]
8994 pub USB0_CH4: USB0_CH4,
8995 #[doc = "USB0_CH5"]
8996 pub USB0_CH5: USB0_CH5,
8997 #[doc = "USB0_CH6"]
8998 pub USB0_CH6: USB0_CH6,
8999 #[doc = "USB0_CH7"]
9000 pub USB0_CH7: USB0_CH7,
9001 #[doc = "USB0_CH8"]
9002 pub USB0_CH8: USB0_CH8,
9003 #[doc = "USB0_CH9"]
9004 pub USB0_CH9: USB0_CH9,
9005 #[doc = "USB0_CH10"]
9006 pub USB0_CH10: USB0_CH10,
9007 #[doc = "USB0_CH11"]
9008 pub USB0_CH11: USB0_CH11,
9009 #[doc = "USB0_CH12"]
9010 pub USB0_CH12: USB0_CH12,
9011 #[doc = "USB0_CH13"]
9012 pub USB0_CH13: USB0_CH13,
9013 #[doc = "USIC0"]
9014 pub USIC0: USIC0,
9015 #[doc = "USIC1"]
9016 pub USIC1: USIC1,
9017 #[doc = "USIC0_CH0"]
9018 pub USIC0_CH0: USIC0_CH0,
9019 #[doc = "USIC0_CH1"]
9020 pub USIC0_CH1: USIC0_CH1,
9021 #[doc = "USIC1_CH0"]
9022 pub USIC1_CH0: USIC1_CH0,
9023 #[doc = "USIC1_CH1"]
9024 pub USIC1_CH1: USIC1_CH1,
9025 #[doc = "CAN"]
9026 pub CAN: CAN,
9027 #[doc = "CAN_NODE0"]
9028 pub CAN_NODE0: CAN_NODE0,
9029 #[doc = "CAN_NODE1"]
9030 pub CAN_NODE1: CAN_NODE1,
9031 #[doc = "CAN_MO0"]
9032 pub CAN_MO0: CAN_MO0,
9033 #[doc = "CAN_MO1"]
9034 pub CAN_MO1: CAN_MO1,
9035 #[doc = "CAN_MO2"]
9036 pub CAN_MO2: CAN_MO2,
9037 #[doc = "CAN_MO3"]
9038 pub CAN_MO3: CAN_MO3,
9039 #[doc = "CAN_MO4"]
9040 pub CAN_MO4: CAN_MO4,
9041 #[doc = "CAN_MO5"]
9042 pub CAN_MO5: CAN_MO5,
9043 #[doc = "CAN_MO6"]
9044 pub CAN_MO6: CAN_MO6,
9045 #[doc = "CAN_MO7"]
9046 pub CAN_MO7: CAN_MO7,
9047 #[doc = "CAN_MO8"]
9048 pub CAN_MO8: CAN_MO8,
9049 #[doc = "CAN_MO9"]
9050 pub CAN_MO9: CAN_MO9,
9051 #[doc = "CAN_MO10"]
9052 pub CAN_MO10: CAN_MO10,
9053 #[doc = "CAN_MO11"]
9054 pub CAN_MO11: CAN_MO11,
9055 #[doc = "CAN_MO12"]
9056 pub CAN_MO12: CAN_MO12,
9057 #[doc = "CAN_MO13"]
9058 pub CAN_MO13: CAN_MO13,
9059 #[doc = "CAN_MO14"]
9060 pub CAN_MO14: CAN_MO14,
9061 #[doc = "CAN_MO15"]
9062 pub CAN_MO15: CAN_MO15,
9063 #[doc = "CAN_MO16"]
9064 pub CAN_MO16: CAN_MO16,
9065 #[doc = "CAN_MO17"]
9066 pub CAN_MO17: CAN_MO17,
9067 #[doc = "CAN_MO18"]
9068 pub CAN_MO18: CAN_MO18,
9069 #[doc = "CAN_MO19"]
9070 pub CAN_MO19: CAN_MO19,
9071 #[doc = "CAN_MO20"]
9072 pub CAN_MO20: CAN_MO20,
9073 #[doc = "CAN_MO21"]
9074 pub CAN_MO21: CAN_MO21,
9075 #[doc = "CAN_MO22"]
9076 pub CAN_MO22: CAN_MO22,
9077 #[doc = "CAN_MO23"]
9078 pub CAN_MO23: CAN_MO23,
9079 #[doc = "CAN_MO24"]
9080 pub CAN_MO24: CAN_MO24,
9081 #[doc = "CAN_MO25"]
9082 pub CAN_MO25: CAN_MO25,
9083 #[doc = "CAN_MO26"]
9084 pub CAN_MO26: CAN_MO26,
9085 #[doc = "CAN_MO27"]
9086 pub CAN_MO27: CAN_MO27,
9087 #[doc = "CAN_MO28"]
9088 pub CAN_MO28: CAN_MO28,
9089 #[doc = "CAN_MO29"]
9090 pub CAN_MO29: CAN_MO29,
9091 #[doc = "CAN_MO30"]
9092 pub CAN_MO30: CAN_MO30,
9093 #[doc = "CAN_MO31"]
9094 pub CAN_MO31: CAN_MO31,
9095 #[doc = "CAN_MO32"]
9096 pub CAN_MO32: CAN_MO32,
9097 #[doc = "CAN_MO33"]
9098 pub CAN_MO33: CAN_MO33,
9099 #[doc = "CAN_MO34"]
9100 pub CAN_MO34: CAN_MO34,
9101 #[doc = "CAN_MO35"]
9102 pub CAN_MO35: CAN_MO35,
9103 #[doc = "CAN_MO36"]
9104 pub CAN_MO36: CAN_MO36,
9105 #[doc = "CAN_MO37"]
9106 pub CAN_MO37: CAN_MO37,
9107 #[doc = "CAN_MO38"]
9108 pub CAN_MO38: CAN_MO38,
9109 #[doc = "CAN_MO39"]
9110 pub CAN_MO39: CAN_MO39,
9111 #[doc = "CAN_MO40"]
9112 pub CAN_MO40: CAN_MO40,
9113 #[doc = "CAN_MO41"]
9114 pub CAN_MO41: CAN_MO41,
9115 #[doc = "CAN_MO42"]
9116 pub CAN_MO42: CAN_MO42,
9117 #[doc = "CAN_MO43"]
9118 pub CAN_MO43: CAN_MO43,
9119 #[doc = "CAN_MO44"]
9120 pub CAN_MO44: CAN_MO44,
9121 #[doc = "CAN_MO45"]
9122 pub CAN_MO45: CAN_MO45,
9123 #[doc = "CAN_MO46"]
9124 pub CAN_MO46: CAN_MO46,
9125 #[doc = "CAN_MO47"]
9126 pub CAN_MO47: CAN_MO47,
9127 #[doc = "CAN_MO48"]
9128 pub CAN_MO48: CAN_MO48,
9129 #[doc = "CAN_MO49"]
9130 pub CAN_MO49: CAN_MO49,
9131 #[doc = "CAN_MO50"]
9132 pub CAN_MO50: CAN_MO50,
9133 #[doc = "CAN_MO51"]
9134 pub CAN_MO51: CAN_MO51,
9135 #[doc = "CAN_MO52"]
9136 pub CAN_MO52: CAN_MO52,
9137 #[doc = "CAN_MO53"]
9138 pub CAN_MO53: CAN_MO53,
9139 #[doc = "CAN_MO54"]
9140 pub CAN_MO54: CAN_MO54,
9141 #[doc = "CAN_MO55"]
9142 pub CAN_MO55: CAN_MO55,
9143 #[doc = "CAN_MO56"]
9144 pub CAN_MO56: CAN_MO56,
9145 #[doc = "CAN_MO57"]
9146 pub CAN_MO57: CAN_MO57,
9147 #[doc = "CAN_MO58"]
9148 pub CAN_MO58: CAN_MO58,
9149 #[doc = "CAN_MO59"]
9150 pub CAN_MO59: CAN_MO59,
9151 #[doc = "CAN_MO60"]
9152 pub CAN_MO60: CAN_MO60,
9153 #[doc = "CAN_MO61"]
9154 pub CAN_MO61: CAN_MO61,
9155 #[doc = "CAN_MO62"]
9156 pub CAN_MO62: CAN_MO62,
9157 #[doc = "CAN_MO63"]
9158 pub CAN_MO63: CAN_MO63,
9159 #[doc = "VADC"]
9160 pub VADC: VADC,
9161 #[doc = "VADC_G0"]
9162 pub VADC_G0: VADC_G0,
9163 #[doc = "VADC_G1"]
9164 pub VADC_G1: VADC_G1,
9165 #[doc = "VADC_G2"]
9166 pub VADC_G2: VADC_G2,
9167 #[doc = "VADC_G3"]
9168 pub VADC_G3: VADC_G3,
9169 #[doc = "DSD"]
9170 pub DSD: DSD,
9171 #[doc = "DSD_CH0"]
9172 pub DSD_CH0: DSD_CH0,
9173 #[doc = "DSD_CH1"]
9174 pub DSD_CH1: DSD_CH1,
9175 #[doc = "DSD_CH2"]
9176 pub DSD_CH2: DSD_CH2,
9177 #[doc = "DSD_CH3"]
9178 pub DSD_CH3: DSD_CH3,
9179 #[doc = "DAC"]
9180 pub DAC: DAC,
9181 #[doc = "CCU40"]
9182 pub CCU40: CCU40,
9183 #[doc = "CCU41"]
9184 pub CCU41: CCU41,
9185 #[doc = "CCU42"]
9186 pub CCU42: CCU42,
9187 #[doc = "CCU43"]
9188 pub CCU43: CCU43,
9189 #[doc = "CCU40_CC40"]
9190 pub CCU40_CC40: CCU40_CC40,
9191 #[doc = "CCU40_CC41"]
9192 pub CCU40_CC41: CCU40_CC41,
9193 #[doc = "CCU40_CC42"]
9194 pub CCU40_CC42: CCU40_CC42,
9195 #[doc = "CCU40_CC43"]
9196 pub CCU40_CC43: CCU40_CC43,
9197 #[doc = "CCU41_CC40"]
9198 pub CCU41_CC40: CCU41_CC40,
9199 #[doc = "CCU41_CC41"]
9200 pub CCU41_CC41: CCU41_CC41,
9201 #[doc = "CCU41_CC42"]
9202 pub CCU41_CC42: CCU41_CC42,
9203 #[doc = "CCU41_CC43"]
9204 pub CCU41_CC43: CCU41_CC43,
9205 #[doc = "CCU42_CC40"]
9206 pub CCU42_CC40: CCU42_CC40,
9207 #[doc = "CCU42_CC41"]
9208 pub CCU42_CC41: CCU42_CC41,
9209 #[doc = "CCU42_CC42"]
9210 pub CCU42_CC42: CCU42_CC42,
9211 #[doc = "CCU42_CC43"]
9212 pub CCU42_CC43: CCU42_CC43,
9213 #[doc = "CCU43_CC40"]
9214 pub CCU43_CC40: CCU43_CC40,
9215 #[doc = "CCU43_CC41"]
9216 pub CCU43_CC41: CCU43_CC41,
9217 #[doc = "CCU43_CC42"]
9218 pub CCU43_CC42: CCU43_CC42,
9219 #[doc = "CCU43_CC43"]
9220 pub CCU43_CC43: CCU43_CC43,
9221 #[doc = "CCU80"]
9222 pub CCU80: CCU80,
9223 #[doc = "CCU81"]
9224 pub CCU81: CCU81,
9225 #[doc = "CCU80_CC80"]
9226 pub CCU80_CC80: CCU80_CC80,
9227 #[doc = "CCU80_CC81"]
9228 pub CCU80_CC81: CCU80_CC81,
9229 #[doc = "CCU80_CC82"]
9230 pub CCU80_CC82: CCU80_CC82,
9231 #[doc = "CCU80_CC83"]
9232 pub CCU80_CC83: CCU80_CC83,
9233 #[doc = "CCU81_CC80"]
9234 pub CCU81_CC80: CCU81_CC80,
9235 #[doc = "CCU81_CC81"]
9236 pub CCU81_CC81: CCU81_CC81,
9237 #[doc = "CCU81_CC82"]
9238 pub CCU81_CC82: CCU81_CC82,
9239 #[doc = "CCU81_CC83"]
9240 pub CCU81_CC83: CCU81_CC83,
9241 #[doc = "HRPWM0"]
9242 pub HRPWM0: HRPWM0,
9243 #[doc = "HRPWM0_CSG0"]
9244 pub HRPWM0_CSG0: HRPWM0_CSG0,
9245 #[doc = "HRPWM0_CSG1"]
9246 pub HRPWM0_CSG1: HRPWM0_CSG1,
9247 #[doc = "HRPWM0_CSG2"]
9248 pub HRPWM0_CSG2: HRPWM0_CSG2,
9249 #[doc = "HRPWM0_HRC0"]
9250 pub HRPWM0_HRC0: HRPWM0_HRC0,
9251 #[doc = "HRPWM0_HRC1"]
9252 pub HRPWM0_HRC1: HRPWM0_HRC1,
9253 #[doc = "HRPWM0_HRC2"]
9254 pub HRPWM0_HRC2: HRPWM0_HRC2,
9255 #[doc = "HRPWM0_HRC3"]
9256 pub HRPWM0_HRC3: HRPWM0_HRC3,
9257 #[doc = "POSIF0"]
9258 pub POSIF0: POSIF0,
9259 #[doc = "POSIF1"]
9260 pub POSIF1: POSIF1,
9261 #[doc = "PORT0"]
9262 pub PORT0: PORT0,
9263 #[doc = "PORT1"]
9264 pub PORT1: PORT1,
9265 #[doc = "PORT2"]
9266 pub PORT2: PORT2,
9267 #[doc = "PORT3"]
9268 pub PORT3: PORT3,
9269 #[doc = "PORT4"]
9270 pub PORT4: PORT4,
9271 #[doc = "PORT5"]
9272 pub PORT5: PORT5,
9273 #[doc = "PORT14"]
9274 pub PORT14: PORT14,
9275 #[doc = "PORT15"]
9276 pub PORT15: PORT15,
9277}
9278impl Peripherals {
9279 #[doc = r" Returns all the peripherals *once*."]
9280 #[cfg(feature = "critical-section")]
9281 #[inline]
9282 pub fn take() -> Option<Self> {
9283 critical_section::with(|_| {
9284 if unsafe { DEVICE_PERIPHERALS } {
9285 return None;
9286 }
9287 Some(unsafe { Peripherals::steal() })
9288 })
9289 }
9290 #[doc = r" Unchecked version of `Peripherals::take`."]
9291 #[doc = r""]
9292 #[doc = r" # Safety"]
9293 #[doc = r""]
9294 #[doc = r" Each of the returned peripherals must be used at most once."]
9295 #[inline]
9296 pub unsafe fn steal() -> Self {
9297 DEVICE_PERIPHERALS = true;
9298 Peripherals {
9299 PPB: PPB::steal(),
9300 DLR: DLR::steal(),
9301 ERU0: ERU0::steal(),
9302 ERU1: ERU1::steal(),
9303 GPDMA0: GPDMA0::steal(),
9304 GPDMA0_CH0: GPDMA0_CH0::steal(),
9305 GPDMA0_CH1: GPDMA0_CH1::steal(),
9306 GPDMA0_CH2: GPDMA0_CH2::steal(),
9307 GPDMA0_CH3: GPDMA0_CH3::steal(),
9308 GPDMA0_CH4: GPDMA0_CH4::steal(),
9309 GPDMA0_CH5: GPDMA0_CH5::steal(),
9310 GPDMA0_CH6: GPDMA0_CH6::steal(),
9311 GPDMA0_CH7: GPDMA0_CH7::steal(),
9312 FCE: FCE::steal(),
9313 FCE_KE0: FCE_KE0::steal(),
9314 FCE_KE1: FCE_KE1::steal(),
9315 FCE_KE2: FCE_KE2::steal(),
9316 FCE_KE3: FCE_KE3::steal(),
9317 PBA0: PBA0::steal(),
9318 PBA1: PBA1::steal(),
9319 FLASH0: FLASH0::steal(),
9320 PREF: PREF::steal(),
9321 PMU0: PMU0::steal(),
9322 WDT: WDT::steal(),
9323 RTC: RTC::steal(),
9324 SCU_CLK: SCU_CLK::steal(),
9325 SCU_OSC: SCU_OSC::steal(),
9326 SCU_PLL: SCU_PLL::steal(),
9327 SCU_GENERAL: SCU_GENERAL::steal(),
9328 SCU_INTERRUPT: SCU_INTERRUPT::steal(),
9329 SCU_PARITY: SCU_PARITY::steal(),
9330 SCU_TRAP: SCU_TRAP::steal(),
9331 SCU_HIBERNATE: SCU_HIBERNATE::steal(),
9332 SCU_POWER: SCU_POWER::steal(),
9333 SCU_RESET: SCU_RESET::steal(),
9334 LEDTS0: LEDTS0::steal(),
9335 ETH0_CON: ETH0_CON::steal(),
9336 ETH0: ETH0::steal(),
9337 USB0: USB0::steal(),
9338 USB0_EP0: USB0_EP0::steal(),
9339 USB0_EP1: USB0_EP1::steal(),
9340 USB0_EP2: USB0_EP2::steal(),
9341 USB0_EP3: USB0_EP3::steal(),
9342 USB0_EP4: USB0_EP4::steal(),
9343 USB0_EP5: USB0_EP5::steal(),
9344 USB0_EP6: USB0_EP6::steal(),
9345 USB0_CH0: USB0_CH0::steal(),
9346 USB0_CH1: USB0_CH1::steal(),
9347 USB0_CH2: USB0_CH2::steal(),
9348 USB0_CH3: USB0_CH3::steal(),
9349 USB0_CH4: USB0_CH4::steal(),
9350 USB0_CH5: USB0_CH5::steal(),
9351 USB0_CH6: USB0_CH6::steal(),
9352 USB0_CH7: USB0_CH7::steal(),
9353 USB0_CH8: USB0_CH8::steal(),
9354 USB0_CH9: USB0_CH9::steal(),
9355 USB0_CH10: USB0_CH10::steal(),
9356 USB0_CH11: USB0_CH11::steal(),
9357 USB0_CH12: USB0_CH12::steal(),
9358 USB0_CH13: USB0_CH13::steal(),
9359 USIC0: USIC0::steal(),
9360 USIC1: USIC1::steal(),
9361 USIC0_CH0: USIC0_CH0::steal(),
9362 USIC0_CH1: USIC0_CH1::steal(),
9363 USIC1_CH0: USIC1_CH0::steal(),
9364 USIC1_CH1: USIC1_CH1::steal(),
9365 CAN: CAN::steal(),
9366 CAN_NODE0: CAN_NODE0::steal(),
9367 CAN_NODE1: CAN_NODE1::steal(),
9368 CAN_MO0: CAN_MO0::steal(),
9369 CAN_MO1: CAN_MO1::steal(),
9370 CAN_MO2: CAN_MO2::steal(),
9371 CAN_MO3: CAN_MO3::steal(),
9372 CAN_MO4: CAN_MO4::steal(),
9373 CAN_MO5: CAN_MO5::steal(),
9374 CAN_MO6: CAN_MO6::steal(),
9375 CAN_MO7: CAN_MO7::steal(),
9376 CAN_MO8: CAN_MO8::steal(),
9377 CAN_MO9: CAN_MO9::steal(),
9378 CAN_MO10: CAN_MO10::steal(),
9379 CAN_MO11: CAN_MO11::steal(),
9380 CAN_MO12: CAN_MO12::steal(),
9381 CAN_MO13: CAN_MO13::steal(),
9382 CAN_MO14: CAN_MO14::steal(),
9383 CAN_MO15: CAN_MO15::steal(),
9384 CAN_MO16: CAN_MO16::steal(),
9385 CAN_MO17: CAN_MO17::steal(),
9386 CAN_MO18: CAN_MO18::steal(),
9387 CAN_MO19: CAN_MO19::steal(),
9388 CAN_MO20: CAN_MO20::steal(),
9389 CAN_MO21: CAN_MO21::steal(),
9390 CAN_MO22: CAN_MO22::steal(),
9391 CAN_MO23: CAN_MO23::steal(),
9392 CAN_MO24: CAN_MO24::steal(),
9393 CAN_MO25: CAN_MO25::steal(),
9394 CAN_MO26: CAN_MO26::steal(),
9395 CAN_MO27: CAN_MO27::steal(),
9396 CAN_MO28: CAN_MO28::steal(),
9397 CAN_MO29: CAN_MO29::steal(),
9398 CAN_MO30: CAN_MO30::steal(),
9399 CAN_MO31: CAN_MO31::steal(),
9400 CAN_MO32: CAN_MO32::steal(),
9401 CAN_MO33: CAN_MO33::steal(),
9402 CAN_MO34: CAN_MO34::steal(),
9403 CAN_MO35: CAN_MO35::steal(),
9404 CAN_MO36: CAN_MO36::steal(),
9405 CAN_MO37: CAN_MO37::steal(),
9406 CAN_MO38: CAN_MO38::steal(),
9407 CAN_MO39: CAN_MO39::steal(),
9408 CAN_MO40: CAN_MO40::steal(),
9409 CAN_MO41: CAN_MO41::steal(),
9410 CAN_MO42: CAN_MO42::steal(),
9411 CAN_MO43: CAN_MO43::steal(),
9412 CAN_MO44: CAN_MO44::steal(),
9413 CAN_MO45: CAN_MO45::steal(),
9414 CAN_MO46: CAN_MO46::steal(),
9415 CAN_MO47: CAN_MO47::steal(),
9416 CAN_MO48: CAN_MO48::steal(),
9417 CAN_MO49: CAN_MO49::steal(),
9418 CAN_MO50: CAN_MO50::steal(),
9419 CAN_MO51: CAN_MO51::steal(),
9420 CAN_MO52: CAN_MO52::steal(),
9421 CAN_MO53: CAN_MO53::steal(),
9422 CAN_MO54: CAN_MO54::steal(),
9423 CAN_MO55: CAN_MO55::steal(),
9424 CAN_MO56: CAN_MO56::steal(),
9425 CAN_MO57: CAN_MO57::steal(),
9426 CAN_MO58: CAN_MO58::steal(),
9427 CAN_MO59: CAN_MO59::steal(),
9428 CAN_MO60: CAN_MO60::steal(),
9429 CAN_MO61: CAN_MO61::steal(),
9430 CAN_MO62: CAN_MO62::steal(),
9431 CAN_MO63: CAN_MO63::steal(),
9432 VADC: VADC::steal(),
9433 VADC_G0: VADC_G0::steal(),
9434 VADC_G1: VADC_G1::steal(),
9435 VADC_G2: VADC_G2::steal(),
9436 VADC_G3: VADC_G3::steal(),
9437 DSD: DSD::steal(),
9438 DSD_CH0: DSD_CH0::steal(),
9439 DSD_CH1: DSD_CH1::steal(),
9440 DSD_CH2: DSD_CH2::steal(),
9441 DSD_CH3: DSD_CH3::steal(),
9442 DAC: DAC::steal(),
9443 CCU40: CCU40::steal(),
9444 CCU41: CCU41::steal(),
9445 CCU42: CCU42::steal(),
9446 CCU43: CCU43::steal(),
9447 CCU40_CC40: CCU40_CC40::steal(),
9448 CCU40_CC41: CCU40_CC41::steal(),
9449 CCU40_CC42: CCU40_CC42::steal(),
9450 CCU40_CC43: CCU40_CC43::steal(),
9451 CCU41_CC40: CCU41_CC40::steal(),
9452 CCU41_CC41: CCU41_CC41::steal(),
9453 CCU41_CC42: CCU41_CC42::steal(),
9454 CCU41_CC43: CCU41_CC43::steal(),
9455 CCU42_CC40: CCU42_CC40::steal(),
9456 CCU42_CC41: CCU42_CC41::steal(),
9457 CCU42_CC42: CCU42_CC42::steal(),
9458 CCU42_CC43: CCU42_CC43::steal(),
9459 CCU43_CC40: CCU43_CC40::steal(),
9460 CCU43_CC41: CCU43_CC41::steal(),
9461 CCU43_CC42: CCU43_CC42::steal(),
9462 CCU43_CC43: CCU43_CC43::steal(),
9463 CCU80: CCU80::steal(),
9464 CCU81: CCU81::steal(),
9465 CCU80_CC80: CCU80_CC80::steal(),
9466 CCU80_CC81: CCU80_CC81::steal(),
9467 CCU80_CC82: CCU80_CC82::steal(),
9468 CCU80_CC83: CCU80_CC83::steal(),
9469 CCU81_CC80: CCU81_CC80::steal(),
9470 CCU81_CC81: CCU81_CC81::steal(),
9471 CCU81_CC82: CCU81_CC82::steal(),
9472 CCU81_CC83: CCU81_CC83::steal(),
9473 HRPWM0: HRPWM0::steal(),
9474 HRPWM0_CSG0: HRPWM0_CSG0::steal(),
9475 HRPWM0_CSG1: HRPWM0_CSG1::steal(),
9476 HRPWM0_CSG2: HRPWM0_CSG2::steal(),
9477 HRPWM0_HRC0: HRPWM0_HRC0::steal(),
9478 HRPWM0_HRC1: HRPWM0_HRC1::steal(),
9479 HRPWM0_HRC2: HRPWM0_HRC2::steal(),
9480 HRPWM0_HRC3: HRPWM0_HRC3::steal(),
9481 POSIF0: POSIF0::steal(),
9482 POSIF1: POSIF1::steal(),
9483 PORT0: PORT0::steal(),
9484 PORT1: PORT1::steal(),
9485 PORT2: PORT2::steal(),
9486 PORT3: PORT3::steal(),
9487 PORT4: PORT4::steal(),
9488 PORT5: PORT5::steal(),
9489 PORT14: PORT14::steal(),
9490 PORT15: PORT15::steal(),
9491 }
9492 }
9493}