1#![doc = "Peripheral access API for R7FA6M3AH microcontrollers (generated using svd2rust v0.28.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.28.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#![deny(dead_code)]
4#![deny(improper_ctypes)]
5#![deny(missing_docs)]
6#![deny(no_mangle_generic_items)]
7#![deny(non_shorthand_field_patterns)]
8#![deny(overflowing_literals)]
9#![deny(path_statements)]
10#![deny(patterns_in_fns_without_body)]
11#![deny(private_in_public)]
12#![deny(unconditional_recursion)]
13#![deny(unused_allocation)]
14#![deny(unused_comparisons)]
15#![deny(unused_parens)]
16#![deny(while_true)]
17#![allow(non_camel_case_types)]
18#![allow(non_snake_case)]
19#![no_std]
20use core::marker::PhantomData;
21use core::ops::Deref;
22#[doc = r"Number available in the NVIC for configuring priority"]
23pub const NVIC_PRIO_BITS: u8 = 4;
24#[cfg(feature = "rt")]
25pub use self::Interrupt as interrupt;
26pub use cortex_m::peripheral::Peripherals as CorePeripherals;
27pub use cortex_m::peripheral::{CBP, CPUID, DCB, DWT, FPB, FPU, ITM, MPU, NVIC, SCB, SYST, TPIU};
28#[cfg(feature = "rt")]
29pub use cortex_m_rt::interrupt;
30#[allow(unused_imports)]
31use generic::*;
32#[doc = r"Common register and bit access and modify traits"]
33pub mod generic;
34#[cfg(feature = "rt")]
35extern "C" {
36 fn IEL0();
37 fn IEL1();
38 fn IEL2();
39 fn IEL3();
40 fn IEL4();
41 fn IEL5();
42 fn IEL6();
43 fn IEL7();
44 fn IEL8();
45 fn IEL9();
46 fn IEL10();
47 fn IEL11();
48 fn IEL12();
49 fn IEL13();
50 fn IEL14();
51 fn IEL15();
52 fn IEL16();
53 fn IEL17();
54 fn IEL18();
55 fn IEL19();
56 fn IEL20();
57 fn IEL21();
58 fn IEL22();
59 fn IEL23();
60 fn IEL24();
61 fn IEL25();
62 fn IEL26();
63 fn IEL27();
64 fn IEL28();
65 fn IEL29();
66 fn IEL30();
67 fn IEL31();
68 fn IEL32();
69 fn IEL33();
70 fn IEL34();
71 fn IEL35();
72 fn IEL36();
73 fn IEL37();
74 fn IEL38();
75 fn IEL39();
76 fn IEL40();
77 fn IEL41();
78 fn IEL42();
79 fn IEL43();
80 fn IEL44();
81 fn IEL45();
82 fn IEL46();
83 fn IEL47();
84 fn IEL48();
85 fn IEL49();
86 fn IEL50();
87 fn IEL51();
88 fn IEL52();
89 fn IEL53();
90 fn IEL54();
91 fn IEL55();
92 fn IEL56();
93 fn IEL57();
94 fn IEL58();
95 fn IEL59();
96 fn IEL60();
97 fn IEL61();
98 fn IEL62();
99 fn IEL63();
100 fn IEL64();
101 fn IEL65();
102 fn IEL66();
103 fn IEL67();
104 fn IEL68();
105 fn IEL69();
106 fn IEL70();
107 fn IEL71();
108 fn IEL72();
109 fn IEL73();
110 fn IEL74();
111 fn IEL75();
112 fn IEL76();
113 fn IEL77();
114 fn IEL78();
115 fn IEL79();
116 fn IEL80();
117 fn IEL81();
118 fn IEL82();
119 fn IEL83();
120 fn IEL84();
121 fn IEL85();
122 fn IEL86();
123 fn IEL87();
124 fn IEL88();
125 fn IEL89();
126 fn IEL90();
127 fn IEL91();
128 fn IEL92();
129 fn IEL93();
130 fn IEL94();
131 fn IEL95();
132}
133#[doc(hidden)]
134pub union Vector {
135 _handler: unsafe extern "C" fn(),
136 _reserved: u32,
137}
138#[cfg(feature = "rt")]
139#[doc(hidden)]
140#[link_section = ".vector_table.interrupts"]
141#[no_mangle]
142pub static __INTERRUPTS: [Vector; 96] = [
143 Vector { _handler: IEL0 },
144 Vector { _handler: IEL1 },
145 Vector { _handler: IEL2 },
146 Vector { _handler: IEL3 },
147 Vector { _handler: IEL4 },
148 Vector { _handler: IEL5 },
149 Vector { _handler: IEL6 },
150 Vector { _handler: IEL7 },
151 Vector { _handler: IEL8 },
152 Vector { _handler: IEL9 },
153 Vector { _handler: IEL10 },
154 Vector { _handler: IEL11 },
155 Vector { _handler: IEL12 },
156 Vector { _handler: IEL13 },
157 Vector { _handler: IEL14 },
158 Vector { _handler: IEL15 },
159 Vector { _handler: IEL16 },
160 Vector { _handler: IEL17 },
161 Vector { _handler: IEL18 },
162 Vector { _handler: IEL19 },
163 Vector { _handler: IEL20 },
164 Vector { _handler: IEL21 },
165 Vector { _handler: IEL22 },
166 Vector { _handler: IEL23 },
167 Vector { _handler: IEL24 },
168 Vector { _handler: IEL25 },
169 Vector { _handler: IEL26 },
170 Vector { _handler: IEL27 },
171 Vector { _handler: IEL28 },
172 Vector { _handler: IEL29 },
173 Vector { _handler: IEL30 },
174 Vector { _handler: IEL31 },
175 Vector { _handler: IEL32 },
176 Vector { _handler: IEL33 },
177 Vector { _handler: IEL34 },
178 Vector { _handler: IEL35 },
179 Vector { _handler: IEL36 },
180 Vector { _handler: IEL37 },
181 Vector { _handler: IEL38 },
182 Vector { _handler: IEL39 },
183 Vector { _handler: IEL40 },
184 Vector { _handler: IEL41 },
185 Vector { _handler: IEL42 },
186 Vector { _handler: IEL43 },
187 Vector { _handler: IEL44 },
188 Vector { _handler: IEL45 },
189 Vector { _handler: IEL46 },
190 Vector { _handler: IEL47 },
191 Vector { _handler: IEL48 },
192 Vector { _handler: IEL49 },
193 Vector { _handler: IEL50 },
194 Vector { _handler: IEL51 },
195 Vector { _handler: IEL52 },
196 Vector { _handler: IEL53 },
197 Vector { _handler: IEL54 },
198 Vector { _handler: IEL55 },
199 Vector { _handler: IEL56 },
200 Vector { _handler: IEL57 },
201 Vector { _handler: IEL58 },
202 Vector { _handler: IEL59 },
203 Vector { _handler: IEL60 },
204 Vector { _handler: IEL61 },
205 Vector { _handler: IEL62 },
206 Vector { _handler: IEL63 },
207 Vector { _handler: IEL64 },
208 Vector { _handler: IEL65 },
209 Vector { _handler: IEL66 },
210 Vector { _handler: IEL67 },
211 Vector { _handler: IEL68 },
212 Vector { _handler: IEL69 },
213 Vector { _handler: IEL70 },
214 Vector { _handler: IEL71 },
215 Vector { _handler: IEL72 },
216 Vector { _handler: IEL73 },
217 Vector { _handler: IEL74 },
218 Vector { _handler: IEL75 },
219 Vector { _handler: IEL76 },
220 Vector { _handler: IEL77 },
221 Vector { _handler: IEL78 },
222 Vector { _handler: IEL79 },
223 Vector { _handler: IEL80 },
224 Vector { _handler: IEL81 },
225 Vector { _handler: IEL82 },
226 Vector { _handler: IEL83 },
227 Vector { _handler: IEL84 },
228 Vector { _handler: IEL85 },
229 Vector { _handler: IEL86 },
230 Vector { _handler: IEL87 },
231 Vector { _handler: IEL88 },
232 Vector { _handler: IEL89 },
233 Vector { _handler: IEL90 },
234 Vector { _handler: IEL91 },
235 Vector { _handler: IEL92 },
236 Vector { _handler: IEL93 },
237 Vector { _handler: IEL94 },
238 Vector { _handler: IEL95 },
239];
240#[doc = r"Enumeration of all the interrupts."]
241#[derive(Copy, Clone, Debug, PartialEq, Eq)]
242#[repr(u16)]
243pub enum Interrupt {
244 #[doc = "0 - ICU Interrupt 0"]
245 IEL0 = 0,
246 #[doc = "1 - ICU Interrupt 1"]
247 IEL1 = 1,
248 #[doc = "2 - ICU Interrupt 2"]
249 IEL2 = 2,
250 #[doc = "3 - ICU Interrupt 3"]
251 IEL3 = 3,
252 #[doc = "4 - ICU Interrupt 4"]
253 IEL4 = 4,
254 #[doc = "5 - ICU Interrupt 5"]
255 IEL5 = 5,
256 #[doc = "6 - ICU Interrupt 6"]
257 IEL6 = 6,
258 #[doc = "7 - ICU Interrupt 7"]
259 IEL7 = 7,
260 #[doc = "8 - ICU Interrupt 8"]
261 IEL8 = 8,
262 #[doc = "9 - ICU Interrupt 9"]
263 IEL9 = 9,
264 #[doc = "10 - ICU Interrupt 10"]
265 IEL10 = 10,
266 #[doc = "11 - ICU Interrupt 11"]
267 IEL11 = 11,
268 #[doc = "12 - ICU Interrupt 12"]
269 IEL12 = 12,
270 #[doc = "13 - ICU Interrupt 13"]
271 IEL13 = 13,
272 #[doc = "14 - ICU Interrupt 14"]
273 IEL14 = 14,
274 #[doc = "15 - ICU Interrupt 15"]
275 IEL15 = 15,
276 #[doc = "16 - ICU Interrupt 16"]
277 IEL16 = 16,
278 #[doc = "17 - ICU Interrupt 17"]
279 IEL17 = 17,
280 #[doc = "18 - ICU Interrupt 18"]
281 IEL18 = 18,
282 #[doc = "19 - ICU Interrupt 19"]
283 IEL19 = 19,
284 #[doc = "20 - ICU Interrupt 20"]
285 IEL20 = 20,
286 #[doc = "21 - ICU Interrupt 21"]
287 IEL21 = 21,
288 #[doc = "22 - ICU Interrupt 22"]
289 IEL22 = 22,
290 #[doc = "23 - ICU Interrupt 23"]
291 IEL23 = 23,
292 #[doc = "24 - ICU Interrupt 24"]
293 IEL24 = 24,
294 #[doc = "25 - ICU Interrupt 25"]
295 IEL25 = 25,
296 #[doc = "26 - ICU Interrupt 26"]
297 IEL26 = 26,
298 #[doc = "27 - ICU Interrupt 27"]
299 IEL27 = 27,
300 #[doc = "28 - ICU Interrupt 28"]
301 IEL28 = 28,
302 #[doc = "29 - ICU Interrupt 29"]
303 IEL29 = 29,
304 #[doc = "30 - ICU Interrupt 30"]
305 IEL30 = 30,
306 #[doc = "31 - ICU Interrupt 31"]
307 IEL31 = 31,
308 #[doc = "32 - ICU Interrupt 32"]
309 IEL32 = 32,
310 #[doc = "33 - ICU Interrupt 33"]
311 IEL33 = 33,
312 #[doc = "34 - ICU Interrupt 34"]
313 IEL34 = 34,
314 #[doc = "35 - ICU Interrupt 35"]
315 IEL35 = 35,
316 #[doc = "36 - ICU Interrupt 36"]
317 IEL36 = 36,
318 #[doc = "37 - ICU Interrupt 37"]
319 IEL37 = 37,
320 #[doc = "38 - ICU Interrupt 38"]
321 IEL38 = 38,
322 #[doc = "39 - ICU Interrupt 39"]
323 IEL39 = 39,
324 #[doc = "40 - ICU Interrupt 40"]
325 IEL40 = 40,
326 #[doc = "41 - ICU Interrupt 41"]
327 IEL41 = 41,
328 #[doc = "42 - ICU Interrupt 42"]
329 IEL42 = 42,
330 #[doc = "43 - ICU Interrupt 43"]
331 IEL43 = 43,
332 #[doc = "44 - ICU Interrupt 44"]
333 IEL44 = 44,
334 #[doc = "45 - ICU Interrupt 45"]
335 IEL45 = 45,
336 #[doc = "46 - ICU Interrupt 46"]
337 IEL46 = 46,
338 #[doc = "47 - ICU Interrupt 47"]
339 IEL47 = 47,
340 #[doc = "48 - ICU Interrupt 48"]
341 IEL48 = 48,
342 #[doc = "49 - ICU Interrupt 49"]
343 IEL49 = 49,
344 #[doc = "50 - ICU Interrupt 50"]
345 IEL50 = 50,
346 #[doc = "51 - ICU Interrupt 51"]
347 IEL51 = 51,
348 #[doc = "52 - ICU Interrupt 52"]
349 IEL52 = 52,
350 #[doc = "53 - ICU Interrupt 53"]
351 IEL53 = 53,
352 #[doc = "54 - ICU Interrupt 54"]
353 IEL54 = 54,
354 #[doc = "55 - ICU Interrupt 55"]
355 IEL55 = 55,
356 #[doc = "56 - ICU Interrupt 56"]
357 IEL56 = 56,
358 #[doc = "57 - ICU Interrupt 57"]
359 IEL57 = 57,
360 #[doc = "58 - ICU Interrupt 58"]
361 IEL58 = 58,
362 #[doc = "59 - ICU Interrupt 59"]
363 IEL59 = 59,
364 #[doc = "60 - ICU Interrupt 60"]
365 IEL60 = 60,
366 #[doc = "61 - ICU Interrupt 61"]
367 IEL61 = 61,
368 #[doc = "62 - ICU Interrupt 62"]
369 IEL62 = 62,
370 #[doc = "63 - ICU Interrupt 63"]
371 IEL63 = 63,
372 #[doc = "64 - ICU Interrupt 64"]
373 IEL64 = 64,
374 #[doc = "65 - ICU Interrupt 65"]
375 IEL65 = 65,
376 #[doc = "66 - ICU Interrupt 66"]
377 IEL66 = 66,
378 #[doc = "67 - ICU Interrupt 67"]
379 IEL67 = 67,
380 #[doc = "68 - ICU Interrupt 68"]
381 IEL68 = 68,
382 #[doc = "69 - ICU Interrupt 69"]
383 IEL69 = 69,
384 #[doc = "70 - ICU Interrupt 70"]
385 IEL70 = 70,
386 #[doc = "71 - ICU Interrupt 71"]
387 IEL71 = 71,
388 #[doc = "72 - ICU Interrupt 72"]
389 IEL72 = 72,
390 #[doc = "73 - ICU Interrupt 73"]
391 IEL73 = 73,
392 #[doc = "74 - ICU Interrupt 74"]
393 IEL74 = 74,
394 #[doc = "75 - ICU Interrupt 75"]
395 IEL75 = 75,
396 #[doc = "76 - ICU Interrupt 76"]
397 IEL76 = 76,
398 #[doc = "77 - ICU Interrupt 77"]
399 IEL77 = 77,
400 #[doc = "78 - ICU Interrupt 78"]
401 IEL78 = 78,
402 #[doc = "79 - ICU Interrupt 79"]
403 IEL79 = 79,
404 #[doc = "80 - ICU Interrupt 80"]
405 IEL80 = 80,
406 #[doc = "81 - ICU Interrupt 81"]
407 IEL81 = 81,
408 #[doc = "82 - ICU Interrupt 82"]
409 IEL82 = 82,
410 #[doc = "83 - ICU Interrupt 83"]
411 IEL83 = 83,
412 #[doc = "84 - ICU Interrupt 84"]
413 IEL84 = 84,
414 #[doc = "85 - ICU Interrupt 85"]
415 IEL85 = 85,
416 #[doc = "86 - ICU Interrupt 86"]
417 IEL86 = 86,
418 #[doc = "87 - ICU Interrupt 87"]
419 IEL87 = 87,
420 #[doc = "88 - ICU Interrupt 88"]
421 IEL88 = 88,
422 #[doc = "89 - ICU Interrupt 89"]
423 IEL89 = 89,
424 #[doc = "90 - ICU Interrupt 90"]
425 IEL90 = 90,
426 #[doc = "91 - ICU Interrupt 91"]
427 IEL91 = 91,
428 #[doc = "92 - ICU Interrupt 92"]
429 IEL92 = 92,
430 #[doc = "93 - ICU Interrupt 93"]
431 IEL93 = 93,
432 #[doc = "94 - ICU Interrupt 94"]
433 IEL94 = 94,
434 #[doc = "95 - ICU Interrupt 95"]
435 IEL95 = 95,
436}
437unsafe impl cortex_m::interrupt::InterruptNumber for Interrupt {
438 #[inline(always)]
439 fn number(self) -> u16 {
440 self as u16
441 }
442}
443#[doc = "Port 0 Control Registers"]
444pub struct PORT0 {
445 _marker: PhantomData<*const ()>,
446}
447unsafe impl Send for PORT0 {}
448impl PORT0 {
449 #[doc = r"Pointer to the register block"]
450 pub const PTR: *const port0::RegisterBlock = 0x4004_0000 as *const _;
451 #[doc = r"Return the pointer to the register block"]
452 #[inline(always)]
453 pub const fn ptr() -> *const port0::RegisterBlock {
454 Self::PTR
455 }
456}
457impl Deref for PORT0 {
458 type Target = port0::RegisterBlock;
459 #[inline(always)]
460 fn deref(&self) -> &Self::Target {
461 unsafe { &*Self::PTR }
462 }
463}
464impl core::fmt::Debug for PORT0 {
465 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
466 f.debug_struct("PORT0").finish()
467 }
468}
469#[doc = "Port 0 Control Registers"]
470pub mod port0;
471#[doc = "Port 1 Control Registers"]
472pub struct PORT1 {
473 _marker: PhantomData<*const ()>,
474}
475unsafe impl Send for PORT1 {}
476impl PORT1 {
477 #[doc = r"Pointer to the register block"]
478 pub const PTR: *const port1::RegisterBlock = 0x4004_0020 as *const _;
479 #[doc = r"Return the pointer to the register block"]
480 #[inline(always)]
481 pub const fn ptr() -> *const port1::RegisterBlock {
482 Self::PTR
483 }
484}
485impl Deref for PORT1 {
486 type Target = port1::RegisterBlock;
487 #[inline(always)]
488 fn deref(&self) -> &Self::Target {
489 unsafe { &*Self::PTR }
490 }
491}
492impl core::fmt::Debug for PORT1 {
493 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
494 f.debug_struct("PORT1").finish()
495 }
496}
497#[doc = "Port 1 Control Registers"]
498pub mod port1;
499#[doc = "Port 2 Control Registers"]
500pub struct PORT2 {
501 _marker: PhantomData<*const ()>,
502}
503unsafe impl Send for PORT2 {}
504impl PORT2 {
505 #[doc = r"Pointer to the register block"]
506 pub const PTR: *const port1::RegisterBlock = 0x4004_0040 as *const _;
507 #[doc = r"Return the pointer to the register block"]
508 #[inline(always)]
509 pub const fn ptr() -> *const port1::RegisterBlock {
510 Self::PTR
511 }
512}
513impl Deref for PORT2 {
514 type Target = port1::RegisterBlock;
515 #[inline(always)]
516 fn deref(&self) -> &Self::Target {
517 unsafe { &*Self::PTR }
518 }
519}
520impl core::fmt::Debug for PORT2 {
521 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
522 f.debug_struct("PORT2").finish()
523 }
524}
525#[doc = "Port 2 Control Registers"]
526pub use self::port1 as port2;
527#[doc = "Port 3 Control Registers"]
528pub struct PORT3 {
529 _marker: PhantomData<*const ()>,
530}
531unsafe impl Send for PORT3 {}
532impl PORT3 {
533 #[doc = r"Pointer to the register block"]
534 pub const PTR: *const port1::RegisterBlock = 0x4004_0060 as *const _;
535 #[doc = r"Return the pointer to the register block"]
536 #[inline(always)]
537 pub const fn ptr() -> *const port1::RegisterBlock {
538 Self::PTR
539 }
540}
541impl Deref for PORT3 {
542 type Target = port1::RegisterBlock;
543 #[inline(always)]
544 fn deref(&self) -> &Self::Target {
545 unsafe { &*Self::PTR }
546 }
547}
548impl core::fmt::Debug for PORT3 {
549 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
550 f.debug_struct("PORT3").finish()
551 }
552}
553#[doc = "Port 3 Control Registers"]
554pub use self::port1 as port3;
555#[doc = "Port 4 Control Registers"]
556pub struct PORT4 {
557 _marker: PhantomData<*const ()>,
558}
559unsafe impl Send for PORT4 {}
560impl PORT4 {
561 #[doc = r"Pointer to the register block"]
562 pub const PTR: *const port1::RegisterBlock = 0x4004_0080 as *const _;
563 #[doc = r"Return the pointer to the register block"]
564 #[inline(always)]
565 pub const fn ptr() -> *const port1::RegisterBlock {
566 Self::PTR
567 }
568}
569impl Deref for PORT4 {
570 type Target = port1::RegisterBlock;
571 #[inline(always)]
572 fn deref(&self) -> &Self::Target {
573 unsafe { &*Self::PTR }
574 }
575}
576impl core::fmt::Debug for PORT4 {
577 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
578 f.debug_struct("PORT4").finish()
579 }
580}
581#[doc = "Port 4 Control Registers"]
582pub use self::port1 as port4;
583#[doc = "Port 5 Control Registers"]
584pub struct PORT5 {
585 _marker: PhantomData<*const ()>,
586}
587unsafe impl Send for PORT5 {}
588impl PORT5 {
589 #[doc = r"Pointer to the register block"]
590 pub const PTR: *const port0::RegisterBlock = 0x4004_00a0 as *const _;
591 #[doc = r"Return the pointer to the register block"]
592 #[inline(always)]
593 pub const fn ptr() -> *const port0::RegisterBlock {
594 Self::PTR
595 }
596}
597impl Deref for PORT5 {
598 type Target = port0::RegisterBlock;
599 #[inline(always)]
600 fn deref(&self) -> &Self::Target {
601 unsafe { &*Self::PTR }
602 }
603}
604impl core::fmt::Debug for PORT5 {
605 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
606 f.debug_struct("PORT5").finish()
607 }
608}
609#[doc = "Port 5 Control Registers"]
610pub use self::port0 as port5;
611#[doc = "Port 6 Control Registers"]
612pub struct PORT6 {
613 _marker: PhantomData<*const ()>,
614}
615unsafe impl Send for PORT6 {}
616impl PORT6 {
617 #[doc = r"Pointer to the register block"]
618 pub const PTR: *const port0::RegisterBlock = 0x4004_00c0 as *const _;
619 #[doc = r"Return the pointer to the register block"]
620 #[inline(always)]
621 pub const fn ptr() -> *const port0::RegisterBlock {
622 Self::PTR
623 }
624}
625impl Deref for PORT6 {
626 type Target = port0::RegisterBlock;
627 #[inline(always)]
628 fn deref(&self) -> &Self::Target {
629 unsafe { &*Self::PTR }
630 }
631}
632impl core::fmt::Debug for PORT6 {
633 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
634 f.debug_struct("PORT6").finish()
635 }
636}
637#[doc = "Port 6 Control Registers"]
638pub use self::port0 as port6;
639#[doc = "Port 7 Control Registers"]
640pub struct PORT7 {
641 _marker: PhantomData<*const ()>,
642}
643unsafe impl Send for PORT7 {}
644impl PORT7 {
645 #[doc = r"Pointer to the register block"]
646 pub const PTR: *const port0::RegisterBlock = 0x4004_00e0 as *const _;
647 #[doc = r"Return the pointer to the register block"]
648 #[inline(always)]
649 pub const fn ptr() -> *const port0::RegisterBlock {
650 Self::PTR
651 }
652}
653impl Deref for PORT7 {
654 type Target = port0::RegisterBlock;
655 #[inline(always)]
656 fn deref(&self) -> &Self::Target {
657 unsafe { &*Self::PTR }
658 }
659}
660impl core::fmt::Debug for PORT7 {
661 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
662 f.debug_struct("PORT7").finish()
663 }
664}
665#[doc = "Port 7 Control Registers"]
666pub use self::port0 as port7;
667#[doc = "Port 8 Control Registers"]
668pub struct PORT8 {
669 _marker: PhantomData<*const ()>,
670}
671unsafe impl Send for PORT8 {}
672impl PORT8 {
673 #[doc = r"Pointer to the register block"]
674 pub const PTR: *const port0::RegisterBlock = 0x4004_0100 as *const _;
675 #[doc = r"Return the pointer to the register block"]
676 #[inline(always)]
677 pub const fn ptr() -> *const port0::RegisterBlock {
678 Self::PTR
679 }
680}
681impl Deref for PORT8 {
682 type Target = port0::RegisterBlock;
683 #[inline(always)]
684 fn deref(&self) -> &Self::Target {
685 unsafe { &*Self::PTR }
686 }
687}
688impl core::fmt::Debug for PORT8 {
689 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
690 f.debug_struct("PORT8").finish()
691 }
692}
693#[doc = "Port 8 Control Registers"]
694pub use self::port0 as port8;
695#[doc = "Port 9 Control Registers"]
696pub struct PORT9 {
697 _marker: PhantomData<*const ()>,
698}
699unsafe impl Send for PORT9 {}
700impl PORT9 {
701 #[doc = r"Pointer to the register block"]
702 pub const PTR: *const port0::RegisterBlock = 0x4004_0120 as *const _;
703 #[doc = r"Return the pointer to the register block"]
704 #[inline(always)]
705 pub const fn ptr() -> *const port0::RegisterBlock {
706 Self::PTR
707 }
708}
709impl Deref for PORT9 {
710 type Target = port0::RegisterBlock;
711 #[inline(always)]
712 fn deref(&self) -> &Self::Target {
713 unsafe { &*Self::PTR }
714 }
715}
716impl core::fmt::Debug for PORT9 {
717 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
718 f.debug_struct("PORT9").finish()
719 }
720}
721#[doc = "Port 9 Control Registers"]
722pub use self::port0 as port9;
723#[doc = "Port A Control Registers"]
724pub struct PORTA {
725 _marker: PhantomData<*const ()>,
726}
727unsafe impl Send for PORTA {}
728impl PORTA {
729 #[doc = r"Pointer to the register block"]
730 pub const PTR: *const port0::RegisterBlock = 0x4004_0140 as *const _;
731 #[doc = r"Return the pointer to the register block"]
732 #[inline(always)]
733 pub const fn ptr() -> *const port0::RegisterBlock {
734 Self::PTR
735 }
736}
737impl Deref for PORTA {
738 type Target = port0::RegisterBlock;
739 #[inline(always)]
740 fn deref(&self) -> &Self::Target {
741 unsafe { &*Self::PTR }
742 }
743}
744impl core::fmt::Debug for PORTA {
745 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
746 f.debug_struct("PORTA").finish()
747 }
748}
749#[doc = "Port A Control Registers"]
750pub use self::port0 as porta;
751#[doc = "Port B Control Registers"]
752pub struct PORTB {
753 _marker: PhantomData<*const ()>,
754}
755unsafe impl Send for PORTB {}
756impl PORTB {
757 #[doc = r"Pointer to the register block"]
758 pub const PTR: *const port0::RegisterBlock = 0x4004_0160 as *const _;
759 #[doc = r"Return the pointer to the register block"]
760 #[inline(always)]
761 pub const fn ptr() -> *const port0::RegisterBlock {
762 Self::PTR
763 }
764}
765impl Deref for PORTB {
766 type Target = port0::RegisterBlock;
767 #[inline(always)]
768 fn deref(&self) -> &Self::Target {
769 unsafe { &*Self::PTR }
770 }
771}
772impl core::fmt::Debug for PORTB {
773 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
774 f.debug_struct("PORTB").finish()
775 }
776}
777#[doc = "Port B Control Registers"]
778pub use self::port0 as portb;
779#[doc = "Pmn Pin Function Control Register"]
780pub struct PFS {
781 _marker: PhantomData<*const ()>,
782}
783unsafe impl Send for PFS {}
784impl PFS {
785 #[doc = r"Pointer to the register block"]
786 pub const PTR: *const pfs::RegisterBlock = 0x4004_0800 as *const _;
787 #[doc = r"Return the pointer to the register block"]
788 #[inline(always)]
789 pub const fn ptr() -> *const pfs::RegisterBlock {
790 Self::PTR
791 }
792}
793impl Deref for PFS {
794 type Target = pfs::RegisterBlock;
795 #[inline(always)]
796 fn deref(&self) -> &Self::Target {
797 unsafe { &*Self::PTR }
798 }
799}
800impl core::fmt::Debug for PFS {
801 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
802 f.debug_struct("PFS").finish()
803 }
804}
805#[doc = "Pmn Pin Function Control Register"]
806pub mod pfs;
807#[doc = "Miscellaneous Port Control Register"]
808pub struct PMISC {
809 _marker: PhantomData<*const ()>,
810}
811unsafe impl Send for PMISC {}
812impl PMISC {
813 #[doc = r"Pointer to the register block"]
814 pub const PTR: *const pmisc::RegisterBlock = 0x4004_0d00 as *const _;
815 #[doc = r"Return the pointer to the register block"]
816 #[inline(always)]
817 pub const fn ptr() -> *const pmisc::RegisterBlock {
818 Self::PTR
819 }
820}
821impl Deref for PMISC {
822 type Target = pmisc::RegisterBlock;
823 #[inline(always)]
824 fn deref(&self) -> &Self::Target {
825 unsafe { &*Self::PTR }
826 }
827}
828impl core::fmt::Debug for PMISC {
829 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
830 f.debug_struct("PMISC").finish()
831 }
832}
833#[doc = "Miscellaneous Port Control Register"]
834pub mod pmisc;
835#[doc = "Serial Peripheral Interface 0"]
836pub struct SPI0 {
837 _marker: PhantomData<*const ()>,
838}
839unsafe impl Send for SPI0 {}
840impl SPI0 {
841 #[doc = r"Pointer to the register block"]
842 pub const PTR: *const spi0::RegisterBlock = 0x4007_2000 as *const _;
843 #[doc = r"Return the pointer to the register block"]
844 #[inline(always)]
845 pub const fn ptr() -> *const spi0::RegisterBlock {
846 Self::PTR
847 }
848}
849impl Deref for SPI0 {
850 type Target = spi0::RegisterBlock;
851 #[inline(always)]
852 fn deref(&self) -> &Self::Target {
853 unsafe { &*Self::PTR }
854 }
855}
856impl core::fmt::Debug for SPI0 {
857 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
858 f.debug_struct("SPI0").finish()
859 }
860}
861#[doc = "Serial Peripheral Interface 0"]
862pub mod spi0;
863#[doc = "Serial Peripheral Interface 1"]
864pub struct SPI1 {
865 _marker: PhantomData<*const ()>,
866}
867unsafe impl Send for SPI1 {}
868impl SPI1 {
869 #[doc = r"Pointer to the register block"]
870 pub const PTR: *const spi0::RegisterBlock = 0x4007_2100 as *const _;
871 #[doc = r"Return the pointer to the register block"]
872 #[inline(always)]
873 pub const fn ptr() -> *const spi0::RegisterBlock {
874 Self::PTR
875 }
876}
877impl Deref for SPI1 {
878 type Target = spi0::RegisterBlock;
879 #[inline(always)]
880 fn deref(&self) -> &Self::Target {
881 unsafe { &*Self::PTR }
882 }
883}
884impl core::fmt::Debug for SPI1 {
885 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
886 f.debug_struct("SPI1").finish()
887 }
888}
889#[doc = "Serial Peripheral Interface 1"]
890pub use self::spi0 as spi1;
891#[doc = "Output Phase Switching Controller"]
892pub struct GPT_OPS {
893 _marker: PhantomData<*const ()>,
894}
895unsafe impl Send for GPT_OPS {}
896impl GPT_OPS {
897 #[doc = r"Pointer to the register block"]
898 pub const PTR: *const gpt_ops::RegisterBlock = 0x4007_8ff0 as *const _;
899 #[doc = r"Return the pointer to the register block"]
900 #[inline(always)]
901 pub const fn ptr() -> *const gpt_ops::RegisterBlock {
902 Self::PTR
903 }
904}
905impl Deref for GPT_OPS {
906 type Target = gpt_ops::RegisterBlock;
907 #[inline(always)]
908 fn deref(&self) -> &Self::Target {
909 unsafe { &*Self::PTR }
910 }
911}
912impl core::fmt::Debug for GPT_OPS {
913 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
914 f.debug_struct("GPT_OPS").finish()
915 }
916}
917#[doc = "Output Phase Switching Controller"]
918pub mod gpt_ops;
919#[doc = "General PWM Timer 0 (32-bit Enhanced High Resolution)"]
920pub struct GPT32EH0 {
921 _marker: PhantomData<*const ()>,
922}
923unsafe impl Send for GPT32EH0 {}
924impl GPT32EH0 {
925 #[doc = r"Pointer to the register block"]
926 pub const PTR: *const gpt32eh0::RegisterBlock = 0x4007_8000 as *const _;
927 #[doc = r"Return the pointer to the register block"]
928 #[inline(always)]
929 pub const fn ptr() -> *const gpt32eh0::RegisterBlock {
930 Self::PTR
931 }
932}
933impl Deref for GPT32EH0 {
934 type Target = gpt32eh0::RegisterBlock;
935 #[inline(always)]
936 fn deref(&self) -> &Self::Target {
937 unsafe { &*Self::PTR }
938 }
939}
940impl core::fmt::Debug for GPT32EH0 {
941 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
942 f.debug_struct("GPT32EH0").finish()
943 }
944}
945#[doc = "General PWM Timer 0 (32-bit Enhanced High Resolution)"]
946pub mod gpt32eh0;
947#[doc = "General PWM Timer 1 (32-bit Enhanced High Resolution)"]
948pub struct GPT32EH1 {
949 _marker: PhantomData<*const ()>,
950}
951unsafe impl Send for GPT32EH1 {}
952impl GPT32EH1 {
953 #[doc = r"Pointer to the register block"]
954 pub const PTR: *const gpt32eh0::RegisterBlock = 0x4007_8100 as *const _;
955 #[doc = r"Return the pointer to the register block"]
956 #[inline(always)]
957 pub const fn ptr() -> *const gpt32eh0::RegisterBlock {
958 Self::PTR
959 }
960}
961impl Deref for GPT32EH1 {
962 type Target = gpt32eh0::RegisterBlock;
963 #[inline(always)]
964 fn deref(&self) -> &Self::Target {
965 unsafe { &*Self::PTR }
966 }
967}
968impl core::fmt::Debug for GPT32EH1 {
969 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
970 f.debug_struct("GPT32EH1").finish()
971 }
972}
973#[doc = "General PWM Timer 1 (32-bit Enhanced High Resolution)"]
974pub use self::gpt32eh0 as gpt32eh1;
975#[doc = "General PWM Timer 2 (32-bit Enhanced High Resolution)"]
976pub struct GPT32EH2 {
977 _marker: PhantomData<*const ()>,
978}
979unsafe impl Send for GPT32EH2 {}
980impl GPT32EH2 {
981 #[doc = r"Pointer to the register block"]
982 pub const PTR: *const gpt32eh0::RegisterBlock = 0x4007_8200 as *const _;
983 #[doc = r"Return the pointer to the register block"]
984 #[inline(always)]
985 pub const fn ptr() -> *const gpt32eh0::RegisterBlock {
986 Self::PTR
987 }
988}
989impl Deref for GPT32EH2 {
990 type Target = gpt32eh0::RegisterBlock;
991 #[inline(always)]
992 fn deref(&self) -> &Self::Target {
993 unsafe { &*Self::PTR }
994 }
995}
996impl core::fmt::Debug for GPT32EH2 {
997 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
998 f.debug_struct("GPT32EH2").finish()
999 }
1000}
1001#[doc = "General PWM Timer 2 (32-bit Enhanced High Resolution)"]
1002pub use self::gpt32eh0 as gpt32eh2;
1003#[doc = "General PWM Timer 3 (32-bit Enhanced High Resolution)"]
1004pub struct GPT32EH3 {
1005 _marker: PhantomData<*const ()>,
1006}
1007unsafe impl Send for GPT32EH3 {}
1008impl GPT32EH3 {
1009 #[doc = r"Pointer to the register block"]
1010 pub const PTR: *const gpt32eh0::RegisterBlock = 0x4007_8300 as *const _;
1011 #[doc = r"Return the pointer to the register block"]
1012 #[inline(always)]
1013 pub const fn ptr() -> *const gpt32eh0::RegisterBlock {
1014 Self::PTR
1015 }
1016}
1017impl Deref for GPT32EH3 {
1018 type Target = gpt32eh0::RegisterBlock;
1019 #[inline(always)]
1020 fn deref(&self) -> &Self::Target {
1021 unsafe { &*Self::PTR }
1022 }
1023}
1024impl core::fmt::Debug for GPT32EH3 {
1025 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1026 f.debug_struct("GPT32EH3").finish()
1027 }
1028}
1029#[doc = "General PWM Timer 3 (32-bit Enhanced High Resolution)"]
1030pub use self::gpt32eh0 as gpt32eh3;
1031#[doc = "General PWM Timer 4 (32-bit Enhanced)"]
1032pub struct GPT32E4 {
1033 _marker: PhantomData<*const ()>,
1034}
1035unsafe impl Send for GPT32E4 {}
1036impl GPT32E4 {
1037 #[doc = r"Pointer to the register block"]
1038 pub const PTR: *const gpt32eh0::RegisterBlock = 0x4007_8400 as *const _;
1039 #[doc = r"Return the pointer to the register block"]
1040 #[inline(always)]
1041 pub const fn ptr() -> *const gpt32eh0::RegisterBlock {
1042 Self::PTR
1043 }
1044}
1045impl Deref for GPT32E4 {
1046 type Target = gpt32eh0::RegisterBlock;
1047 #[inline(always)]
1048 fn deref(&self) -> &Self::Target {
1049 unsafe { &*Self::PTR }
1050 }
1051}
1052impl core::fmt::Debug for GPT32E4 {
1053 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1054 f.debug_struct("GPT32E4").finish()
1055 }
1056}
1057#[doc = "General PWM Timer 4 (32-bit Enhanced)"]
1058pub use self::gpt32eh0 as gpt32e4;
1059#[doc = "General PWM Timer 5 (32-bit Enhanced)"]
1060pub struct GPT32E5 {
1061 _marker: PhantomData<*const ()>,
1062}
1063unsafe impl Send for GPT32E5 {}
1064impl GPT32E5 {
1065 #[doc = r"Pointer to the register block"]
1066 pub const PTR: *const gpt32eh0::RegisterBlock = 0x4007_8500 as *const _;
1067 #[doc = r"Return the pointer to the register block"]
1068 #[inline(always)]
1069 pub const fn ptr() -> *const gpt32eh0::RegisterBlock {
1070 Self::PTR
1071 }
1072}
1073impl Deref for GPT32E5 {
1074 type Target = gpt32eh0::RegisterBlock;
1075 #[inline(always)]
1076 fn deref(&self) -> &Self::Target {
1077 unsafe { &*Self::PTR }
1078 }
1079}
1080impl core::fmt::Debug for GPT32E5 {
1081 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1082 f.debug_struct("GPT32E5").finish()
1083 }
1084}
1085#[doc = "General PWM Timer 5 (32-bit Enhanced)"]
1086pub use self::gpt32eh0 as gpt32e5;
1087#[doc = "General PWM Timer 6 (32-bit Enhanced)"]
1088pub struct GPT32E6 {
1089 _marker: PhantomData<*const ()>,
1090}
1091unsafe impl Send for GPT32E6 {}
1092impl GPT32E6 {
1093 #[doc = r"Pointer to the register block"]
1094 pub const PTR: *const gpt32eh0::RegisterBlock = 0x4007_8600 as *const _;
1095 #[doc = r"Return the pointer to the register block"]
1096 #[inline(always)]
1097 pub const fn ptr() -> *const gpt32eh0::RegisterBlock {
1098 Self::PTR
1099 }
1100}
1101impl Deref for GPT32E6 {
1102 type Target = gpt32eh0::RegisterBlock;
1103 #[inline(always)]
1104 fn deref(&self) -> &Self::Target {
1105 unsafe { &*Self::PTR }
1106 }
1107}
1108impl core::fmt::Debug for GPT32E6 {
1109 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1110 f.debug_struct("GPT32E6").finish()
1111 }
1112}
1113#[doc = "General PWM Timer 6 (32-bit Enhanced)"]
1114pub use self::gpt32eh0 as gpt32e6;
1115#[doc = "General PWM Timer 7 (32-bit Enhanced)"]
1116pub struct GPT32E7 {
1117 _marker: PhantomData<*const ()>,
1118}
1119unsafe impl Send for GPT32E7 {}
1120impl GPT32E7 {
1121 #[doc = r"Pointer to the register block"]
1122 pub const PTR: *const gpt32eh0::RegisterBlock = 0x4007_8700 as *const _;
1123 #[doc = r"Return the pointer to the register block"]
1124 #[inline(always)]
1125 pub const fn ptr() -> *const gpt32eh0::RegisterBlock {
1126 Self::PTR
1127 }
1128}
1129impl Deref for GPT32E7 {
1130 type Target = gpt32eh0::RegisterBlock;
1131 #[inline(always)]
1132 fn deref(&self) -> &Self::Target {
1133 unsafe { &*Self::PTR }
1134 }
1135}
1136impl core::fmt::Debug for GPT32E7 {
1137 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1138 f.debug_struct("GPT32E7").finish()
1139 }
1140}
1141#[doc = "General PWM Timer 7 (32-bit Enhanced)"]
1142pub use self::gpt32eh0 as gpt32e7;
1143#[doc = "Graphics LCD Controller"]
1144pub struct GLCDC {
1145 _marker: PhantomData<*const ()>,
1146}
1147unsafe impl Send for GLCDC {}
1148impl GLCDC {
1149 #[doc = r"Pointer to the register block"]
1150 pub const PTR: *const glcdc::RegisterBlock = 0x400e_0000 as *const _;
1151 #[doc = r"Return the pointer to the register block"]
1152 #[inline(always)]
1153 pub const fn ptr() -> *const glcdc::RegisterBlock {
1154 Self::PTR
1155 }
1156}
1157impl Deref for GLCDC {
1158 type Target = glcdc::RegisterBlock;
1159 #[inline(always)]
1160 fn deref(&self) -> &Self::Target {
1161 unsafe { &*Self::PTR }
1162 }
1163}
1164impl core::fmt::Debug for GLCDC {
1165 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1166 f.debug_struct("GLCDC").finish()
1167 }
1168}
1169#[doc = "Graphics LCD Controller"]
1170pub mod glcdc;
1171#[doc = "2D Drawing Engine"]
1172pub struct DRW {
1173 _marker: PhantomData<*const ()>,
1174}
1175unsafe impl Send for DRW {}
1176impl DRW {
1177 #[doc = r"Pointer to the register block"]
1178 pub const PTR: *const drw::RegisterBlock = 0x400e_4000 as *const _;
1179 #[doc = r"Return the pointer to the register block"]
1180 #[inline(always)]
1181 pub const fn ptr() -> *const drw::RegisterBlock {
1182 Self::PTR
1183 }
1184}
1185impl Deref for DRW {
1186 type Target = drw::RegisterBlock;
1187 #[inline(always)]
1188 fn deref(&self) -> &Self::Target {
1189 unsafe { &*Self::PTR }
1190 }
1191}
1192impl core::fmt::Debug for DRW {
1193 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1194 f.debug_struct("DRW").finish()
1195 }
1196}
1197#[doc = "2D Drawing Engine"]
1198pub mod drw;
1199#[doc = "USB 2.0 High-Speed Module"]
1200pub struct USBHS {
1201 _marker: PhantomData<*const ()>,
1202}
1203unsafe impl Send for USBHS {}
1204impl USBHS {
1205 #[doc = r"Pointer to the register block"]
1206 pub const PTR: *const usbhs::RegisterBlock = 0x4006_0000 as *const _;
1207 #[doc = r"Return the pointer to the register block"]
1208 #[inline(always)]
1209 pub const fn ptr() -> *const usbhs::RegisterBlock {
1210 Self::PTR
1211 }
1212}
1213impl Deref for USBHS {
1214 type Target = usbhs::RegisterBlock;
1215 #[inline(always)]
1216 fn deref(&self) -> &Self::Target {
1217 unsafe { &*Self::PTR }
1218 }
1219}
1220impl core::fmt::Debug for USBHS {
1221 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1222 f.debug_struct("USBHS").finish()
1223 }
1224}
1225#[doc = "USB 2.0 High-Speed Module"]
1226pub mod usbhs;
1227#[doc = "Serial Communication Interface 0"]
1228pub struct SCI0 {
1229 _marker: PhantomData<*const ()>,
1230}
1231unsafe impl Send for SCI0 {}
1232impl SCI0 {
1233 #[doc = r"Pointer to the register block"]
1234 pub const PTR: *const sci0::RegisterBlock = 0x4007_0000 as *const _;
1235 #[doc = r"Return the pointer to the register block"]
1236 #[inline(always)]
1237 pub const fn ptr() -> *const sci0::RegisterBlock {
1238 Self::PTR
1239 }
1240}
1241impl Deref for SCI0 {
1242 type Target = sci0::RegisterBlock;
1243 #[inline(always)]
1244 fn deref(&self) -> &Self::Target {
1245 unsafe { &*Self::PTR }
1246 }
1247}
1248impl core::fmt::Debug for SCI0 {
1249 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1250 f.debug_struct("SCI0").finish()
1251 }
1252}
1253#[doc = "Serial Communication Interface 0"]
1254pub mod sci0;
1255#[doc = "Serial Communication Interface 1"]
1256pub struct SCI1 {
1257 _marker: PhantomData<*const ()>,
1258}
1259unsafe impl Send for SCI1 {}
1260impl SCI1 {
1261 #[doc = r"Pointer to the register block"]
1262 pub const PTR: *const sci0::RegisterBlock = 0x4007_0020 as *const _;
1263 #[doc = r"Return the pointer to the register block"]
1264 #[inline(always)]
1265 pub const fn ptr() -> *const sci0::RegisterBlock {
1266 Self::PTR
1267 }
1268}
1269impl Deref for SCI1 {
1270 type Target = sci0::RegisterBlock;
1271 #[inline(always)]
1272 fn deref(&self) -> &Self::Target {
1273 unsafe { &*Self::PTR }
1274 }
1275}
1276impl core::fmt::Debug for SCI1 {
1277 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1278 f.debug_struct("SCI1").finish()
1279 }
1280}
1281#[doc = "Serial Communication Interface 1"]
1282pub use self::sci0 as sci1;
1283#[doc = "Serial Communication Interface 2"]
1284pub struct SCI2 {
1285 _marker: PhantomData<*const ()>,
1286}
1287unsafe impl Send for SCI2 {}
1288impl SCI2 {
1289 #[doc = r"Pointer to the register block"]
1290 pub const PTR: *const sci0::RegisterBlock = 0x4007_0040 as *const _;
1291 #[doc = r"Return the pointer to the register block"]
1292 #[inline(always)]
1293 pub const fn ptr() -> *const sci0::RegisterBlock {
1294 Self::PTR
1295 }
1296}
1297impl Deref for SCI2 {
1298 type Target = sci0::RegisterBlock;
1299 #[inline(always)]
1300 fn deref(&self) -> &Self::Target {
1301 unsafe { &*Self::PTR }
1302 }
1303}
1304impl core::fmt::Debug for SCI2 {
1305 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1306 f.debug_struct("SCI2").finish()
1307 }
1308}
1309#[doc = "Serial Communication Interface 2"]
1310pub use self::sci0 as sci2;
1311#[doc = "Serial Communication Interface 3"]
1312pub struct SCI3 {
1313 _marker: PhantomData<*const ()>,
1314}
1315unsafe impl Send for SCI3 {}
1316impl SCI3 {
1317 #[doc = r"Pointer to the register block"]
1318 pub const PTR: *const sci0::RegisterBlock = 0x4007_0060 as *const _;
1319 #[doc = r"Return the pointer to the register block"]
1320 #[inline(always)]
1321 pub const fn ptr() -> *const sci0::RegisterBlock {
1322 Self::PTR
1323 }
1324}
1325impl Deref for SCI3 {
1326 type Target = sci0::RegisterBlock;
1327 #[inline(always)]
1328 fn deref(&self) -> &Self::Target {
1329 unsafe { &*Self::PTR }
1330 }
1331}
1332impl core::fmt::Debug for SCI3 {
1333 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1334 f.debug_struct("SCI3").finish()
1335 }
1336}
1337#[doc = "Serial Communication Interface 3"]
1338pub use self::sci0 as sci3;
1339#[doc = "Serial Communication Interface 4"]
1340pub struct SCI4 {
1341 _marker: PhantomData<*const ()>,
1342}
1343unsafe impl Send for SCI4 {}
1344impl SCI4 {
1345 #[doc = r"Pointer to the register block"]
1346 pub const PTR: *const sci0::RegisterBlock = 0x4007_0080 as *const _;
1347 #[doc = r"Return the pointer to the register block"]
1348 #[inline(always)]
1349 pub const fn ptr() -> *const sci0::RegisterBlock {
1350 Self::PTR
1351 }
1352}
1353impl Deref for SCI4 {
1354 type Target = sci0::RegisterBlock;
1355 #[inline(always)]
1356 fn deref(&self) -> &Self::Target {
1357 unsafe { &*Self::PTR }
1358 }
1359}
1360impl core::fmt::Debug for SCI4 {
1361 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1362 f.debug_struct("SCI4").finish()
1363 }
1364}
1365#[doc = "Serial Communication Interface 4"]
1366pub use self::sci0 as sci4;
1367#[doc = "Serial Communication Interface 5"]
1368pub struct SCI5 {
1369 _marker: PhantomData<*const ()>,
1370}
1371unsafe impl Send for SCI5 {}
1372impl SCI5 {
1373 #[doc = r"Pointer to the register block"]
1374 pub const PTR: *const sci0::RegisterBlock = 0x4007_00a0 as *const _;
1375 #[doc = r"Return the pointer to the register block"]
1376 #[inline(always)]
1377 pub const fn ptr() -> *const sci0::RegisterBlock {
1378 Self::PTR
1379 }
1380}
1381impl Deref for SCI5 {
1382 type Target = sci0::RegisterBlock;
1383 #[inline(always)]
1384 fn deref(&self) -> &Self::Target {
1385 unsafe { &*Self::PTR }
1386 }
1387}
1388impl core::fmt::Debug for SCI5 {
1389 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1390 f.debug_struct("SCI5").finish()
1391 }
1392}
1393#[doc = "Serial Communication Interface 5"]
1394pub use self::sci0 as sci5;
1395#[doc = "Serial Communication Interface 6"]
1396pub struct SCI6 {
1397 _marker: PhantomData<*const ()>,
1398}
1399unsafe impl Send for SCI6 {}
1400impl SCI6 {
1401 #[doc = r"Pointer to the register block"]
1402 pub const PTR: *const sci0::RegisterBlock = 0x4007_00c0 as *const _;
1403 #[doc = r"Return the pointer to the register block"]
1404 #[inline(always)]
1405 pub const fn ptr() -> *const sci0::RegisterBlock {
1406 Self::PTR
1407 }
1408}
1409impl Deref for SCI6 {
1410 type Target = sci0::RegisterBlock;
1411 #[inline(always)]
1412 fn deref(&self) -> &Self::Target {
1413 unsafe { &*Self::PTR }
1414 }
1415}
1416impl core::fmt::Debug for SCI6 {
1417 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1418 f.debug_struct("SCI6").finish()
1419 }
1420}
1421#[doc = "Serial Communication Interface 6"]
1422pub use self::sci0 as sci6;
1423#[doc = "Serial Communication Interface 7"]
1424pub struct SCI7 {
1425 _marker: PhantomData<*const ()>,
1426}
1427unsafe impl Send for SCI7 {}
1428impl SCI7 {
1429 #[doc = r"Pointer to the register block"]
1430 pub const PTR: *const sci0::RegisterBlock = 0x4007_00e0 as *const _;
1431 #[doc = r"Return the pointer to the register block"]
1432 #[inline(always)]
1433 pub const fn ptr() -> *const sci0::RegisterBlock {
1434 Self::PTR
1435 }
1436}
1437impl Deref for SCI7 {
1438 type Target = sci0::RegisterBlock;
1439 #[inline(always)]
1440 fn deref(&self) -> &Self::Target {
1441 unsafe { &*Self::PTR }
1442 }
1443}
1444impl core::fmt::Debug for SCI7 {
1445 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1446 f.debug_struct("SCI7").finish()
1447 }
1448}
1449#[doc = "Serial Communication Interface 7"]
1450pub use self::sci0 as sci7;
1451#[doc = "Serial Communication Interface 8"]
1452pub struct SCI8 {
1453 _marker: PhantomData<*const ()>,
1454}
1455unsafe impl Send for SCI8 {}
1456impl SCI8 {
1457 #[doc = r"Pointer to the register block"]
1458 pub const PTR: *const sci0::RegisterBlock = 0x4007_0100 as *const _;
1459 #[doc = r"Return the pointer to the register block"]
1460 #[inline(always)]
1461 pub const fn ptr() -> *const sci0::RegisterBlock {
1462 Self::PTR
1463 }
1464}
1465impl Deref for SCI8 {
1466 type Target = sci0::RegisterBlock;
1467 #[inline(always)]
1468 fn deref(&self) -> &Self::Target {
1469 unsafe { &*Self::PTR }
1470 }
1471}
1472impl core::fmt::Debug for SCI8 {
1473 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1474 f.debug_struct("SCI8").finish()
1475 }
1476}
1477#[doc = "Serial Communication Interface 8"]
1478pub use self::sci0 as sci8;
1479#[doc = "Serial Communication Interface 9"]
1480pub struct SCI9 {
1481 _marker: PhantomData<*const ()>,
1482}
1483unsafe impl Send for SCI9 {}
1484impl SCI9 {
1485 #[doc = r"Pointer to the register block"]
1486 pub const PTR: *const sci0::RegisterBlock = 0x4007_0120 as *const _;
1487 #[doc = r"Return the pointer to the register block"]
1488 #[inline(always)]
1489 pub const fn ptr() -> *const sci0::RegisterBlock {
1490 Self::PTR
1491 }
1492}
1493impl Deref for SCI9 {
1494 type Target = sci0::RegisterBlock;
1495 #[inline(always)]
1496 fn deref(&self) -> &Self::Target {
1497 unsafe { &*Self::PTR }
1498 }
1499}
1500impl core::fmt::Debug for SCI9 {
1501 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1502 f.debug_struct("SCI9").finish()
1503 }
1504}
1505#[doc = "Serial Communication Interface 9"]
1506pub use self::sci0 as sci9;
1507#[doc = "Inter-Integrated Circuit 0"]
1508pub struct IIC0 {
1509 _marker: PhantomData<*const ()>,
1510}
1511unsafe impl Send for IIC0 {}
1512impl IIC0 {
1513 #[doc = r"Pointer to the register block"]
1514 pub const PTR: *const iic0::RegisterBlock = 0x4005_3000 as *const _;
1515 #[doc = r"Return the pointer to the register block"]
1516 #[inline(always)]
1517 pub const fn ptr() -> *const iic0::RegisterBlock {
1518 Self::PTR
1519 }
1520}
1521impl Deref for IIC0 {
1522 type Target = iic0::RegisterBlock;
1523 #[inline(always)]
1524 fn deref(&self) -> &Self::Target {
1525 unsafe { &*Self::PTR }
1526 }
1527}
1528impl core::fmt::Debug for IIC0 {
1529 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1530 f.debug_struct("IIC0").finish()
1531 }
1532}
1533#[doc = "Inter-Integrated Circuit 0"]
1534pub mod iic0;
1535#[doc = "Inter-Integrated Circuit 1"]
1536pub struct IIC1 {
1537 _marker: PhantomData<*const ()>,
1538}
1539unsafe impl Send for IIC1 {}
1540impl IIC1 {
1541 #[doc = r"Pointer to the register block"]
1542 pub const PTR: *const iic1::RegisterBlock = 0x4005_3100 as *const _;
1543 #[doc = r"Return the pointer to the register block"]
1544 #[inline(always)]
1545 pub const fn ptr() -> *const iic1::RegisterBlock {
1546 Self::PTR
1547 }
1548}
1549impl Deref for IIC1 {
1550 type Target = iic1::RegisterBlock;
1551 #[inline(always)]
1552 fn deref(&self) -> &Self::Target {
1553 unsafe { &*Self::PTR }
1554 }
1555}
1556impl core::fmt::Debug for IIC1 {
1557 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1558 f.debug_struct("IIC1").finish()
1559 }
1560}
1561#[doc = "Inter-Integrated Circuit 1"]
1562pub mod iic1;
1563#[doc = "Inter-Integrated Circuit 2"]
1564pub struct IIC2 {
1565 _marker: PhantomData<*const ()>,
1566}
1567unsafe impl Send for IIC2 {}
1568impl IIC2 {
1569 #[doc = r"Pointer to the register block"]
1570 pub const PTR: *const iic1::RegisterBlock = 0x4005_3200 as *const _;
1571 #[doc = r"Return the pointer to the register block"]
1572 #[inline(always)]
1573 pub const fn ptr() -> *const iic1::RegisterBlock {
1574 Self::PTR
1575 }
1576}
1577impl Deref for IIC2 {
1578 type Target = iic1::RegisterBlock;
1579 #[inline(always)]
1580 fn deref(&self) -> &Self::Target {
1581 unsafe { &*Self::PTR }
1582 }
1583}
1584impl core::fmt::Debug for IIC2 {
1585 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1586 f.debug_struct("IIC2").finish()
1587 }
1588}
1589#[doc = "Inter-Integrated Circuit 2"]
1590pub use self::iic1 as iic2;
1591#[doc = "System Control"]
1592pub struct SYSTEM {
1593 _marker: PhantomData<*const ()>,
1594}
1595unsafe impl Send for SYSTEM {}
1596impl SYSTEM {
1597 #[doc = r"Pointer to the register block"]
1598 pub const PTR: *const system::RegisterBlock = 0x4001_e000 as *const _;
1599 #[doc = r"Return the pointer to the register block"]
1600 #[inline(always)]
1601 pub const fn ptr() -> *const system::RegisterBlock {
1602 Self::PTR
1603 }
1604}
1605impl Deref for SYSTEM {
1606 type Target = system::RegisterBlock;
1607 #[inline(always)]
1608 fn deref(&self) -> &Self::Target {
1609 unsafe { &*Self::PTR }
1610 }
1611}
1612impl core::fmt::Debug for SYSTEM {
1613 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1614 f.debug_struct("SYSTEM").finish()
1615 }
1616}
1617#[doc = "System Control"]
1618pub mod system;
1619#[doc = "DMA Controller for the Ethernet Controller Channel 0"]
1620pub struct EDMAC0 {
1621 _marker: PhantomData<*const ()>,
1622}
1623unsafe impl Send for EDMAC0 {}
1624impl EDMAC0 {
1625 #[doc = r"Pointer to the register block"]
1626 pub const PTR: *const edmac0::RegisterBlock = 0x4006_4000 as *const _;
1627 #[doc = r"Return the pointer to the register block"]
1628 #[inline(always)]
1629 pub const fn ptr() -> *const edmac0::RegisterBlock {
1630 Self::PTR
1631 }
1632}
1633impl Deref for EDMAC0 {
1634 type Target = edmac0::RegisterBlock;
1635 #[inline(always)]
1636 fn deref(&self) -> &Self::Target {
1637 unsafe { &*Self::PTR }
1638 }
1639}
1640impl core::fmt::Debug for EDMAC0 {
1641 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1642 f.debug_struct("EDMAC0").finish()
1643 }
1644}
1645#[doc = "DMA Controller for the Ethernet Controller Channel 0"]
1646pub mod edmac0;
1647#[doc = "Ethernet Controller Channel 0"]
1648pub struct ETHERC0 {
1649 _marker: PhantomData<*const ()>,
1650}
1651unsafe impl Send for ETHERC0 {}
1652impl ETHERC0 {
1653 #[doc = r"Pointer to the register block"]
1654 pub const PTR: *const etherc0::RegisterBlock = 0x4006_4100 as *const _;
1655 #[doc = r"Return the pointer to the register block"]
1656 #[inline(always)]
1657 pub const fn ptr() -> *const etherc0::RegisterBlock {
1658 Self::PTR
1659 }
1660}
1661impl Deref for ETHERC0 {
1662 type Target = etherc0::RegisterBlock;
1663 #[inline(always)]
1664 fn deref(&self) -> &Self::Target {
1665 unsafe { &*Self::PTR }
1666 }
1667}
1668impl core::fmt::Debug for ETHERC0 {
1669 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1670 f.debug_struct("ETHERC0").finish()
1671 }
1672}
1673#[doc = "Ethernet Controller Channel 0"]
1674pub mod etherc0;
1675#[doc = "DMA Controller for EPTPC"]
1676pub struct PTPEDMAC {
1677 _marker: PhantomData<*const ()>,
1678}
1679unsafe impl Send for PTPEDMAC {}
1680impl PTPEDMAC {
1681 #[doc = r"Pointer to the register block"]
1682 pub const PTR: *const ptpedmac::RegisterBlock = 0x4006_4400 as *const _;
1683 #[doc = r"Return the pointer to the register block"]
1684 #[inline(always)]
1685 pub const fn ptr() -> *const ptpedmac::RegisterBlock {
1686 Self::PTR
1687 }
1688}
1689impl Deref for PTPEDMAC {
1690 type Target = ptpedmac::RegisterBlock;
1691 #[inline(always)]
1692 fn deref(&self) -> &Self::Target {
1693 unsafe { &*Self::PTR }
1694 }
1695}
1696impl core::fmt::Debug for PTPEDMAC {
1697 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1698 f.debug_struct("PTPEDMAC").finish()
1699 }
1700}
1701#[doc = "DMA Controller for EPTPC"]
1702pub mod ptpedmac;
1703#[doc = "PTP Module for the Ethernet Controller"]
1704pub struct EPTPC {
1705 _marker: PhantomData<*const ()>,
1706}
1707unsafe impl Send for EPTPC {}
1708impl EPTPC {
1709 #[doc = r"Pointer to the register block"]
1710 pub const PTR: *const eptpc::RegisterBlock = 0x4006_5000 as *const _;
1711 #[doc = r"Return the pointer to the register block"]
1712 #[inline(always)]
1713 pub const fn ptr() -> *const eptpc::RegisterBlock {
1714 Self::PTR
1715 }
1716}
1717impl Deref for EPTPC {
1718 type Target = eptpc::RegisterBlock;
1719 #[inline(always)]
1720 fn deref(&self) -> &Self::Target {
1721 unsafe { &*Self::PTR }
1722 }
1723}
1724impl core::fmt::Debug for EPTPC {
1725 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1726 f.debug_struct("EPTPC").finish()
1727 }
1728}
1729#[doc = "PTP Module for the Ethernet Controller"]
1730pub mod eptpc;
1731#[doc = "PTP Module 0 for the Ethernet Controller"]
1732pub struct EPTPC0 {
1733 _marker: PhantomData<*const ()>,
1734}
1735unsafe impl Send for EPTPC0 {}
1736impl EPTPC0 {
1737 #[doc = r"Pointer to the register block"]
1738 pub const PTR: *const eptpc0::RegisterBlock = 0x4006_5800 as *const _;
1739 #[doc = r"Return the pointer to the register block"]
1740 #[inline(always)]
1741 pub const fn ptr() -> *const eptpc0::RegisterBlock {
1742 Self::PTR
1743 }
1744}
1745impl Deref for EPTPC0 {
1746 type Target = eptpc0::RegisterBlock;
1747 #[inline(always)]
1748 fn deref(&self) -> &Self::Target {
1749 unsafe { &*Self::PTR }
1750 }
1751}
1752impl core::fmt::Debug for EPTPC0 {
1753 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1754 f.debug_struct("EPTPC0").finish()
1755 }
1756}
1757#[doc = "PTP Module 0 for the Ethernet Controller"]
1758pub mod eptpc0;
1759#[doc = "EPTPC Configulation"]
1760pub struct EPTPC_CFG {
1761 _marker: PhantomData<*const ()>,
1762}
1763unsafe impl Send for EPTPC_CFG {}
1764impl EPTPC_CFG {
1765 #[doc = r"Pointer to the register block"]
1766 pub const PTR: *const eptpc_cfg::RegisterBlock = 0x4006_4500 as *const _;
1767 #[doc = r"Return the pointer to the register block"]
1768 #[inline(always)]
1769 pub const fn ptr() -> *const eptpc_cfg::RegisterBlock {
1770 Self::PTR
1771 }
1772}
1773impl Deref for EPTPC_CFG {
1774 type Target = eptpc_cfg::RegisterBlock;
1775 #[inline(always)]
1776 fn deref(&self) -> &Self::Target {
1777 unsafe { &*Self::PTR }
1778 }
1779}
1780impl core::fmt::Debug for EPTPC_CFG {
1781 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1782 f.debug_struct("EPTPC_CFG").finish()
1783 }
1784}
1785#[doc = "EPTPC Configulation"]
1786pub mod eptpc_cfg;
1787#[doc = "SD Host Interface 0"]
1788pub struct SDHI0 {
1789 _marker: PhantomData<*const ()>,
1790}
1791unsafe impl Send for SDHI0 {}
1792impl SDHI0 {
1793 #[doc = r"Pointer to the register block"]
1794 pub const PTR: *const sdhi0::RegisterBlock = 0x4006_2000 as *const _;
1795 #[doc = r"Return the pointer to the register block"]
1796 #[inline(always)]
1797 pub const fn ptr() -> *const sdhi0::RegisterBlock {
1798 Self::PTR
1799 }
1800}
1801impl Deref for SDHI0 {
1802 type Target = sdhi0::RegisterBlock;
1803 #[inline(always)]
1804 fn deref(&self) -> &Self::Target {
1805 unsafe { &*Self::PTR }
1806 }
1807}
1808impl core::fmt::Debug for SDHI0 {
1809 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1810 f.debug_struct("SDHI0").finish()
1811 }
1812}
1813#[doc = "SD Host Interface 0"]
1814pub mod sdhi0;
1815#[doc = "SD Host Interface 1"]
1816pub struct SDHI1 {
1817 _marker: PhantomData<*const ()>,
1818}
1819unsafe impl Send for SDHI1 {}
1820impl SDHI1 {
1821 #[doc = r"Pointer to the register block"]
1822 pub const PTR: *const sdhi0::RegisterBlock = 0x4006_2400 as *const _;
1823 #[doc = r"Return the pointer to the register block"]
1824 #[inline(always)]
1825 pub const fn ptr() -> *const sdhi0::RegisterBlock {
1826 Self::PTR
1827 }
1828}
1829impl Deref for SDHI1 {
1830 type Target = sdhi0::RegisterBlock;
1831 #[inline(always)]
1832 fn deref(&self) -> &Self::Target {
1833 unsafe { &*Self::PTR }
1834 }
1835}
1836impl core::fmt::Debug for SDHI1 {
1837 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1838 f.debug_struct("SDHI1").finish()
1839 }
1840}
1841#[doc = "SD Host Interface 1"]
1842pub use self::sdhi0 as sdhi1;
1843#[doc = "CRC Calculator"]
1844pub struct CRC {
1845 _marker: PhantomData<*const ()>,
1846}
1847unsafe impl Send for CRC {}
1848impl CRC {
1849 #[doc = r"Pointer to the register block"]
1850 pub const PTR: *const crc::RegisterBlock = 0x4007_4000 as *const _;
1851 #[doc = r"Return the pointer to the register block"]
1852 #[inline(always)]
1853 pub const fn ptr() -> *const crc::RegisterBlock {
1854 Self::PTR
1855 }
1856}
1857impl Deref for CRC {
1858 type Target = crc::RegisterBlock;
1859 #[inline(always)]
1860 fn deref(&self) -> &Self::Target {
1861 unsafe { &*Self::PTR }
1862 }
1863}
1864impl core::fmt::Debug for CRC {
1865 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1866 f.debug_struct("CRC").finish()
1867 }
1868}
1869#[doc = "CRC Calculator"]
1870pub mod crc;
1871#[doc = "Capacitive Touch Sensing Unit"]
1872pub struct CTSU {
1873 _marker: PhantomData<*const ()>,
1874}
1875unsafe impl Send for CTSU {}
1876impl CTSU {
1877 #[doc = r"Pointer to the register block"]
1878 pub const PTR: *const ctsu::RegisterBlock = 0x4008_1000 as *const _;
1879 #[doc = r"Return the pointer to the register block"]
1880 #[inline(always)]
1881 pub const fn ptr() -> *const ctsu::RegisterBlock {
1882 Self::PTR
1883 }
1884}
1885impl Deref for CTSU {
1886 type Target = ctsu::RegisterBlock;
1887 #[inline(always)]
1888 fn deref(&self) -> &Self::Target {
1889 unsafe { &*Self::PTR }
1890 }
1891}
1892impl core::fmt::Debug for CTSU {
1893 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1894 f.debug_struct("CTSU").finish()
1895 }
1896}
1897#[doc = "Capacitive Touch Sensing Unit"]
1898pub mod ctsu;
1899#[doc = "Bus Master MPU"]
1900pub struct MMPU {
1901 _marker: PhantomData<*const ()>,
1902}
1903unsafe impl Send for MMPU {}
1904impl MMPU {
1905 #[doc = r"Pointer to the register block"]
1906 pub const PTR: *const mmpu::RegisterBlock = 0x4000_0000 as *const _;
1907 #[doc = r"Return the pointer to the register block"]
1908 #[inline(always)]
1909 pub const fn ptr() -> *const mmpu::RegisterBlock {
1910 Self::PTR
1911 }
1912}
1913impl Deref for MMPU {
1914 type Target = mmpu::RegisterBlock;
1915 #[inline(always)]
1916 fn deref(&self) -> &Self::Target {
1917 unsafe { &*Self::PTR }
1918 }
1919}
1920impl core::fmt::Debug for MMPU {
1921 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1922 f.debug_struct("MMPU").finish()
1923 }
1924}
1925#[doc = "Bus Master MPU"]
1926pub mod mmpu;
1927#[doc = "Bus Slave MPU"]
1928pub struct SMPU {
1929 _marker: PhantomData<*const ()>,
1930}
1931unsafe impl Send for SMPU {}
1932impl SMPU {
1933 #[doc = r"Pointer to the register block"]
1934 pub const PTR: *const smpu::RegisterBlock = 0x4000_0c00 as *const _;
1935 #[doc = r"Return the pointer to the register block"]
1936 #[inline(always)]
1937 pub const fn ptr() -> *const smpu::RegisterBlock {
1938 Self::PTR
1939 }
1940}
1941impl Deref for SMPU {
1942 type Target = smpu::RegisterBlock;
1943 #[inline(always)]
1944 fn deref(&self) -> &Self::Target {
1945 unsafe { &*Self::PTR }
1946 }
1947}
1948impl core::fmt::Debug for SMPU {
1949 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1950 f.debug_struct("SMPU").finish()
1951 }
1952}
1953#[doc = "Bus Slave MPU"]
1954pub mod smpu;
1955#[doc = "CPU Stack Pointer Monitor"]
1956pub struct SPMON {
1957 _marker: PhantomData<*const ()>,
1958}
1959unsafe impl Send for SPMON {}
1960impl SPMON {
1961 #[doc = r"Pointer to the register block"]
1962 pub const PTR: *const spmon::RegisterBlock = 0x4000_0d00 as *const _;
1963 #[doc = r"Return the pointer to the register block"]
1964 #[inline(always)]
1965 pub const fn ptr() -> *const spmon::RegisterBlock {
1966 Self::PTR
1967 }
1968}
1969impl Deref for SPMON {
1970 type Target = spmon::RegisterBlock;
1971 #[inline(always)]
1972 fn deref(&self) -> &Self::Target {
1973 unsafe { &*Self::PTR }
1974 }
1975}
1976impl core::fmt::Debug for SPMON {
1977 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1978 f.debug_struct("SPMON").finish()
1979 }
1980}
1981#[doc = "CPU Stack Pointer Monitor"]
1982pub mod spmon;
1983#[doc = "12bit A/D Converter 0"]
1984pub struct ADC120 {
1985 _marker: PhantomData<*const ()>,
1986}
1987unsafe impl Send for ADC120 {}
1988impl ADC120 {
1989 #[doc = r"Pointer to the register block"]
1990 pub const PTR: *const adc120::RegisterBlock = 0x4005_c000 as *const _;
1991 #[doc = r"Return the pointer to the register block"]
1992 #[inline(always)]
1993 pub const fn ptr() -> *const adc120::RegisterBlock {
1994 Self::PTR
1995 }
1996}
1997impl Deref for ADC120 {
1998 type Target = adc120::RegisterBlock;
1999 #[inline(always)]
2000 fn deref(&self) -> &Self::Target {
2001 unsafe { &*Self::PTR }
2002 }
2003}
2004impl core::fmt::Debug for ADC120 {
2005 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2006 f.debug_struct("ADC120").finish()
2007 }
2008}
2009#[doc = "12bit A/D Converter 0"]
2010pub mod adc120;
2011#[doc = "12bit A/D Converter 1"]
2012pub struct ADC121 {
2013 _marker: PhantomData<*const ()>,
2014}
2015unsafe impl Send for ADC121 {}
2016impl ADC121 {
2017 #[doc = r"Pointer to the register block"]
2018 pub const PTR: *const adc121::RegisterBlock = 0x4005_c200 as *const _;
2019 #[doc = r"Return the pointer to the register block"]
2020 #[inline(always)]
2021 pub const fn ptr() -> *const adc121::RegisterBlock {
2022 Self::PTR
2023 }
2024}
2025impl Deref for ADC121 {
2026 type Target = adc121::RegisterBlock;
2027 #[inline(always)]
2028 fn deref(&self) -> &Self::Target {
2029 unsafe { &*Self::PTR }
2030 }
2031}
2032impl core::fmt::Debug for ADC121 {
2033 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2034 f.debug_struct("ADC121").finish()
2035 }
2036}
2037#[doc = "12bit A/D Converter 1"]
2038pub mod adc121;
2039#[doc = "Module Stop Control B,C,D"]
2040pub struct MSTP {
2041 _marker: PhantomData<*const ()>,
2042}
2043unsafe impl Send for MSTP {}
2044impl MSTP {
2045 #[doc = r"Pointer to the register block"]
2046 pub const PTR: *const mstp::RegisterBlock = 0x4004_7000 as *const _;
2047 #[doc = r"Return the pointer to the register block"]
2048 #[inline(always)]
2049 pub const fn ptr() -> *const mstp::RegisterBlock {
2050 Self::PTR
2051 }
2052}
2053impl Deref for MSTP {
2054 type Target = mstp::RegisterBlock;
2055 #[inline(always)]
2056 fn deref(&self) -> &Self::Target {
2057 unsafe { &*Self::PTR }
2058 }
2059}
2060impl core::fmt::Debug for MSTP {
2061 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2062 f.debug_struct("MSTP").finish()
2063 }
2064}
2065#[doc = "Module Stop Control B,C,D"]
2066pub mod mstp;
2067#[doc = "General PWM Timer 8 (32-bit Enhanced)"]
2068pub struct GPT328 {
2069 _marker: PhantomData<*const ()>,
2070}
2071unsafe impl Send for GPT328 {}
2072impl GPT328 {
2073 #[doc = r"Pointer to the register block"]
2074 pub const PTR: *const gpt328::RegisterBlock = 0x4007_8800 as *const _;
2075 #[doc = r"Return the pointer to the register block"]
2076 #[inline(always)]
2077 pub const fn ptr() -> *const gpt328::RegisterBlock {
2078 Self::PTR
2079 }
2080}
2081impl Deref for GPT328 {
2082 type Target = gpt328::RegisterBlock;
2083 #[inline(always)]
2084 fn deref(&self) -> &Self::Target {
2085 unsafe { &*Self::PTR }
2086 }
2087}
2088impl core::fmt::Debug for GPT328 {
2089 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2090 f.debug_struct("GPT328").finish()
2091 }
2092}
2093#[doc = "General PWM Timer 8 (32-bit Enhanced)"]
2094pub mod gpt328;
2095#[doc = "General PWM Timer 9 (32-bit Enhanced)"]
2096pub struct GPT329 {
2097 _marker: PhantomData<*const ()>,
2098}
2099unsafe impl Send for GPT329 {}
2100impl GPT329 {
2101 #[doc = r"Pointer to the register block"]
2102 pub const PTR: *const gpt328::RegisterBlock = 0x4007_8900 as *const _;
2103 #[doc = r"Return the pointer to the register block"]
2104 #[inline(always)]
2105 pub const fn ptr() -> *const gpt328::RegisterBlock {
2106 Self::PTR
2107 }
2108}
2109impl Deref for GPT329 {
2110 type Target = gpt328::RegisterBlock;
2111 #[inline(always)]
2112 fn deref(&self) -> &Self::Target {
2113 unsafe { &*Self::PTR }
2114 }
2115}
2116impl core::fmt::Debug for GPT329 {
2117 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2118 f.debug_struct("GPT329").finish()
2119 }
2120}
2121#[doc = "General PWM Timer 9 (32-bit Enhanced)"]
2122pub use self::gpt328 as gpt329;
2123#[doc = "General PWM Timer 10 (32-bit Enhanced)"]
2124pub struct GPT3210 {
2125 _marker: PhantomData<*const ()>,
2126}
2127unsafe impl Send for GPT3210 {}
2128impl GPT3210 {
2129 #[doc = r"Pointer to the register block"]
2130 pub const PTR: *const gpt328::RegisterBlock = 0x4007_8a00 as *const _;
2131 #[doc = r"Return the pointer to the register block"]
2132 #[inline(always)]
2133 pub const fn ptr() -> *const gpt328::RegisterBlock {
2134 Self::PTR
2135 }
2136}
2137impl Deref for GPT3210 {
2138 type Target = gpt328::RegisterBlock;
2139 #[inline(always)]
2140 fn deref(&self) -> &Self::Target {
2141 unsafe { &*Self::PTR }
2142 }
2143}
2144impl core::fmt::Debug for GPT3210 {
2145 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2146 f.debug_struct("GPT3210").finish()
2147 }
2148}
2149#[doc = "General PWM Timer 10 (32-bit Enhanced)"]
2150pub use self::gpt328 as gpt3210;
2151#[doc = "General PWM Timer 11 (32-bit Enhanced)"]
2152pub struct GPT3211 {
2153 _marker: PhantomData<*const ()>,
2154}
2155unsafe impl Send for GPT3211 {}
2156impl GPT3211 {
2157 #[doc = r"Pointer to the register block"]
2158 pub const PTR: *const gpt328::RegisterBlock = 0x4007_8b00 as *const _;
2159 #[doc = r"Return the pointer to the register block"]
2160 #[inline(always)]
2161 pub const fn ptr() -> *const gpt328::RegisterBlock {
2162 Self::PTR
2163 }
2164}
2165impl Deref for GPT3211 {
2166 type Target = gpt328::RegisterBlock;
2167 #[inline(always)]
2168 fn deref(&self) -> &Self::Target {
2169 unsafe { &*Self::PTR }
2170 }
2171}
2172impl core::fmt::Debug for GPT3211 {
2173 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2174 f.debug_struct("GPT3211").finish()
2175 }
2176}
2177#[doc = "General PWM Timer 11 (32-bit Enhanced)"]
2178pub use self::gpt328 as gpt3211;
2179#[doc = "General PWM Timer 12 (32-bit Enhanced)"]
2180pub struct GPT3212 {
2181 _marker: PhantomData<*const ()>,
2182}
2183unsafe impl Send for GPT3212 {}
2184impl GPT3212 {
2185 #[doc = r"Pointer to the register block"]
2186 pub const PTR: *const gpt328::RegisterBlock = 0x4007_8c00 as *const _;
2187 #[doc = r"Return the pointer to the register block"]
2188 #[inline(always)]
2189 pub const fn ptr() -> *const gpt328::RegisterBlock {
2190 Self::PTR
2191 }
2192}
2193impl Deref for GPT3212 {
2194 type Target = gpt328::RegisterBlock;
2195 #[inline(always)]
2196 fn deref(&self) -> &Self::Target {
2197 unsafe { &*Self::PTR }
2198 }
2199}
2200impl core::fmt::Debug for GPT3212 {
2201 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2202 f.debug_struct("GPT3212").finish()
2203 }
2204}
2205#[doc = "General PWM Timer 12 (32-bit Enhanced)"]
2206pub use self::gpt328 as gpt3212;
2207#[doc = "General PWM Timer 13 (32-bit Enhanced)"]
2208pub struct GPT3213 {
2209 _marker: PhantomData<*const ()>,
2210}
2211unsafe impl Send for GPT3213 {}
2212impl GPT3213 {
2213 #[doc = r"Pointer to the register block"]
2214 pub const PTR: *const gpt328::RegisterBlock = 0x4007_8d00 as *const _;
2215 #[doc = r"Return the pointer to the register block"]
2216 #[inline(always)]
2217 pub const fn ptr() -> *const gpt328::RegisterBlock {
2218 Self::PTR
2219 }
2220}
2221impl Deref for GPT3213 {
2222 type Target = gpt328::RegisterBlock;
2223 #[inline(always)]
2224 fn deref(&self) -> &Self::Target {
2225 unsafe { &*Self::PTR }
2226 }
2227}
2228impl core::fmt::Debug for GPT3213 {
2229 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2230 f.debug_struct("GPT3213").finish()
2231 }
2232}
2233#[doc = "General PWM Timer 13 (32-bit Enhanced)"]
2234pub use self::gpt328 as gpt3213;
2235#[doc = "Realtime Clock"]
2236pub struct RTC {
2237 _marker: PhantomData<*const ()>,
2238}
2239unsafe impl Send for RTC {}
2240impl RTC {
2241 #[doc = r"Pointer to the register block"]
2242 pub const PTR: *const rtc::RegisterBlock = 0x4004_4000 as *const _;
2243 #[doc = r"Return the pointer to the register block"]
2244 #[inline(always)]
2245 pub const fn ptr() -> *const rtc::RegisterBlock {
2246 Self::PTR
2247 }
2248}
2249impl Deref for RTC {
2250 type Target = rtc::RegisterBlock;
2251 #[inline(always)]
2252 fn deref(&self) -> &Self::Target {
2253 unsafe { &*Self::PTR }
2254 }
2255}
2256impl core::fmt::Debug for RTC {
2257 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2258 f.debug_struct("RTC").finish()
2259 }
2260}
2261#[doc = "Realtime Clock"]
2262pub mod rtc;
2263#[doc = "Serial Sound Interface Enhanced (SSIE)"]
2264pub struct SSIE0 {
2265 _marker: PhantomData<*const ()>,
2266}
2267unsafe impl Send for SSIE0 {}
2268impl SSIE0 {
2269 #[doc = r"Pointer to the register block"]
2270 pub const PTR: *const ssie0::RegisterBlock = 0x4004_e000 as *const _;
2271 #[doc = r"Return the pointer to the register block"]
2272 #[inline(always)]
2273 pub const fn ptr() -> *const ssie0::RegisterBlock {
2274 Self::PTR
2275 }
2276}
2277impl Deref for SSIE0 {
2278 type Target = ssie0::RegisterBlock;
2279 #[inline(always)]
2280 fn deref(&self) -> &Self::Target {
2281 unsafe { &*Self::PTR }
2282 }
2283}
2284impl core::fmt::Debug for SSIE0 {
2285 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2286 f.debug_struct("SSIE0").finish()
2287 }
2288}
2289#[doc = "Serial Sound Interface Enhanced (SSIE)"]
2290pub mod ssie0;
2291#[doc = "Serial Sound Interface Enhanced (SSIE)"]
2292pub struct SSIE1 {
2293 _marker: PhantomData<*const ()>,
2294}
2295unsafe impl Send for SSIE1 {}
2296impl SSIE1 {
2297 #[doc = r"Pointer to the register block"]
2298 pub const PTR: *const ssie0::RegisterBlock = 0x4004_e100 as *const _;
2299 #[doc = r"Return the pointer to the register block"]
2300 #[inline(always)]
2301 pub const fn ptr() -> *const ssie0::RegisterBlock {
2302 Self::PTR
2303 }
2304}
2305impl Deref for SSIE1 {
2306 type Target = ssie0::RegisterBlock;
2307 #[inline(always)]
2308 fn deref(&self) -> &Self::Target {
2309 unsafe { &*Self::PTR }
2310 }
2311}
2312impl core::fmt::Debug for SSIE1 {
2313 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2314 f.debug_struct("SSIE1").finish()
2315 }
2316}
2317#[doc = "Serial Sound Interface Enhanced (SSIE)"]
2318pub use self::ssie0 as ssie1;
2319#[doc = "USB 2.0 FS Module"]
2320pub struct USBFS {
2321 _marker: PhantomData<*const ()>,
2322}
2323unsafe impl Send for USBFS {}
2324impl USBFS {
2325 #[doc = r"Pointer to the register block"]
2326 pub const PTR: *const usbfs::RegisterBlock = 0x4009_0000 as *const _;
2327 #[doc = r"Return the pointer to the register block"]
2328 #[inline(always)]
2329 pub const fn ptr() -> *const usbfs::RegisterBlock {
2330 Self::PTR
2331 }
2332}
2333impl Deref for USBFS {
2334 type Target = usbfs::RegisterBlock;
2335 #[inline(always)]
2336 fn deref(&self) -> &Self::Target {
2337 unsafe { &*Self::PTR }
2338 }
2339}
2340impl core::fmt::Debug for USBFS {
2341 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2342 f.debug_struct("USBFS").finish()
2343 }
2344}
2345#[doc = "USB 2.0 FS Module"]
2346pub mod usbfs;
2347#[doc = "Sampling Rate Converter RAM"]
2348pub struct SRCRAM {
2349 _marker: PhantomData<*const ()>,
2350}
2351unsafe impl Send for SRCRAM {}
2352impl SRCRAM {
2353 #[doc = r"Pointer to the register block"]
2354 pub const PTR: *const srcram::RegisterBlock = 0x4004_8000 as *const _;
2355 #[doc = r"Return the pointer to the register block"]
2356 #[inline(always)]
2357 pub const fn ptr() -> *const srcram::RegisterBlock {
2358 Self::PTR
2359 }
2360}
2361impl Deref for SRCRAM {
2362 type Target = srcram::RegisterBlock;
2363 #[inline(always)]
2364 fn deref(&self) -> &Self::Target {
2365 unsafe { &*Self::PTR }
2366 }
2367}
2368impl core::fmt::Debug for SRCRAM {
2369 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2370 f.debug_struct("SRCRAM").finish()
2371 }
2372}
2373#[doc = "Sampling Rate Converter RAM"]
2374pub mod srcram;
2375#[doc = "Sampling Rate Converter"]
2376pub struct SRC {
2377 _marker: PhantomData<*const ()>,
2378}
2379unsafe impl Send for SRC {}
2380impl SRC {
2381 #[doc = r"Pointer to the register block"]
2382 pub const PTR: *const src::RegisterBlock = 0x4004_dff0 as *const _;
2383 #[doc = r"Return the pointer to the register block"]
2384 #[inline(always)]
2385 pub const fn ptr() -> *const src::RegisterBlock {
2386 Self::PTR
2387 }
2388}
2389impl Deref for SRC {
2390 type Target = src::RegisterBlock;
2391 #[inline(always)]
2392 fn deref(&self) -> &Self::Target {
2393 unsafe { &*Self::PTR }
2394 }
2395}
2396impl core::fmt::Debug for SRC {
2397 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2398 f.debug_struct("SRC").finish()
2399 }
2400}
2401#[doc = "Sampling Rate Converter"]
2402pub mod src;
2403#[doc = "Interrupt Controller"]
2404pub struct ICU {
2405 _marker: PhantomData<*const ()>,
2406}
2407unsafe impl Send for ICU {}
2408impl ICU {
2409 #[doc = r"Pointer to the register block"]
2410 pub const PTR: *const icu::RegisterBlock = 0x4000_6000 as *const _;
2411 #[doc = r"Return the pointer to the register block"]
2412 #[inline(always)]
2413 pub const fn ptr() -> *const icu::RegisterBlock {
2414 Self::PTR
2415 }
2416}
2417impl Deref for ICU {
2418 type Target = icu::RegisterBlock;
2419 #[inline(always)]
2420 fn deref(&self) -> &Self::Target {
2421 unsafe { &*Self::PTR }
2422 }
2423}
2424impl core::fmt::Debug for ICU {
2425 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2426 f.debug_struct("ICU").finish()
2427 }
2428}
2429#[doc = "Interrupt Controller"]
2430pub mod icu;
2431#[doc = "SRAM Control"]
2432pub struct SRAM {
2433 _marker: PhantomData<*const ()>,
2434}
2435unsafe impl Send for SRAM {}
2436impl SRAM {
2437 #[doc = r"Pointer to the register block"]
2438 pub const PTR: *const sram::RegisterBlock = 0x4000_2000 as *const _;
2439 #[doc = r"Return the pointer to the register block"]
2440 #[inline(always)]
2441 pub const fn ptr() -> *const sram::RegisterBlock {
2442 Self::PTR
2443 }
2444}
2445impl Deref for SRAM {
2446 type Target = sram::RegisterBlock;
2447 #[inline(always)]
2448 fn deref(&self) -> &Self::Target {
2449 unsafe { &*Self::PTR }
2450 }
2451}
2452impl core::fmt::Debug for SRAM {
2453 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2454 f.debug_struct("SRAM").finish()
2455 }
2456}
2457#[doc = "SRAM Control"]
2458pub mod sram;
2459#[doc = "PWM Delay Generation Circuit"]
2460pub struct GPT_ODC {
2461 _marker: PhantomData<*const ()>,
2462}
2463unsafe impl Send for GPT_ODC {}
2464impl GPT_ODC {
2465 #[doc = r"Pointer to the register block"]
2466 pub const PTR: *const gpt_odc::RegisterBlock = 0x4007_b000 as *const _;
2467 #[doc = r"Return the pointer to the register block"]
2468 #[inline(always)]
2469 pub const fn ptr() -> *const gpt_odc::RegisterBlock {
2470 Self::PTR
2471 }
2472}
2473impl Deref for GPT_ODC {
2474 type Target = gpt_odc::RegisterBlock;
2475 #[inline(always)]
2476 fn deref(&self) -> &Self::Target {
2477 unsafe { &*Self::PTR }
2478 }
2479}
2480impl core::fmt::Debug for GPT_ODC {
2481 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2482 f.debug_struct("GPT_ODC").finish()
2483 }
2484}
2485#[doc = "PWM Delay Generation Circuit"]
2486pub mod gpt_odc;
2487#[doc = "Asynchronous General purpose Timer 0"]
2488pub struct AGT0 {
2489 _marker: PhantomData<*const ()>,
2490}
2491unsafe impl Send for AGT0 {}
2492impl AGT0 {
2493 #[doc = r"Pointer to the register block"]
2494 pub const PTR: *const agt0::RegisterBlock = 0x4008_4000 as *const _;
2495 #[doc = r"Return the pointer to the register block"]
2496 #[inline(always)]
2497 pub const fn ptr() -> *const agt0::RegisterBlock {
2498 Self::PTR
2499 }
2500}
2501impl Deref for AGT0 {
2502 type Target = agt0::RegisterBlock;
2503 #[inline(always)]
2504 fn deref(&self) -> &Self::Target {
2505 unsafe { &*Self::PTR }
2506 }
2507}
2508impl core::fmt::Debug for AGT0 {
2509 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2510 f.debug_struct("AGT0").finish()
2511 }
2512}
2513#[doc = "Asynchronous General purpose Timer 0"]
2514pub mod agt0;
2515#[doc = "Asynchronous General purpose Timer 1"]
2516pub struct AGT1 {
2517 _marker: PhantomData<*const ()>,
2518}
2519unsafe impl Send for AGT1 {}
2520impl AGT1 {
2521 #[doc = r"Pointer to the register block"]
2522 pub const PTR: *const agt0::RegisterBlock = 0x4008_4100 as *const _;
2523 #[doc = r"Return the pointer to the register block"]
2524 #[inline(always)]
2525 pub const fn ptr() -> *const agt0::RegisterBlock {
2526 Self::PTR
2527 }
2528}
2529impl Deref for AGT1 {
2530 type Target = agt0::RegisterBlock;
2531 #[inline(always)]
2532 fn deref(&self) -> &Self::Target {
2533 unsafe { &*Self::PTR }
2534 }
2535}
2536impl core::fmt::Debug for AGT1 {
2537 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2538 f.debug_struct("AGT1").finish()
2539 }
2540}
2541#[doc = "Asynchronous General purpose Timer 1"]
2542pub use self::agt0 as agt1;
2543#[doc = "Flash Cache"]
2544pub struct FCACHE {
2545 _marker: PhantomData<*const ()>,
2546}
2547unsafe impl Send for FCACHE {}
2548impl FCACHE {
2549 #[doc = r"Pointer to the register block"]
2550 pub const PTR: *const fcache::RegisterBlock = 0x4001_c000 as *const _;
2551 #[doc = r"Return the pointer to the register block"]
2552 #[inline(always)]
2553 pub const fn ptr() -> *const fcache::RegisterBlock {
2554 Self::PTR
2555 }
2556}
2557impl Deref for FCACHE {
2558 type Target = fcache::RegisterBlock;
2559 #[inline(always)]
2560 fn deref(&self) -> &Self::Target {
2561 unsafe { &*Self::PTR }
2562 }
2563}
2564impl core::fmt::Debug for FCACHE {
2565 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2566 f.debug_struct("FCACHE").finish()
2567 }
2568}
2569#[doc = "Flash Cache"]
2570pub mod fcache;
2571#[doc = "BUS Control"]
2572pub struct BUS {
2573 _marker: PhantomData<*const ()>,
2574}
2575unsafe impl Send for BUS {}
2576impl BUS {
2577 #[doc = r"Pointer to the register block"]
2578 pub const PTR: *const bus::RegisterBlock = 0x4000_3000 as *const _;
2579 #[doc = r"Return the pointer to the register block"]
2580 #[inline(always)]
2581 pub const fn ptr() -> *const bus::RegisterBlock {
2582 Self::PTR
2583 }
2584}
2585impl Deref for BUS {
2586 type Target = bus::RegisterBlock;
2587 #[inline(always)]
2588 fn deref(&self) -> &Self::Target {
2589 unsafe { &*Self::PTR }
2590 }
2591}
2592impl core::fmt::Debug for BUS {
2593 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2594 f.debug_struct("BUS").finish()
2595 }
2596}
2597#[doc = "BUS Control"]
2598pub mod bus;
2599#[doc = "12-bit D/A converter"]
2600pub struct DAC12 {
2601 _marker: PhantomData<*const ()>,
2602}
2603unsafe impl Send for DAC12 {}
2604impl DAC12 {
2605 #[doc = r"Pointer to the register block"]
2606 pub const PTR: *const dac12::RegisterBlock = 0x4005_e000 as *const _;
2607 #[doc = r"Return the pointer to the register block"]
2608 #[inline(always)]
2609 pub const fn ptr() -> *const dac12::RegisterBlock {
2610 Self::PTR
2611 }
2612}
2613impl Deref for DAC12 {
2614 type Target = dac12::RegisterBlock;
2615 #[inline(always)]
2616 fn deref(&self) -> &Self::Target {
2617 unsafe { &*Self::PTR }
2618 }
2619}
2620impl core::fmt::Debug for DAC12 {
2621 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2622 f.debug_struct("DAC12").finish()
2623 }
2624}
2625#[doc = "12-bit D/A converter"]
2626pub mod dac12;
2627#[doc = "ADC-DAC Interface"]
2628pub struct AMI {
2629 _marker: PhantomData<*const ()>,
2630}
2631unsafe impl Send for AMI {}
2632impl AMI {
2633 #[doc = r"Pointer to the register block"]
2634 pub const PTR: *const ami::RegisterBlock = 0x4005_f000 as *const _;
2635 #[doc = r"Return the pointer to the register block"]
2636 #[inline(always)]
2637 pub const fn ptr() -> *const ami::RegisterBlock {
2638 Self::PTR
2639 }
2640}
2641impl Deref for AMI {
2642 type Target = ami::RegisterBlock;
2643 #[inline(always)]
2644 fn deref(&self) -> &Self::Target {
2645 unsafe { &*Self::PTR }
2646 }
2647}
2648impl core::fmt::Debug for AMI {
2649 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2650 f.debug_struct("AMI").finish()
2651 }
2652}
2653#[doc = "ADC-DAC Interface"]
2654pub mod ami;
2655#[doc = "JPEG Codec"]
2656pub struct JPEG {
2657 _marker: PhantomData<*const ()>,
2658}
2659unsafe impl Send for JPEG {}
2660impl JPEG {
2661 #[doc = r"Pointer to the register block"]
2662 pub const PTR: *const jpeg::RegisterBlock = 0x400e_6000 as *const _;
2663 #[doc = r"Return the pointer to the register block"]
2664 #[inline(always)]
2665 pub const fn ptr() -> *const jpeg::RegisterBlock {
2666 Self::PTR
2667 }
2668}
2669impl Deref for JPEG {
2670 type Target = jpeg::RegisterBlock;
2671 #[inline(always)]
2672 fn deref(&self) -> &Self::Target {
2673 unsafe { &*Self::PTR }
2674 }
2675}
2676impl core::fmt::Debug for JPEG {
2677 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2678 f.debug_struct("JPEG").finish()
2679 }
2680}
2681#[doc = "JPEG Codec"]
2682pub mod jpeg;
2683#[doc = "Port Output Enable Module for GPT"]
2684pub struct POEG {
2685 _marker: PhantomData<*const ()>,
2686}
2687unsafe impl Send for POEG {}
2688impl POEG {
2689 #[doc = r"Pointer to the register block"]
2690 pub const PTR: *const poeg::RegisterBlock = 0x4004_2000 as *const _;
2691 #[doc = r"Return the pointer to the register block"]
2692 #[inline(always)]
2693 pub const fn ptr() -> *const poeg::RegisterBlock {
2694 Self::PTR
2695 }
2696}
2697impl Deref for POEG {
2698 type Target = poeg::RegisterBlock;
2699 #[inline(always)]
2700 fn deref(&self) -> &Self::Target {
2701 unsafe { &*Self::PTR }
2702 }
2703}
2704impl core::fmt::Debug for POEG {
2705 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2706 f.debug_struct("POEG").finish()
2707 }
2708}
2709#[doc = "Port Output Enable Module for GPT"]
2710pub mod poeg;
2711#[doc = "Infrared Data Association"]
2712pub struct IRDA {
2713 _marker: PhantomData<*const ()>,
2714}
2715unsafe impl Send for IRDA {}
2716impl IRDA {
2717 #[doc = r"Pointer to the register block"]
2718 pub const PTR: *const irda::RegisterBlock = 0x4007_0f00 as *const _;
2719 #[doc = r"Return the pointer to the register block"]
2720 #[inline(always)]
2721 pub const fn ptr() -> *const irda::RegisterBlock {
2722 Self::PTR
2723 }
2724}
2725impl Deref for IRDA {
2726 type Target = irda::RegisterBlock;
2727 #[inline(always)]
2728 fn deref(&self) -> &Self::Target {
2729 unsafe { &*Self::PTR }
2730 }
2731}
2732impl core::fmt::Debug for IRDA {
2733 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2734 f.debug_struct("IRDA").finish()
2735 }
2736}
2737#[doc = "Infrared Data Association"]
2738pub mod irda;
2739#[doc = "CAN0 Module"]
2740pub struct CAN0 {
2741 _marker: PhantomData<*const ()>,
2742}
2743unsafe impl Send for CAN0 {}
2744impl CAN0 {
2745 #[doc = r"Pointer to the register block"]
2746 pub const PTR: *const can0::RegisterBlock = 0x4005_0000 as *const _;
2747 #[doc = r"Return the pointer to the register block"]
2748 #[inline(always)]
2749 pub const fn ptr() -> *const can0::RegisterBlock {
2750 Self::PTR
2751 }
2752}
2753impl Deref for CAN0 {
2754 type Target = can0::RegisterBlock;
2755 #[inline(always)]
2756 fn deref(&self) -> &Self::Target {
2757 unsafe { &*Self::PTR }
2758 }
2759}
2760impl core::fmt::Debug for CAN0 {
2761 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2762 f.debug_struct("CAN0").finish()
2763 }
2764}
2765#[doc = "CAN0 Module"]
2766pub mod can0;
2767#[doc = "CAN1 Module"]
2768pub struct CAN1 {
2769 _marker: PhantomData<*const ()>,
2770}
2771unsafe impl Send for CAN1 {}
2772impl CAN1 {
2773 #[doc = r"Pointer to the register block"]
2774 pub const PTR: *const can0::RegisterBlock = 0x4005_1000 as *const _;
2775 #[doc = r"Return the pointer to the register block"]
2776 #[inline(always)]
2777 pub const fn ptr() -> *const can0::RegisterBlock {
2778 Self::PTR
2779 }
2780}
2781impl Deref for CAN1 {
2782 type Target = can0::RegisterBlock;
2783 #[inline(always)]
2784 fn deref(&self) -> &Self::Target {
2785 unsafe { &*Self::PTR }
2786 }
2787}
2788impl core::fmt::Debug for CAN1 {
2789 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2790 f.debug_struct("CAN1").finish()
2791 }
2792}
2793#[doc = "CAN1 Module"]
2794pub use self::can0 as can1;
2795#[doc = "Parallel Data Capture Unit"]
2796pub struct PDC {
2797 _marker: PhantomData<*const ()>,
2798}
2799unsafe impl Send for PDC {}
2800impl PDC {
2801 #[doc = r"Pointer to the register block"]
2802 pub const PTR: *const pdc::RegisterBlock = 0x4009_4000 as *const _;
2803 #[doc = r"Return the pointer to the register block"]
2804 #[inline(always)]
2805 pub const fn ptr() -> *const pdc::RegisterBlock {
2806 Self::PTR
2807 }
2808}
2809impl Deref for PDC {
2810 type Target = pdc::RegisterBlock;
2811 #[inline(always)]
2812 fn deref(&self) -> &Self::Target {
2813 unsafe { &*Self::PTR }
2814 }
2815}
2816impl core::fmt::Debug for PDC {
2817 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2818 f.debug_struct("PDC").finish()
2819 }
2820}
2821#[doc = "Parallel Data Capture Unit"]
2822pub mod pdc;
2823#[doc = "Quad-SPI"]
2824pub struct QSPI {
2825 _marker: PhantomData<*const ()>,
2826}
2827unsafe impl Send for QSPI {}
2828impl QSPI {
2829 #[doc = r"Pointer to the register block"]
2830 pub const PTR: *const qspi::RegisterBlock = 0x6400_0000 as *const _;
2831 #[doc = r"Return the pointer to the register block"]
2832 #[inline(always)]
2833 pub const fn ptr() -> *const qspi::RegisterBlock {
2834 Self::PTR
2835 }
2836}
2837impl Deref for QSPI {
2838 type Target = qspi::RegisterBlock;
2839 #[inline(always)]
2840 fn deref(&self) -> &Self::Target {
2841 unsafe { &*Self::PTR }
2842 }
2843}
2844impl core::fmt::Debug for QSPI {
2845 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2846 f.debug_struct("QSPI").finish()
2847 }
2848}
2849#[doc = "Quad-SPI"]
2850pub mod qspi;
2851#[doc = "Memory Mirror Function"]
2852pub struct MMF {
2853 _marker: PhantomData<*const ()>,
2854}
2855unsafe impl Send for MMF {}
2856impl MMF {
2857 #[doc = r"Pointer to the register block"]
2858 pub const PTR: *const mmf::RegisterBlock = 0x4000_1000 as *const _;
2859 #[doc = r"Return the pointer to the register block"]
2860 #[inline(always)]
2861 pub const fn ptr() -> *const mmf::RegisterBlock {
2862 Self::PTR
2863 }
2864}
2865impl Deref for MMF {
2866 type Target = mmf::RegisterBlock;
2867 #[inline(always)]
2868 fn deref(&self) -> &Self::Target {
2869 unsafe { &*Self::PTR }
2870 }
2871}
2872impl core::fmt::Debug for MMF {
2873 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2874 f.debug_struct("MMF").finish()
2875 }
2876}
2877#[doc = "Memory Mirror Function"]
2878pub mod mmf;
2879#[doc = "Direct memory access controller 0"]
2880pub struct DMAC0 {
2881 _marker: PhantomData<*const ()>,
2882}
2883unsafe impl Send for DMAC0 {}
2884impl DMAC0 {
2885 #[doc = r"Pointer to the register block"]
2886 pub const PTR: *const dmac0::RegisterBlock = 0x4000_5000 as *const _;
2887 #[doc = r"Return the pointer to the register block"]
2888 #[inline(always)]
2889 pub const fn ptr() -> *const dmac0::RegisterBlock {
2890 Self::PTR
2891 }
2892}
2893impl Deref for DMAC0 {
2894 type Target = dmac0::RegisterBlock;
2895 #[inline(always)]
2896 fn deref(&self) -> &Self::Target {
2897 unsafe { &*Self::PTR }
2898 }
2899}
2900impl core::fmt::Debug for DMAC0 {
2901 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2902 f.debug_struct("DMAC0").finish()
2903 }
2904}
2905#[doc = "Direct memory access controller 0"]
2906pub mod dmac0;
2907#[doc = "Direct memory access controller 1"]
2908pub struct DMAC1 {
2909 _marker: PhantomData<*const ()>,
2910}
2911unsafe impl Send for DMAC1 {}
2912impl DMAC1 {
2913 #[doc = r"Pointer to the register block"]
2914 pub const PTR: *const dmac0::RegisterBlock = 0x4000_5040 as *const _;
2915 #[doc = r"Return the pointer to the register block"]
2916 #[inline(always)]
2917 pub const fn ptr() -> *const dmac0::RegisterBlock {
2918 Self::PTR
2919 }
2920}
2921impl Deref for DMAC1 {
2922 type Target = dmac0::RegisterBlock;
2923 #[inline(always)]
2924 fn deref(&self) -> &Self::Target {
2925 unsafe { &*Self::PTR }
2926 }
2927}
2928impl core::fmt::Debug for DMAC1 {
2929 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2930 f.debug_struct("DMAC1").finish()
2931 }
2932}
2933#[doc = "Direct memory access controller 1"]
2934pub use self::dmac0 as dmac1;
2935#[doc = "Direct memory access controller 2"]
2936pub struct DMAC2 {
2937 _marker: PhantomData<*const ()>,
2938}
2939unsafe impl Send for DMAC2 {}
2940impl DMAC2 {
2941 #[doc = r"Pointer to the register block"]
2942 pub const PTR: *const dmac0::RegisterBlock = 0x4000_5080 as *const _;
2943 #[doc = r"Return the pointer to the register block"]
2944 #[inline(always)]
2945 pub const fn ptr() -> *const dmac0::RegisterBlock {
2946 Self::PTR
2947 }
2948}
2949impl Deref for DMAC2 {
2950 type Target = dmac0::RegisterBlock;
2951 #[inline(always)]
2952 fn deref(&self) -> &Self::Target {
2953 unsafe { &*Self::PTR }
2954 }
2955}
2956impl core::fmt::Debug for DMAC2 {
2957 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2958 f.debug_struct("DMAC2").finish()
2959 }
2960}
2961#[doc = "Direct memory access controller 2"]
2962pub use self::dmac0 as dmac2;
2963#[doc = "Direct memory access controller 3"]
2964pub struct DMAC3 {
2965 _marker: PhantomData<*const ()>,
2966}
2967unsafe impl Send for DMAC3 {}
2968impl DMAC3 {
2969 #[doc = r"Pointer to the register block"]
2970 pub const PTR: *const dmac0::RegisterBlock = 0x4000_50c0 as *const _;
2971 #[doc = r"Return the pointer to the register block"]
2972 #[inline(always)]
2973 pub const fn ptr() -> *const dmac0::RegisterBlock {
2974 Self::PTR
2975 }
2976}
2977impl Deref for DMAC3 {
2978 type Target = dmac0::RegisterBlock;
2979 #[inline(always)]
2980 fn deref(&self) -> &Self::Target {
2981 unsafe { &*Self::PTR }
2982 }
2983}
2984impl core::fmt::Debug for DMAC3 {
2985 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2986 f.debug_struct("DMAC3").finish()
2987 }
2988}
2989#[doc = "Direct memory access controller 3"]
2990pub use self::dmac0 as dmac3;
2991#[doc = "Direct memory access controller 4"]
2992pub struct DMAC4 {
2993 _marker: PhantomData<*const ()>,
2994}
2995unsafe impl Send for DMAC4 {}
2996impl DMAC4 {
2997 #[doc = r"Pointer to the register block"]
2998 pub const PTR: *const dmac0::RegisterBlock = 0x4000_5100 as *const _;
2999 #[doc = r"Return the pointer to the register block"]
3000 #[inline(always)]
3001 pub const fn ptr() -> *const dmac0::RegisterBlock {
3002 Self::PTR
3003 }
3004}
3005impl Deref for DMAC4 {
3006 type Target = dmac0::RegisterBlock;
3007 #[inline(always)]
3008 fn deref(&self) -> &Self::Target {
3009 unsafe { &*Self::PTR }
3010 }
3011}
3012impl core::fmt::Debug for DMAC4 {
3013 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3014 f.debug_struct("DMAC4").finish()
3015 }
3016}
3017#[doc = "Direct memory access controller 4"]
3018pub use self::dmac0 as dmac4;
3019#[doc = "Direct memory access controller 5"]
3020pub struct DMAC5 {
3021 _marker: PhantomData<*const ()>,
3022}
3023unsafe impl Send for DMAC5 {}
3024impl DMAC5 {
3025 #[doc = r"Pointer to the register block"]
3026 pub const PTR: *const dmac0::RegisterBlock = 0x4000_5140 as *const _;
3027 #[doc = r"Return the pointer to the register block"]
3028 #[inline(always)]
3029 pub const fn ptr() -> *const dmac0::RegisterBlock {
3030 Self::PTR
3031 }
3032}
3033impl Deref for DMAC5 {
3034 type Target = dmac0::RegisterBlock;
3035 #[inline(always)]
3036 fn deref(&self) -> &Self::Target {
3037 unsafe { &*Self::PTR }
3038 }
3039}
3040impl core::fmt::Debug for DMAC5 {
3041 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3042 f.debug_struct("DMAC5").finish()
3043 }
3044}
3045#[doc = "Direct memory access controller 5"]
3046pub use self::dmac0 as dmac5;
3047#[doc = "Direct memory access controller 6"]
3048pub struct DMAC6 {
3049 _marker: PhantomData<*const ()>,
3050}
3051unsafe impl Send for DMAC6 {}
3052impl DMAC6 {
3053 #[doc = r"Pointer to the register block"]
3054 pub const PTR: *const dmac0::RegisterBlock = 0x4000_5180 as *const _;
3055 #[doc = r"Return the pointer to the register block"]
3056 #[inline(always)]
3057 pub const fn ptr() -> *const dmac0::RegisterBlock {
3058 Self::PTR
3059 }
3060}
3061impl Deref for DMAC6 {
3062 type Target = dmac0::RegisterBlock;
3063 #[inline(always)]
3064 fn deref(&self) -> &Self::Target {
3065 unsafe { &*Self::PTR }
3066 }
3067}
3068impl core::fmt::Debug for DMAC6 {
3069 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3070 f.debug_struct("DMAC6").finish()
3071 }
3072}
3073#[doc = "Direct memory access controller 6"]
3074pub use self::dmac0 as dmac6;
3075#[doc = "Direct memory access controller 7"]
3076pub struct DMAC7 {
3077 _marker: PhantomData<*const ()>,
3078}
3079unsafe impl Send for DMAC7 {}
3080impl DMAC7 {
3081 #[doc = r"Pointer to the register block"]
3082 pub const PTR: *const dmac0::RegisterBlock = 0x4000_51c0 as *const _;
3083 #[doc = r"Return the pointer to the register block"]
3084 #[inline(always)]
3085 pub const fn ptr() -> *const dmac0::RegisterBlock {
3086 Self::PTR
3087 }
3088}
3089impl Deref for DMAC7 {
3090 type Target = dmac0::RegisterBlock;
3091 #[inline(always)]
3092 fn deref(&self) -> &Self::Target {
3093 unsafe { &*Self::PTR }
3094 }
3095}
3096impl core::fmt::Debug for DMAC7 {
3097 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3098 f.debug_struct("DMAC7").finish()
3099 }
3100}
3101#[doc = "Direct memory access controller 7"]
3102pub use self::dmac0 as dmac7;
3103#[doc = "DMAC Module Activation"]
3104pub struct DMA {
3105 _marker: PhantomData<*const ()>,
3106}
3107unsafe impl Send for DMA {}
3108impl DMA {
3109 #[doc = r"Pointer to the register block"]
3110 pub const PTR: *const dma::RegisterBlock = 0x4000_5200 as *const _;
3111 #[doc = r"Return the pointer to the register block"]
3112 #[inline(always)]
3113 pub const fn ptr() -> *const dma::RegisterBlock {
3114 Self::PTR
3115 }
3116}
3117impl Deref for DMA {
3118 type Target = dma::RegisterBlock;
3119 #[inline(always)]
3120 fn deref(&self) -> &Self::Target {
3121 unsafe { &*Self::PTR }
3122 }
3123}
3124impl core::fmt::Debug for DMA {
3125 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3126 f.debug_struct("DMA").finish()
3127 }
3128}
3129#[doc = "DMAC Module Activation"]
3130pub mod dma;
3131#[doc = "Data Transfer Controller"]
3132pub struct DTC {
3133 _marker: PhantomData<*const ()>,
3134}
3135unsafe impl Send for DTC {}
3136impl DTC {
3137 #[doc = r"Pointer to the register block"]
3138 pub const PTR: *const dtc::RegisterBlock = 0x4000_5400 as *const _;
3139 #[doc = r"Return the pointer to the register block"]
3140 #[inline(always)]
3141 pub const fn ptr() -> *const dtc::RegisterBlock {
3142 Self::PTR
3143 }
3144}
3145impl Deref for DTC {
3146 type Target = dtc::RegisterBlock;
3147 #[inline(always)]
3148 fn deref(&self) -> &Self::Target {
3149 unsafe { &*Self::PTR }
3150 }
3151}
3152impl core::fmt::Debug for DTC {
3153 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3154 f.debug_struct("DTC").finish()
3155 }
3156}
3157#[doc = "Data Transfer Controller"]
3158pub mod dtc;
3159#[doc = "Debug Function"]
3160pub struct DBG {
3161 _marker: PhantomData<*const ()>,
3162}
3163unsafe impl Send for DBG {}
3164impl DBG {
3165 #[doc = r"Pointer to the register block"]
3166 pub const PTR: *const dbg::RegisterBlock = 0x4001_b000 as *const _;
3167 #[doc = r"Return the pointer to the register block"]
3168 #[inline(always)]
3169 pub const fn ptr() -> *const dbg::RegisterBlock {
3170 Self::PTR
3171 }
3172}
3173impl Deref for DBG {
3174 type Target = dbg::RegisterBlock;
3175 #[inline(always)]
3176 fn deref(&self) -> &Self::Target {
3177 unsafe { &*Self::PTR }
3178 }
3179}
3180impl core::fmt::Debug for DBG {
3181 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3182 f.debug_struct("DBG").finish()
3183 }
3184}
3185#[doc = "Debug Function"]
3186pub mod dbg;
3187#[doc = "Temperature Sensor"]
3188pub struct TSN {
3189 _marker: PhantomData<*const ()>,
3190}
3191unsafe impl Send for TSN {}
3192impl TSN {
3193 #[doc = r"Pointer to the register block"]
3194 pub const PTR: *const tsn::RegisterBlock = 0x4005_d000 as *const _;
3195 #[doc = r"Return the pointer to the register block"]
3196 #[inline(always)]
3197 pub const fn ptr() -> *const tsn::RegisterBlock {
3198 Self::PTR
3199 }
3200}
3201impl Deref for TSN {
3202 type Target = tsn::RegisterBlock;
3203 #[inline(always)]
3204 fn deref(&self) -> &Self::Target {
3205 unsafe { &*Self::PTR }
3206 }
3207}
3208impl core::fmt::Debug for TSN {
3209 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3210 f.debug_struct("TSN").finish()
3211 }
3212}
3213#[doc = "Temperature Sensor"]
3214pub mod tsn;
3215#[doc = "High-Speed Analog Comparator 0"]
3216pub struct ACMPHS0 {
3217 _marker: PhantomData<*const ()>,
3218}
3219unsafe impl Send for ACMPHS0 {}
3220impl ACMPHS0 {
3221 #[doc = r"Pointer to the register block"]
3222 pub const PTR: *const acmphs0::RegisterBlock = 0x4008_5000 as *const _;
3223 #[doc = r"Return the pointer to the register block"]
3224 #[inline(always)]
3225 pub const fn ptr() -> *const acmphs0::RegisterBlock {
3226 Self::PTR
3227 }
3228}
3229impl Deref for ACMPHS0 {
3230 type Target = acmphs0::RegisterBlock;
3231 #[inline(always)]
3232 fn deref(&self) -> &Self::Target {
3233 unsafe { &*Self::PTR }
3234 }
3235}
3236impl core::fmt::Debug for ACMPHS0 {
3237 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3238 f.debug_struct("ACMPHS0").finish()
3239 }
3240}
3241#[doc = "High-Speed Analog Comparator 0"]
3242pub mod acmphs0;
3243#[doc = "High-Speed Analog Comparator 1"]
3244pub struct ACMPHS1 {
3245 _marker: PhantomData<*const ()>,
3246}
3247unsafe impl Send for ACMPHS1 {}
3248impl ACMPHS1 {
3249 #[doc = r"Pointer to the register block"]
3250 pub const PTR: *const acmphs1::RegisterBlock = 0x4008_5100 as *const _;
3251 #[doc = r"Return the pointer to the register block"]
3252 #[inline(always)]
3253 pub const fn ptr() -> *const acmphs1::RegisterBlock {
3254 Self::PTR
3255 }
3256}
3257impl Deref for ACMPHS1 {
3258 type Target = acmphs1::RegisterBlock;
3259 #[inline(always)]
3260 fn deref(&self) -> &Self::Target {
3261 unsafe { &*Self::PTR }
3262 }
3263}
3264impl core::fmt::Debug for ACMPHS1 {
3265 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3266 f.debug_struct("ACMPHS1").finish()
3267 }
3268}
3269#[doc = "High-Speed Analog Comparator 1"]
3270pub mod acmphs1;
3271#[doc = "High-Speed Analog Comparator 2"]
3272pub struct ACMPHS2 {
3273 _marker: PhantomData<*const ()>,
3274}
3275unsafe impl Send for ACMPHS2 {}
3276impl ACMPHS2 {
3277 #[doc = r"Pointer to the register block"]
3278 pub const PTR: *const acmphs1::RegisterBlock = 0x4008_5200 as *const _;
3279 #[doc = r"Return the pointer to the register block"]
3280 #[inline(always)]
3281 pub const fn ptr() -> *const acmphs1::RegisterBlock {
3282 Self::PTR
3283 }
3284}
3285impl Deref for ACMPHS2 {
3286 type Target = acmphs1::RegisterBlock;
3287 #[inline(always)]
3288 fn deref(&self) -> &Self::Target {
3289 unsafe { &*Self::PTR }
3290 }
3291}
3292impl core::fmt::Debug for ACMPHS2 {
3293 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3294 f.debug_struct("ACMPHS2").finish()
3295 }
3296}
3297#[doc = "High-Speed Analog Comparator 2"]
3298pub use self::acmphs1 as acmphs2;
3299#[doc = "High-Speed Analog Comparator 3"]
3300pub struct ACMPHS3 {
3301 _marker: PhantomData<*const ()>,
3302}
3303unsafe impl Send for ACMPHS3 {}
3304impl ACMPHS3 {
3305 #[doc = r"Pointer to the register block"]
3306 pub const PTR: *const acmphs1::RegisterBlock = 0x4008_5300 as *const _;
3307 #[doc = r"Return the pointer to the register block"]
3308 #[inline(always)]
3309 pub const fn ptr() -> *const acmphs1::RegisterBlock {
3310 Self::PTR
3311 }
3312}
3313impl Deref for ACMPHS3 {
3314 type Target = acmphs1::RegisterBlock;
3315 #[inline(always)]
3316 fn deref(&self) -> &Self::Target {
3317 unsafe { &*Self::PTR }
3318 }
3319}
3320impl core::fmt::Debug for ACMPHS3 {
3321 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3322 f.debug_struct("ACMPHS3").finish()
3323 }
3324}
3325#[doc = "High-Speed Analog Comparator 3"]
3326pub use self::acmphs1 as acmphs3;
3327#[doc = "High-Speed Analog Comparator 4"]
3328pub struct ACMPHS4 {
3329 _marker: PhantomData<*const ()>,
3330}
3331unsafe impl Send for ACMPHS4 {}
3332impl ACMPHS4 {
3333 #[doc = r"Pointer to the register block"]
3334 pub const PTR: *const acmphs1::RegisterBlock = 0x4008_5400 as *const _;
3335 #[doc = r"Return the pointer to the register block"]
3336 #[inline(always)]
3337 pub const fn ptr() -> *const acmphs1::RegisterBlock {
3338 Self::PTR
3339 }
3340}
3341impl Deref for ACMPHS4 {
3342 type Target = acmphs1::RegisterBlock;
3343 #[inline(always)]
3344 fn deref(&self) -> &Self::Target {
3345 unsafe { &*Self::PTR }
3346 }
3347}
3348impl core::fmt::Debug for ACMPHS4 {
3349 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3350 f.debug_struct("ACMPHS4").finish()
3351 }
3352}
3353#[doc = "High-Speed Analog Comparator 4"]
3354pub use self::acmphs1 as acmphs4;
3355#[doc = "High-Speed Analog Comparator 5"]
3356pub struct ACMPHS5 {
3357 _marker: PhantomData<*const ()>,
3358}
3359unsafe impl Send for ACMPHS5 {}
3360impl ACMPHS5 {
3361 #[doc = r"Pointer to the register block"]
3362 pub const PTR: *const acmphs1::RegisterBlock = 0x4008_5500 as *const _;
3363 #[doc = r"Return the pointer to the register block"]
3364 #[inline(always)]
3365 pub const fn ptr() -> *const acmphs1::RegisterBlock {
3366 Self::PTR
3367 }
3368}
3369impl Deref for ACMPHS5 {
3370 type Target = acmphs1::RegisterBlock;
3371 #[inline(always)]
3372 fn deref(&self) -> &Self::Target {
3373 unsafe { &*Self::PTR }
3374 }
3375}
3376impl core::fmt::Debug for ACMPHS5 {
3377 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3378 f.debug_struct("ACMPHS5").finish()
3379 }
3380}
3381#[doc = "High-Speed Analog Comparator 5"]
3382pub use self::acmphs1 as acmphs5;
3383#[doc = "Event Link Controller"]
3384pub struct ELC {
3385 _marker: PhantomData<*const ()>,
3386}
3387unsafe impl Send for ELC {}
3388impl ELC {
3389 #[doc = r"Pointer to the register block"]
3390 pub const PTR: *const elc::RegisterBlock = 0x4004_1000 as *const _;
3391 #[doc = r"Return the pointer to the register block"]
3392 #[inline(always)]
3393 pub const fn ptr() -> *const elc::RegisterBlock {
3394 Self::PTR
3395 }
3396}
3397impl Deref for ELC {
3398 type Target = elc::RegisterBlock;
3399 #[inline(always)]
3400 fn deref(&self) -> &Self::Target {
3401 unsafe { &*Self::PTR }
3402 }
3403}
3404impl core::fmt::Debug for ELC {
3405 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3406 f.debug_struct("ELC").finish()
3407 }
3408}
3409#[doc = "Event Link Controller"]
3410pub mod elc;
3411#[doc = "Watchdog Timer"]
3412pub struct WDT {
3413 _marker: PhantomData<*const ()>,
3414}
3415unsafe impl Send for WDT {}
3416impl WDT {
3417 #[doc = r"Pointer to the register block"]
3418 pub const PTR: *const wdt::RegisterBlock = 0x4004_4200 as *const _;
3419 #[doc = r"Return the pointer to the register block"]
3420 #[inline(always)]
3421 pub const fn ptr() -> *const wdt::RegisterBlock {
3422 Self::PTR
3423 }
3424}
3425impl Deref for WDT {
3426 type Target = wdt::RegisterBlock;
3427 #[inline(always)]
3428 fn deref(&self) -> &Self::Target {
3429 unsafe { &*Self::PTR }
3430 }
3431}
3432impl core::fmt::Debug for WDT {
3433 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3434 f.debug_struct("WDT").finish()
3435 }
3436}
3437#[doc = "Watchdog Timer"]
3438pub mod wdt;
3439#[doc = "Independent Watchdog Timer"]
3440pub struct IWDT {
3441 _marker: PhantomData<*const ()>,
3442}
3443unsafe impl Send for IWDT {}
3444impl IWDT {
3445 #[doc = r"Pointer to the register block"]
3446 pub const PTR: *const iwdt::RegisterBlock = 0x4004_4400 as *const _;
3447 #[doc = r"Return the pointer to the register block"]
3448 #[inline(always)]
3449 pub const fn ptr() -> *const iwdt::RegisterBlock {
3450 Self::PTR
3451 }
3452}
3453impl Deref for IWDT {
3454 type Target = iwdt::RegisterBlock;
3455 #[inline(always)]
3456 fn deref(&self) -> &Self::Target {
3457 unsafe { &*Self::PTR }
3458 }
3459}
3460impl core::fmt::Debug for IWDT {
3461 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3462 f.debug_struct("IWDT").finish()
3463 }
3464}
3465#[doc = "Independent Watchdog Timer"]
3466pub mod iwdt;
3467#[doc = "Key Interrupt Function"]
3468pub struct KINT {
3469 _marker: PhantomData<*const ()>,
3470}
3471unsafe impl Send for KINT {}
3472impl KINT {
3473 #[doc = r"Pointer to the register block"]
3474 pub const PTR: *const kint::RegisterBlock = 0x4008_0000 as *const _;
3475 #[doc = r"Return the pointer to the register block"]
3476 #[inline(always)]
3477 pub const fn ptr() -> *const kint::RegisterBlock {
3478 Self::PTR
3479 }
3480}
3481impl Deref for KINT {
3482 type Target = kint::RegisterBlock;
3483 #[inline(always)]
3484 fn deref(&self) -> &Self::Target {
3485 unsafe { &*Self::PTR }
3486 }
3487}
3488impl core::fmt::Debug for KINT {
3489 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3490 f.debug_struct("KINT").finish()
3491 }
3492}
3493#[doc = "Key Interrupt Function"]
3494pub mod kint;
3495#[doc = "Data Operation Circuit"]
3496pub struct DOC {
3497 _marker: PhantomData<*const ()>,
3498}
3499unsafe impl Send for DOC {}
3500impl DOC {
3501 #[doc = r"Pointer to the register block"]
3502 pub const PTR: *const doc::RegisterBlock = 0x4005_4100 as *const _;
3503 #[doc = r"Return the pointer to the register block"]
3504 #[inline(always)]
3505 pub const fn ptr() -> *const doc::RegisterBlock {
3506 Self::PTR
3507 }
3508}
3509impl Deref for DOC {
3510 type Target = doc::RegisterBlock;
3511 #[inline(always)]
3512 fn deref(&self) -> &Self::Target {
3513 unsafe { &*Self::PTR }
3514 }
3515}
3516impl core::fmt::Debug for DOC {
3517 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3518 f.debug_struct("DOC").finish()
3519 }
3520}
3521#[doc = "Data Operation Circuit"]
3522pub mod doc;
3523#[doc = "Clock Frequency Accuracy Measurement Circuit"]
3524pub struct CAC {
3525 _marker: PhantomData<*const ()>,
3526}
3527unsafe impl Send for CAC {}
3528impl CAC {
3529 #[doc = r"Pointer to the register block"]
3530 pub const PTR: *const cac::RegisterBlock = 0x4004_4600 as *const _;
3531 #[doc = r"Return the pointer to the register block"]
3532 #[inline(always)]
3533 pub const fn ptr() -> *const cac::RegisterBlock {
3534 Self::PTR
3535 }
3536}
3537impl Deref for CAC {
3538 type Target = cac::RegisterBlock;
3539 #[inline(always)]
3540 fn deref(&self) -> &Self::Target {
3541 unsafe { &*Self::PTR }
3542 }
3543}
3544impl core::fmt::Debug for CAC {
3545 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3546 f.debug_struct("CAC").finish()
3547 }
3548}
3549#[doc = "Clock Frequency Accuracy Measurement Circuit"]
3550pub mod cac;
3551#[no_mangle]
3552static mut DEVICE_PERIPHERALS: bool = false;
3553#[doc = r" All the peripherals."]
3554#[allow(non_snake_case)]
3555pub struct Peripherals {
3556 #[doc = "PORT0"]
3557 pub PORT0: PORT0,
3558 #[doc = "PORT1"]
3559 pub PORT1: PORT1,
3560 #[doc = "PORT2"]
3561 pub PORT2: PORT2,
3562 #[doc = "PORT3"]
3563 pub PORT3: PORT3,
3564 #[doc = "PORT4"]
3565 pub PORT4: PORT4,
3566 #[doc = "PORT5"]
3567 pub PORT5: PORT5,
3568 #[doc = "PORT6"]
3569 pub PORT6: PORT6,
3570 #[doc = "PORT7"]
3571 pub PORT7: PORT7,
3572 #[doc = "PORT8"]
3573 pub PORT8: PORT8,
3574 #[doc = "PORT9"]
3575 pub PORT9: PORT9,
3576 #[doc = "PORTA"]
3577 pub PORTA: PORTA,
3578 #[doc = "PORTB"]
3579 pub PORTB: PORTB,
3580 #[doc = "PFS"]
3581 pub PFS: PFS,
3582 #[doc = "PMISC"]
3583 pub PMISC: PMISC,
3584 #[doc = "SPI0"]
3585 pub SPI0: SPI0,
3586 #[doc = "SPI1"]
3587 pub SPI1: SPI1,
3588 #[doc = "GPT_OPS"]
3589 pub GPT_OPS: GPT_OPS,
3590 #[doc = "GPT32EH0"]
3591 pub GPT32EH0: GPT32EH0,
3592 #[doc = "GPT32EH1"]
3593 pub GPT32EH1: GPT32EH1,
3594 #[doc = "GPT32EH2"]
3595 pub GPT32EH2: GPT32EH2,
3596 #[doc = "GPT32EH3"]
3597 pub GPT32EH3: GPT32EH3,
3598 #[doc = "GPT32E4"]
3599 pub GPT32E4: GPT32E4,
3600 #[doc = "GPT32E5"]
3601 pub GPT32E5: GPT32E5,
3602 #[doc = "GPT32E6"]
3603 pub GPT32E6: GPT32E6,
3604 #[doc = "GPT32E7"]
3605 pub GPT32E7: GPT32E7,
3606 #[doc = "GLCDC"]
3607 pub GLCDC: GLCDC,
3608 #[doc = "DRW"]
3609 pub DRW: DRW,
3610 #[doc = "USBHS"]
3611 pub USBHS: USBHS,
3612 #[doc = "SCI0"]
3613 pub SCI0: SCI0,
3614 #[doc = "SCI1"]
3615 pub SCI1: SCI1,
3616 #[doc = "SCI2"]
3617 pub SCI2: SCI2,
3618 #[doc = "SCI3"]
3619 pub SCI3: SCI3,
3620 #[doc = "SCI4"]
3621 pub SCI4: SCI4,
3622 #[doc = "SCI5"]
3623 pub SCI5: SCI5,
3624 #[doc = "SCI6"]
3625 pub SCI6: SCI6,
3626 #[doc = "SCI7"]
3627 pub SCI7: SCI7,
3628 #[doc = "SCI8"]
3629 pub SCI8: SCI8,
3630 #[doc = "SCI9"]
3631 pub SCI9: SCI9,
3632 #[doc = "IIC0"]
3633 pub IIC0: IIC0,
3634 #[doc = "IIC1"]
3635 pub IIC1: IIC1,
3636 #[doc = "IIC2"]
3637 pub IIC2: IIC2,
3638 #[doc = "SYSTEM"]
3639 pub SYSTEM: SYSTEM,
3640 #[doc = "EDMAC0"]
3641 pub EDMAC0: EDMAC0,
3642 #[doc = "ETHERC0"]
3643 pub ETHERC0: ETHERC0,
3644 #[doc = "PTPEDMAC"]
3645 pub PTPEDMAC: PTPEDMAC,
3646 #[doc = "EPTPC"]
3647 pub EPTPC: EPTPC,
3648 #[doc = "EPTPC0"]
3649 pub EPTPC0: EPTPC0,
3650 #[doc = "EPTPC_CFG"]
3651 pub EPTPC_CFG: EPTPC_CFG,
3652 #[doc = "SDHI0"]
3653 pub SDHI0: SDHI0,
3654 #[doc = "SDHI1"]
3655 pub SDHI1: SDHI1,
3656 #[doc = "CRC"]
3657 pub CRC: CRC,
3658 #[doc = "CTSU"]
3659 pub CTSU: CTSU,
3660 #[doc = "MMPU"]
3661 pub MMPU: MMPU,
3662 #[doc = "SMPU"]
3663 pub SMPU: SMPU,
3664 #[doc = "SPMON"]
3665 pub SPMON: SPMON,
3666 #[doc = "ADC120"]
3667 pub ADC120: ADC120,
3668 #[doc = "ADC121"]
3669 pub ADC121: ADC121,
3670 #[doc = "MSTP"]
3671 pub MSTP: MSTP,
3672 #[doc = "GPT328"]
3673 pub GPT328: GPT328,
3674 #[doc = "GPT329"]
3675 pub GPT329: GPT329,
3676 #[doc = "GPT3210"]
3677 pub GPT3210: GPT3210,
3678 #[doc = "GPT3211"]
3679 pub GPT3211: GPT3211,
3680 #[doc = "GPT3212"]
3681 pub GPT3212: GPT3212,
3682 #[doc = "GPT3213"]
3683 pub GPT3213: GPT3213,
3684 #[doc = "RTC"]
3685 pub RTC: RTC,
3686 #[doc = "SSIE0"]
3687 pub SSIE0: SSIE0,
3688 #[doc = "SSIE1"]
3689 pub SSIE1: SSIE1,
3690 #[doc = "USBFS"]
3691 pub USBFS: USBFS,
3692 #[doc = "SRCRAM"]
3693 pub SRCRAM: SRCRAM,
3694 #[doc = "SRC"]
3695 pub SRC: SRC,
3696 #[doc = "ICU"]
3697 pub ICU: ICU,
3698 #[doc = "SRAM"]
3699 pub SRAM: SRAM,
3700 #[doc = "GPT_ODC"]
3701 pub GPT_ODC: GPT_ODC,
3702 #[doc = "AGT0"]
3703 pub AGT0: AGT0,
3704 #[doc = "AGT1"]
3705 pub AGT1: AGT1,
3706 #[doc = "FCACHE"]
3707 pub FCACHE: FCACHE,
3708 #[doc = "BUS"]
3709 pub BUS: BUS,
3710 #[doc = "DAC12"]
3711 pub DAC12: DAC12,
3712 #[doc = "AMI"]
3713 pub AMI: AMI,
3714 #[doc = "JPEG"]
3715 pub JPEG: JPEG,
3716 #[doc = "POEG"]
3717 pub POEG: POEG,
3718 #[doc = "IRDA"]
3719 pub IRDA: IRDA,
3720 #[doc = "CAN0"]
3721 pub CAN0: CAN0,
3722 #[doc = "CAN1"]
3723 pub CAN1: CAN1,
3724 #[doc = "PDC"]
3725 pub PDC: PDC,
3726 #[doc = "QSPI"]
3727 pub QSPI: QSPI,
3728 #[doc = "MMF"]
3729 pub MMF: MMF,
3730 #[doc = "DMAC0"]
3731 pub DMAC0: DMAC0,
3732 #[doc = "DMAC1"]
3733 pub DMAC1: DMAC1,
3734 #[doc = "DMAC2"]
3735 pub DMAC2: DMAC2,
3736 #[doc = "DMAC3"]
3737 pub DMAC3: DMAC3,
3738 #[doc = "DMAC4"]
3739 pub DMAC4: DMAC4,
3740 #[doc = "DMAC5"]
3741 pub DMAC5: DMAC5,
3742 #[doc = "DMAC6"]
3743 pub DMAC6: DMAC6,
3744 #[doc = "DMAC7"]
3745 pub DMAC7: DMAC7,
3746 #[doc = "DMA"]
3747 pub DMA: DMA,
3748 #[doc = "DTC"]
3749 pub DTC: DTC,
3750 #[doc = "DBG"]
3751 pub DBG: DBG,
3752 #[doc = "TSN"]
3753 pub TSN: TSN,
3754 #[doc = "ACMPHS0"]
3755 pub ACMPHS0: ACMPHS0,
3756 #[doc = "ACMPHS1"]
3757 pub ACMPHS1: ACMPHS1,
3758 #[doc = "ACMPHS2"]
3759 pub ACMPHS2: ACMPHS2,
3760 #[doc = "ACMPHS3"]
3761 pub ACMPHS3: ACMPHS3,
3762 #[doc = "ACMPHS4"]
3763 pub ACMPHS4: ACMPHS4,
3764 #[doc = "ACMPHS5"]
3765 pub ACMPHS5: ACMPHS5,
3766 #[doc = "ELC"]
3767 pub ELC: ELC,
3768 #[doc = "WDT"]
3769 pub WDT: WDT,
3770 #[doc = "IWDT"]
3771 pub IWDT: IWDT,
3772 #[doc = "KINT"]
3773 pub KINT: KINT,
3774 #[doc = "DOC"]
3775 pub DOC: DOC,
3776 #[doc = "CAC"]
3777 pub CAC: CAC,
3778}
3779impl Peripherals {
3780 #[doc = r" Returns all the peripherals *once*."]
3781 #[cfg(feature = "critical-section")]
3782 #[inline]
3783 pub fn take() -> Option<Self> {
3784 critical_section::with(|_| {
3785 if unsafe { DEVICE_PERIPHERALS } {
3786 return None;
3787 }
3788 Some(unsafe { Peripherals::steal() })
3789 })
3790 }
3791 #[doc = r" Unchecked version of `Peripherals::take`."]
3792 #[doc = r""]
3793 #[doc = r" # Safety"]
3794 #[doc = r""]
3795 #[doc = r" Each of the returned peripherals must be used at most once."]
3796 #[inline]
3797 pub unsafe fn steal() -> Self {
3798 DEVICE_PERIPHERALS = true;
3799 Peripherals {
3800 PORT0: PORT0 {
3801 _marker: PhantomData,
3802 },
3803 PORT1: PORT1 {
3804 _marker: PhantomData,
3805 },
3806 PORT2: PORT2 {
3807 _marker: PhantomData,
3808 },
3809 PORT3: PORT3 {
3810 _marker: PhantomData,
3811 },
3812 PORT4: PORT4 {
3813 _marker: PhantomData,
3814 },
3815 PORT5: PORT5 {
3816 _marker: PhantomData,
3817 },
3818 PORT6: PORT6 {
3819 _marker: PhantomData,
3820 },
3821 PORT7: PORT7 {
3822 _marker: PhantomData,
3823 },
3824 PORT8: PORT8 {
3825 _marker: PhantomData,
3826 },
3827 PORT9: PORT9 {
3828 _marker: PhantomData,
3829 },
3830 PORTA: PORTA {
3831 _marker: PhantomData,
3832 },
3833 PORTB: PORTB {
3834 _marker: PhantomData,
3835 },
3836 PFS: PFS {
3837 _marker: PhantomData,
3838 },
3839 PMISC: PMISC {
3840 _marker: PhantomData,
3841 },
3842 SPI0: SPI0 {
3843 _marker: PhantomData,
3844 },
3845 SPI1: SPI1 {
3846 _marker: PhantomData,
3847 },
3848 GPT_OPS: GPT_OPS {
3849 _marker: PhantomData,
3850 },
3851 GPT32EH0: GPT32EH0 {
3852 _marker: PhantomData,
3853 },
3854 GPT32EH1: GPT32EH1 {
3855 _marker: PhantomData,
3856 },
3857 GPT32EH2: GPT32EH2 {
3858 _marker: PhantomData,
3859 },
3860 GPT32EH3: GPT32EH3 {
3861 _marker: PhantomData,
3862 },
3863 GPT32E4: GPT32E4 {
3864 _marker: PhantomData,
3865 },
3866 GPT32E5: GPT32E5 {
3867 _marker: PhantomData,
3868 },
3869 GPT32E6: GPT32E6 {
3870 _marker: PhantomData,
3871 },
3872 GPT32E7: GPT32E7 {
3873 _marker: PhantomData,
3874 },
3875 GLCDC: GLCDC {
3876 _marker: PhantomData,
3877 },
3878 DRW: DRW {
3879 _marker: PhantomData,
3880 },
3881 USBHS: USBHS {
3882 _marker: PhantomData,
3883 },
3884 SCI0: SCI0 {
3885 _marker: PhantomData,
3886 },
3887 SCI1: SCI1 {
3888 _marker: PhantomData,
3889 },
3890 SCI2: SCI2 {
3891 _marker: PhantomData,
3892 },
3893 SCI3: SCI3 {
3894 _marker: PhantomData,
3895 },
3896 SCI4: SCI4 {
3897 _marker: PhantomData,
3898 },
3899 SCI5: SCI5 {
3900 _marker: PhantomData,
3901 },
3902 SCI6: SCI6 {
3903 _marker: PhantomData,
3904 },
3905 SCI7: SCI7 {
3906 _marker: PhantomData,
3907 },
3908 SCI8: SCI8 {
3909 _marker: PhantomData,
3910 },
3911 SCI9: SCI9 {
3912 _marker: PhantomData,
3913 },
3914 IIC0: IIC0 {
3915 _marker: PhantomData,
3916 },
3917 IIC1: IIC1 {
3918 _marker: PhantomData,
3919 },
3920 IIC2: IIC2 {
3921 _marker: PhantomData,
3922 },
3923 SYSTEM: SYSTEM {
3924 _marker: PhantomData,
3925 },
3926 EDMAC0: EDMAC0 {
3927 _marker: PhantomData,
3928 },
3929 ETHERC0: ETHERC0 {
3930 _marker: PhantomData,
3931 },
3932 PTPEDMAC: PTPEDMAC {
3933 _marker: PhantomData,
3934 },
3935 EPTPC: EPTPC {
3936 _marker: PhantomData,
3937 },
3938 EPTPC0: EPTPC0 {
3939 _marker: PhantomData,
3940 },
3941 EPTPC_CFG: EPTPC_CFG {
3942 _marker: PhantomData,
3943 },
3944 SDHI0: SDHI0 {
3945 _marker: PhantomData,
3946 },
3947 SDHI1: SDHI1 {
3948 _marker: PhantomData,
3949 },
3950 CRC: CRC {
3951 _marker: PhantomData,
3952 },
3953 CTSU: CTSU {
3954 _marker: PhantomData,
3955 },
3956 MMPU: MMPU {
3957 _marker: PhantomData,
3958 },
3959 SMPU: SMPU {
3960 _marker: PhantomData,
3961 },
3962 SPMON: SPMON {
3963 _marker: PhantomData,
3964 },
3965 ADC120: ADC120 {
3966 _marker: PhantomData,
3967 },
3968 ADC121: ADC121 {
3969 _marker: PhantomData,
3970 },
3971 MSTP: MSTP {
3972 _marker: PhantomData,
3973 },
3974 GPT328: GPT328 {
3975 _marker: PhantomData,
3976 },
3977 GPT329: GPT329 {
3978 _marker: PhantomData,
3979 },
3980 GPT3210: GPT3210 {
3981 _marker: PhantomData,
3982 },
3983 GPT3211: GPT3211 {
3984 _marker: PhantomData,
3985 },
3986 GPT3212: GPT3212 {
3987 _marker: PhantomData,
3988 },
3989 GPT3213: GPT3213 {
3990 _marker: PhantomData,
3991 },
3992 RTC: RTC {
3993 _marker: PhantomData,
3994 },
3995 SSIE0: SSIE0 {
3996 _marker: PhantomData,
3997 },
3998 SSIE1: SSIE1 {
3999 _marker: PhantomData,
4000 },
4001 USBFS: USBFS {
4002 _marker: PhantomData,
4003 },
4004 SRCRAM: SRCRAM {
4005 _marker: PhantomData,
4006 },
4007 SRC: SRC {
4008 _marker: PhantomData,
4009 },
4010 ICU: ICU {
4011 _marker: PhantomData,
4012 },
4013 SRAM: SRAM {
4014 _marker: PhantomData,
4015 },
4016 GPT_ODC: GPT_ODC {
4017 _marker: PhantomData,
4018 },
4019 AGT0: AGT0 {
4020 _marker: PhantomData,
4021 },
4022 AGT1: AGT1 {
4023 _marker: PhantomData,
4024 },
4025 FCACHE: FCACHE {
4026 _marker: PhantomData,
4027 },
4028 BUS: BUS {
4029 _marker: PhantomData,
4030 },
4031 DAC12: DAC12 {
4032 _marker: PhantomData,
4033 },
4034 AMI: AMI {
4035 _marker: PhantomData,
4036 },
4037 JPEG: JPEG {
4038 _marker: PhantomData,
4039 },
4040 POEG: POEG {
4041 _marker: PhantomData,
4042 },
4043 IRDA: IRDA {
4044 _marker: PhantomData,
4045 },
4046 CAN0: CAN0 {
4047 _marker: PhantomData,
4048 },
4049 CAN1: CAN1 {
4050 _marker: PhantomData,
4051 },
4052 PDC: PDC {
4053 _marker: PhantomData,
4054 },
4055 QSPI: QSPI {
4056 _marker: PhantomData,
4057 },
4058 MMF: MMF {
4059 _marker: PhantomData,
4060 },
4061 DMAC0: DMAC0 {
4062 _marker: PhantomData,
4063 },
4064 DMAC1: DMAC1 {
4065 _marker: PhantomData,
4066 },
4067 DMAC2: DMAC2 {
4068 _marker: PhantomData,
4069 },
4070 DMAC3: DMAC3 {
4071 _marker: PhantomData,
4072 },
4073 DMAC4: DMAC4 {
4074 _marker: PhantomData,
4075 },
4076 DMAC5: DMAC5 {
4077 _marker: PhantomData,
4078 },
4079 DMAC6: DMAC6 {
4080 _marker: PhantomData,
4081 },
4082 DMAC7: DMAC7 {
4083 _marker: PhantomData,
4084 },
4085 DMA: DMA {
4086 _marker: PhantomData,
4087 },
4088 DTC: DTC {
4089 _marker: PhantomData,
4090 },
4091 DBG: DBG {
4092 _marker: PhantomData,
4093 },
4094 TSN: TSN {
4095 _marker: PhantomData,
4096 },
4097 ACMPHS0: ACMPHS0 {
4098 _marker: PhantomData,
4099 },
4100 ACMPHS1: ACMPHS1 {
4101 _marker: PhantomData,
4102 },
4103 ACMPHS2: ACMPHS2 {
4104 _marker: PhantomData,
4105 },
4106 ACMPHS3: ACMPHS3 {
4107 _marker: PhantomData,
4108 },
4109 ACMPHS4: ACMPHS4 {
4110 _marker: PhantomData,
4111 },
4112 ACMPHS5: ACMPHS5 {
4113 _marker: PhantomData,
4114 },
4115 ELC: ELC {
4116 _marker: PhantomData,
4117 },
4118 WDT: WDT {
4119 _marker: PhantomData,
4120 },
4121 IWDT: IWDT {
4122 _marker: PhantomData,
4123 },
4124 KINT: KINT {
4125 _marker: PhantomData,
4126 },
4127 DOC: DOC {
4128 _marker: PhantomData,
4129 },
4130 CAC: CAC {
4131 _marker: PhantomData,
4132 },
4133 }
4134 }
4135}