1#![doc = "Peripheral access API for TM4C129X microcontrollers (generated using svd2rust v0.17.0)\n\nYou can find an overview of the API [here].\n\n[here]: https://docs.rs/svd2rust/0.17.0/svd2rust/#peripheral-api"]
2#![deny(const_err)]
3#![deny(dead_code)]
4#![deny(improper_ctypes)]
5#![deny(legacy_directory_ownership)]
6#![deny(missing_docs)]
7#![deny(no_mangle_generic_items)]
8#![deny(non_shorthand_field_patterns)]
9#![deny(overflowing_literals)]
10#![deny(path_statements)]
11#![deny(patterns_in_fns_without_body)]
12#![deny(plugin_as_library)]
13#![deny(private_in_public)]
14#![deny(safe_extern_statics)]
15#![deny(unconditional_recursion)]
16#![deny(unions_with_drop_fields)]
17#![deny(unused_allocation)]
18#![deny(unused_comparisons)]
19#![deny(unused_parens)]
20#![deny(while_true)]
21#![allow(non_camel_case_types)]
22#![allow(non_snake_case)]
23#![no_std]
24extern crate cortex_m;
25#[cfg(feature = "rt")]
26extern crate cortex_m_rt;
27extern crate vcell;
28use core::marker::PhantomData;
29use core::ops::Deref;
30#[doc = r"Number available in the NVIC for configuring priority"]
31pub const NVIC_PRIO_BITS: u8 = 3;
32#[cfg(feature = "rt")]
33extern "C" {
34 fn GPIOA();
35 fn GPIOB();
36 fn GPIOC();
37 fn GPIOD();
38 fn GPIOE();
39 fn UART0();
40 fn UART1();
41 fn SSI0();
42 fn I2C0();
43 fn PWM0_FAULT();
44 fn PWM0_0();
45 fn PWM0_1();
46 fn PWM0_2();
47 fn QEI0();
48 fn ADC0SS0();
49 fn ADC0SS1();
50 fn ADC0SS2();
51 fn ADC0SS3();
52 fn WATCHDOG();
53 fn TIMER0A();
54 fn TIMER0B();
55 fn TIMER1A();
56 fn TIMER1B();
57 fn TIMER2A();
58 fn TIMER2B();
59 fn COMP0();
60 fn COMP1();
61 fn COMP2();
62 fn SYSCTL();
63 fn FLASH();
64 fn GPIOF();
65 fn GPIOG();
66 fn GPIOH();
67 fn UART2();
68 fn SSI1();
69 fn TIMER3A();
70 fn TIMER3B();
71 fn I2C1();
72 fn CAN0();
73 fn CAN1();
74 fn EMAC0();
75 fn HIBERNATE();
76 fn USB0();
77 fn PWM0_3();
78 fn UDMA();
79 fn UDMAERR();
80 fn ADC1SS0();
81 fn ADC1SS1();
82 fn ADC1SS2();
83 fn ADC1SS3();
84 fn EPI0();
85 fn GPIOJ();
86 fn GPIOK();
87 fn GPIOL();
88 fn SSI2();
89 fn SSI3();
90 fn UART3();
91 fn UART4();
92 fn UART5();
93 fn UART6();
94 fn UART7();
95 fn I2C2();
96 fn I2C3();
97 fn TIMER4A();
98 fn TIMER4B();
99 fn TIMER5A();
100 fn TIMER5B();
101 fn SYSEXC();
102 fn I2C4();
103 fn I2C5();
104 fn GPIOM();
105 fn GPION();
106 fn TAMPER0();
107 fn GPIOP0();
108 fn GPIOP1();
109 fn GPIOP2();
110 fn GPIOP3();
111 fn GPIOP4();
112 fn GPIOP5();
113 fn GPIOP6();
114 fn GPIOP7();
115 fn GPIOQ0();
116 fn GPIOQ1();
117 fn GPIOQ2();
118 fn GPIOQ3();
119 fn GPIOQ4();
120 fn GPIOQ5();
121 fn GPIOQ6();
122 fn GPIOQ7();
123 fn GPIOR();
124 fn GPIOS();
125 fn SHA0();
126 fn AES0();
127 fn DES0();
128 fn LCD0();
129 fn TIMER6A();
130 fn TIMER6B();
131 fn TIMER7A();
132 fn TIMER7B();
133 fn I2C6();
134 fn I2C7();
135 fn ONEWIRE0();
136 fn I2C8();
137 fn I2C9();
138 fn GPIOT();
139}
140#[doc(hidden)]
141pub union Vector {
142 _handler: unsafe extern "C" fn(),
143 _reserved: u32,
144}
145#[cfg(feature = "rt")]
146#[doc(hidden)]
147#[link_section = ".vector_table.interrupts"]
148#[no_mangle]
149pub static __INTERRUPTS: [Vector; 112] = [
150 Vector { _handler: GPIOA },
151 Vector { _handler: GPIOB },
152 Vector { _handler: GPIOC },
153 Vector { _handler: GPIOD },
154 Vector { _handler: GPIOE },
155 Vector { _handler: UART0 },
156 Vector { _handler: UART1 },
157 Vector { _handler: SSI0 },
158 Vector { _handler: I2C0 },
159 Vector { _handler: PWM0_FAULT },
160 Vector { _handler: PWM0_0 },
161 Vector { _handler: PWM0_1 },
162 Vector { _handler: PWM0_2 },
163 Vector { _handler: QEI0 },
164 Vector { _handler: ADC0SS0 },
165 Vector { _handler: ADC0SS1 },
166 Vector { _handler: ADC0SS2 },
167 Vector { _handler: ADC0SS3 },
168 Vector { _handler: WATCHDOG },
169 Vector { _handler: TIMER0A },
170 Vector { _handler: TIMER0B },
171 Vector { _handler: TIMER1A },
172 Vector { _handler: TIMER1B },
173 Vector { _handler: TIMER2A },
174 Vector { _handler: TIMER2B },
175 Vector { _handler: COMP0 },
176 Vector { _handler: COMP1 },
177 Vector { _handler: COMP2 },
178 Vector { _handler: SYSCTL },
179 Vector { _handler: FLASH },
180 Vector { _handler: GPIOF },
181 Vector { _handler: GPIOG },
182 Vector { _handler: GPIOH },
183 Vector { _handler: UART2 },
184 Vector { _handler: SSI1 },
185 Vector { _handler: TIMER3A },
186 Vector { _handler: TIMER3B },
187 Vector { _handler: I2C1 },
188 Vector { _handler: CAN0 },
189 Vector { _handler: CAN1 },
190 Vector { _handler: EMAC0 },
191 Vector { _handler: HIBERNATE },
192 Vector { _handler: USB0 },
193 Vector { _handler: PWM0_3 },
194 Vector { _handler: UDMA },
195 Vector { _handler: UDMAERR },
196 Vector { _handler: ADC1SS0 },
197 Vector { _handler: ADC1SS1 },
198 Vector { _handler: ADC1SS2 },
199 Vector { _handler: ADC1SS3 },
200 Vector { _handler: EPI0 },
201 Vector { _handler: GPIOJ },
202 Vector { _handler: GPIOK },
203 Vector { _handler: GPIOL },
204 Vector { _handler: SSI2 },
205 Vector { _handler: SSI3 },
206 Vector { _handler: UART3 },
207 Vector { _handler: UART4 },
208 Vector { _handler: UART5 },
209 Vector { _handler: UART6 },
210 Vector { _handler: UART7 },
211 Vector { _handler: I2C2 },
212 Vector { _handler: I2C3 },
213 Vector { _handler: TIMER4A },
214 Vector { _handler: TIMER4B },
215 Vector { _handler: TIMER5A },
216 Vector { _handler: TIMER5B },
217 Vector { _handler: SYSEXC },
218 Vector { _reserved: 0 },
219 Vector { _reserved: 0 },
220 Vector { _handler: I2C4 },
221 Vector { _handler: I2C5 },
222 Vector { _handler: GPIOM },
223 Vector { _handler: GPION },
224 Vector { _reserved: 0 },
225 Vector { _handler: TAMPER0 },
226 Vector { _handler: GPIOP0 },
227 Vector { _handler: GPIOP1 },
228 Vector { _handler: GPIOP2 },
229 Vector { _handler: GPIOP3 },
230 Vector { _handler: GPIOP4 },
231 Vector { _handler: GPIOP5 },
232 Vector { _handler: GPIOP6 },
233 Vector { _handler: GPIOP7 },
234 Vector { _handler: GPIOQ0 },
235 Vector { _handler: GPIOQ1 },
236 Vector { _handler: GPIOQ2 },
237 Vector { _handler: GPIOQ3 },
238 Vector { _handler: GPIOQ4 },
239 Vector { _handler: GPIOQ5 },
240 Vector { _handler: GPIOQ6 },
241 Vector { _handler: GPIOQ7 },
242 Vector { _handler: GPIOR },
243 Vector { _handler: GPIOS },
244 Vector { _handler: SHA0 },
245 Vector { _handler: AES0 },
246 Vector { _handler: DES0 },
247 Vector { _handler: LCD0 },
248 Vector { _handler: TIMER6A },
249 Vector { _handler: TIMER6B },
250 Vector { _handler: TIMER7A },
251 Vector { _handler: TIMER7B },
252 Vector { _handler: I2C6 },
253 Vector { _handler: I2C7 },
254 Vector { _reserved: 0 },
255 Vector { _handler: ONEWIRE0 },
256 Vector { _reserved: 0 },
257 Vector { _reserved: 0 },
258 Vector { _reserved: 0 },
259 Vector { _handler: I2C8 },
260 Vector { _handler: I2C9 },
261 Vector { _handler: GPIOT },
262];
263#[doc = r"Enumeration of all the interrupts"]
264#[derive(Copy, Clone, Debug)]
265#[repr(u8)]
266pub enum Interrupt {
267 #[doc = "0 - GPIO Port A"]
268 GPIOA = 0,
269 #[doc = "1 - GPIO Port B"]
270 GPIOB = 1,
271 #[doc = "2 - GPIO Port C"]
272 GPIOC = 2,
273 #[doc = "3 - GPIO Port D"]
274 GPIOD = 3,
275 #[doc = "4 - GPIO Port E"]
276 GPIOE = 4,
277 #[doc = "5 - UART0"]
278 UART0 = 5,
279 #[doc = "6 - UART1"]
280 UART1 = 6,
281 #[doc = "7 - SSI0"]
282 SSI0 = 7,
283 #[doc = "8 - I2C0"]
284 I2C0 = 8,
285 #[doc = "9 - PWM Fault"]
286 PWM0_FAULT = 9,
287 #[doc = "10 - PWM Generator 0"]
288 PWM0_0 = 10,
289 #[doc = "11 - PWM Generator 1"]
290 PWM0_1 = 11,
291 #[doc = "12 - PWM Generator 2"]
292 PWM0_2 = 12,
293 #[doc = "13 - QEI0"]
294 QEI0 = 13,
295 #[doc = "14 - ADC0 Sequence 0"]
296 ADC0SS0 = 14,
297 #[doc = "15 - ADC0 Sequence 1"]
298 ADC0SS1 = 15,
299 #[doc = "16 - ADC0 Sequence 2"]
300 ADC0SS2 = 16,
301 #[doc = "17 - ADC0 Sequence 3"]
302 ADC0SS3 = 17,
303 #[doc = "18 - Watchdog Timers 0 and 1"]
304 WATCHDOG = 18,
305 #[doc = "19 - 16/32-Bit Timer 0A"]
306 TIMER0A = 19,
307 #[doc = "20 - 16/32-Bit Timer 0B"]
308 TIMER0B = 20,
309 #[doc = "21 - 16/32-Bit Timer 1A"]
310 TIMER1A = 21,
311 #[doc = "22 - 16/32-Bit Timer 1B"]
312 TIMER1B = 22,
313 #[doc = "23 - 16/32-Bit Timer 2A"]
314 TIMER2A = 23,
315 #[doc = "24 - 16/32-Bit Timer 2B"]
316 TIMER2B = 24,
317 #[doc = "25 - Analog Comparator 0"]
318 COMP0 = 25,
319 #[doc = "26 - Analog Comparator 1"]
320 COMP1 = 26,
321 #[doc = "27 - Analog Comparator 2"]
322 COMP2 = 27,
323 #[doc = "28 - System Control"]
324 SYSCTL = 28,
325 #[doc = "29 - Flash Memory Control"]
326 FLASH = 29,
327 #[doc = "30 - GPIO Port F"]
328 GPIOF = 30,
329 #[doc = "31 - GPIO Port G"]
330 GPIOG = 31,
331 #[doc = "32 - GPIO Port H"]
332 GPIOH = 32,
333 #[doc = "33 - UART2"]
334 UART2 = 33,
335 #[doc = "34 - SSI1"]
336 SSI1 = 34,
337 #[doc = "35 - 16/32-Bit Timer 3A"]
338 TIMER3A = 35,
339 #[doc = "36 - 16/32-Bit Timer 3B"]
340 TIMER3B = 36,
341 #[doc = "37 - I2C1"]
342 I2C1 = 37,
343 #[doc = "38 - CAN 0"]
344 CAN0 = 38,
345 #[doc = "39 - CAN1"]
346 CAN1 = 39,
347 #[doc = "40 - Ethernet MAC"]
348 EMAC0 = 40,
349 #[doc = "41 - HIB (Power Island)"]
350 HIBERNATE = 41,
351 #[doc = "42 - USB MAC"]
352 USB0 = 42,
353 #[doc = "43 - PWM Generator 3"]
354 PWM0_3 = 43,
355 #[doc = "44 - uDMA 0 Software"]
356 UDMA = 44,
357 #[doc = "45 - uDMA 0 Error"]
358 UDMAERR = 45,
359 #[doc = "46 - ADC1 Sequence 0"]
360 ADC1SS0 = 46,
361 #[doc = "47 - ADC1 Sequence 1"]
362 ADC1SS1 = 47,
363 #[doc = "48 - ADC1 Sequence 2"]
364 ADC1SS2 = 48,
365 #[doc = "49 - ADC1 Sequence 3"]
366 ADC1SS3 = 49,
367 #[doc = "50 - EPI 0"]
368 EPI0 = 50,
369 #[doc = "51 - GPIO Port J"]
370 GPIOJ = 51,
371 #[doc = "52 - GPIO Port K"]
372 GPIOK = 52,
373 #[doc = "53 - GPIO Port L"]
374 GPIOL = 53,
375 #[doc = "54 - SSI 2"]
376 SSI2 = 54,
377 #[doc = "55 - SSI 3"]
378 SSI3 = 55,
379 #[doc = "56 - UART 3"]
380 UART3 = 56,
381 #[doc = "57 - UART 4"]
382 UART4 = 57,
383 #[doc = "58 - UART 5"]
384 UART5 = 58,
385 #[doc = "59 - UART 6"]
386 UART6 = 59,
387 #[doc = "60 - UART 7"]
388 UART7 = 60,
389 #[doc = "61 - I2C 2"]
390 I2C2 = 61,
391 #[doc = "62 - I2C 3"]
392 I2C3 = 62,
393 #[doc = "63 - Timer 4A"]
394 TIMER4A = 63,
395 #[doc = "64 - Timer 4B"]
396 TIMER4B = 64,
397 #[doc = "65 - Timer 5A"]
398 TIMER5A = 65,
399 #[doc = "66 - Timer 5B"]
400 TIMER5B = 66,
401 #[doc = "67 - Floating-Point Exception (imprecise)"]
402 SYSEXC = 67,
403 #[doc = "70 - I2C 4"]
404 I2C4 = 70,
405 #[doc = "71 - I2C 5"]
406 I2C5 = 71,
407 #[doc = "72 - GPIO Port M"]
408 GPIOM = 72,
409 #[doc = "73 - GPIO Port N"]
410 GPION = 73,
411 #[doc = "75 - Tamper"]
412 TAMPER0 = 75,
413 #[doc = "76 - GPIO Port P (Summary or P0)"]
414 GPIOP0 = 76,
415 #[doc = "77 - GPIO Port P1"]
416 GPIOP1 = 77,
417 #[doc = "78 - GPIO Port P2"]
418 GPIOP2 = 78,
419 #[doc = "79 - GPIO Port P3"]
420 GPIOP3 = 79,
421 #[doc = "80 - GPIO Port P4"]
422 GPIOP4 = 80,
423 #[doc = "81 - GPIO Port P5"]
424 GPIOP5 = 81,
425 #[doc = "82 - GPIO Port P6"]
426 GPIOP6 = 82,
427 #[doc = "83 - GPIO Port P7"]
428 GPIOP7 = 83,
429 #[doc = "84 - GPIO Port Q (Summary or Q0)"]
430 GPIOQ0 = 84,
431 #[doc = "85 - GPIO Port Q1"]
432 GPIOQ1 = 85,
433 #[doc = "86 - GPIO Port Q2"]
434 GPIOQ2 = 86,
435 #[doc = "87 - GPIO Port Q3"]
436 GPIOQ3 = 87,
437 #[doc = "88 - GPIO Port Q4"]
438 GPIOQ4 = 88,
439 #[doc = "89 - GPIO Port Q5"]
440 GPIOQ5 = 89,
441 #[doc = "90 - GPIO Port Q6"]
442 GPIOQ6 = 90,
443 #[doc = "91 - GPIO Port Q7"]
444 GPIOQ7 = 91,
445 #[doc = "92 - GPIO Port R"]
446 GPIOR = 92,
447 #[doc = "93 - GPIO Port S"]
448 GPIOS = 93,
449 #[doc = "94 - SHA/MD5"]
450 SHA0 = 94,
451 #[doc = "95 - AES"]
452 AES0 = 95,
453 #[doc = "96 - DES"]
454 DES0 = 96,
455 #[doc = "97 - LCD"]
456 LCD0 = 97,
457 #[doc = "98 - 16/32-Bit Timer 6A"]
458 TIMER6A = 98,
459 #[doc = "99 - 16/32-Bit Timer 6B"]
460 TIMER6B = 99,
461 #[doc = "100 - 16/32-Bit Timer 7A"]
462 TIMER7A = 100,
463 #[doc = "101 - 16/32-Bit Timer 7B"]
464 TIMER7B = 101,
465 #[doc = "102 - I2C 6"]
466 I2C6 = 102,
467 #[doc = "103 - I2C 7"]
468 I2C7 = 103,
469 #[doc = "105 - 1-Wire"]
470 ONEWIRE0 = 105,
471 #[doc = "109 - I2C 8"]
472 I2C8 = 109,
473 #[doc = "110 - I2C 9"]
474 I2C9 = 110,
475 #[doc = "111 - GPIO T"]
476 GPIOT = 111,
477}
478unsafe impl cortex_m::interrupt::InterruptNumber for Interrupt {
479 #[inline(always)]
480 fn number(self) -> u16 {
481 self as u16
482 }
483}
484#[cfg(feature = "rt")]
485pub use self::Interrupt as interrupt;
486pub use cortex_m::peripheral::Peripherals as CorePeripherals;
487pub use cortex_m::peripheral::{CBP, CPUID, DCB, DWT, FPB, FPU, ITM, MPU, NVIC, SCB, SYST, TPIU};
488#[cfg(feature = "rt")]
489pub use cortex_m_rt::interrupt;
490#[allow(unused_imports)]
491use generic::*;
492#[doc = r"Common register and bit access and modify traits"]
493pub mod generic;
494#[doc = "Watchdog Timer register offsets"]
495pub struct WATCHDOG0 {
496 _marker: PhantomData<*const ()>,
497}
498unsafe impl Send for WATCHDOG0 {}
499impl WATCHDOG0 {
500 #[doc = r"Returns a pointer to the register block"]
501 #[inline(always)]
502 pub const fn ptr() -> *const watchdog0::RegisterBlock {
503 0x4000_0000 as *const _
504 }
505}
506impl Deref for WATCHDOG0 {
507 type Target = watchdog0::RegisterBlock;
508 #[inline(always)]
509 fn deref(&self) -> &Self::Target {
510 unsafe { &*WATCHDOG0::ptr() }
511 }
512}
513#[doc = "Watchdog Timer register offsets"]
514pub mod watchdog0;
515#[doc = "Watchdog Timer register offsets"]
516pub struct WATCHDOG1 {
517 _marker: PhantomData<*const ()>,
518}
519unsafe impl Send for WATCHDOG1 {}
520impl WATCHDOG1 {
521 #[doc = r"Returns a pointer to the register block"]
522 #[inline(always)]
523 pub const fn ptr() -> *const watchdog0::RegisterBlock {
524 0x4000_1000 as *const _
525 }
526}
527impl Deref for WATCHDOG1 {
528 type Target = watchdog0::RegisterBlock;
529 #[inline(always)]
530 fn deref(&self) -> &Self::Target {
531 unsafe { &*WATCHDOG1::ptr() }
532 }
533}
534#[doc = "SSI register offsets"]
535pub struct SSI0 {
536 _marker: PhantomData<*const ()>,
537}
538unsafe impl Send for SSI0 {}
539impl SSI0 {
540 #[doc = r"Returns a pointer to the register block"]
541 #[inline(always)]
542 pub const fn ptr() -> *const ssi0::RegisterBlock {
543 0x4000_8000 as *const _
544 }
545}
546impl Deref for SSI0 {
547 type Target = ssi0::RegisterBlock;
548 #[inline(always)]
549 fn deref(&self) -> &Self::Target {
550 unsafe { &*SSI0::ptr() }
551 }
552}
553#[doc = "SSI register offsets"]
554pub mod ssi0;
555#[doc = "SSI register offsets"]
556pub struct SSI1 {
557 _marker: PhantomData<*const ()>,
558}
559unsafe impl Send for SSI1 {}
560impl SSI1 {
561 #[doc = r"Returns a pointer to the register block"]
562 #[inline(always)]
563 pub const fn ptr() -> *const ssi0::RegisterBlock {
564 0x4000_9000 as *const _
565 }
566}
567impl Deref for SSI1 {
568 type Target = ssi0::RegisterBlock;
569 #[inline(always)]
570 fn deref(&self) -> &Self::Target {
571 unsafe { &*SSI1::ptr() }
572 }
573}
574#[doc = "SSI register offsets"]
575pub struct SSI2 {
576 _marker: PhantomData<*const ()>,
577}
578unsafe impl Send for SSI2 {}
579impl SSI2 {
580 #[doc = r"Returns a pointer to the register block"]
581 #[inline(always)]
582 pub const fn ptr() -> *const ssi0::RegisterBlock {
583 0x4000_a000 as *const _
584 }
585}
586impl Deref for SSI2 {
587 type Target = ssi0::RegisterBlock;
588 #[inline(always)]
589 fn deref(&self) -> &Self::Target {
590 unsafe { &*SSI2::ptr() }
591 }
592}
593#[doc = "SSI register offsets"]
594pub struct SSI3 {
595 _marker: PhantomData<*const ()>,
596}
597unsafe impl Send for SSI3 {}
598impl SSI3 {
599 #[doc = r"Returns a pointer to the register block"]
600 #[inline(always)]
601 pub const fn ptr() -> *const ssi0::RegisterBlock {
602 0x4000_b000 as *const _
603 }
604}
605impl Deref for SSI3 {
606 type Target = ssi0::RegisterBlock;
607 #[inline(always)]
608 fn deref(&self) -> &Self::Target {
609 unsafe { &*SSI3::ptr() }
610 }
611}
612#[doc = "UART register offsets"]
613pub struct UART0 {
614 _marker: PhantomData<*const ()>,
615}
616unsafe impl Send for UART0 {}
617impl UART0 {
618 #[doc = r"Returns a pointer to the register block"]
619 #[inline(always)]
620 pub const fn ptr() -> *const uart0::RegisterBlock {
621 0x4000_c000 as *const _
622 }
623}
624impl Deref for UART0 {
625 type Target = uart0::RegisterBlock;
626 #[inline(always)]
627 fn deref(&self) -> &Self::Target {
628 unsafe { &*UART0::ptr() }
629 }
630}
631#[doc = "UART register offsets"]
632pub mod uart0;
633#[doc = "UART register offsets"]
634pub struct UART1 {
635 _marker: PhantomData<*const ()>,
636}
637unsafe impl Send for UART1 {}
638impl UART1 {
639 #[doc = r"Returns a pointer to the register block"]
640 #[inline(always)]
641 pub const fn ptr() -> *const uart0::RegisterBlock {
642 0x4000_d000 as *const _
643 }
644}
645impl Deref for UART1 {
646 type Target = uart0::RegisterBlock;
647 #[inline(always)]
648 fn deref(&self) -> &Self::Target {
649 unsafe { &*UART1::ptr() }
650 }
651}
652#[doc = "UART register offsets"]
653pub struct UART2 {
654 _marker: PhantomData<*const ()>,
655}
656unsafe impl Send for UART2 {}
657impl UART2 {
658 #[doc = r"Returns a pointer to the register block"]
659 #[inline(always)]
660 pub const fn ptr() -> *const uart0::RegisterBlock {
661 0x4000_e000 as *const _
662 }
663}
664impl Deref for UART2 {
665 type Target = uart0::RegisterBlock;
666 #[inline(always)]
667 fn deref(&self) -> &Self::Target {
668 unsafe { &*UART2::ptr() }
669 }
670}
671#[doc = "UART register offsets"]
672pub struct UART3 {
673 _marker: PhantomData<*const ()>,
674}
675unsafe impl Send for UART3 {}
676impl UART3 {
677 #[doc = r"Returns a pointer to the register block"]
678 #[inline(always)]
679 pub const fn ptr() -> *const uart0::RegisterBlock {
680 0x4000_f000 as *const _
681 }
682}
683impl Deref for UART3 {
684 type Target = uart0::RegisterBlock;
685 #[inline(always)]
686 fn deref(&self) -> &Self::Target {
687 unsafe { &*UART3::ptr() }
688 }
689}
690#[doc = "UART register offsets"]
691pub struct UART4 {
692 _marker: PhantomData<*const ()>,
693}
694unsafe impl Send for UART4 {}
695impl UART4 {
696 #[doc = r"Returns a pointer to the register block"]
697 #[inline(always)]
698 pub const fn ptr() -> *const uart0::RegisterBlock {
699 0x4001_0000 as *const _
700 }
701}
702impl Deref for UART4 {
703 type Target = uart0::RegisterBlock;
704 #[inline(always)]
705 fn deref(&self) -> &Self::Target {
706 unsafe { &*UART4::ptr() }
707 }
708}
709#[doc = "UART register offsets"]
710pub struct UART5 {
711 _marker: PhantomData<*const ()>,
712}
713unsafe impl Send for UART5 {}
714impl UART5 {
715 #[doc = r"Returns a pointer to the register block"]
716 #[inline(always)]
717 pub const fn ptr() -> *const uart0::RegisterBlock {
718 0x4001_1000 as *const _
719 }
720}
721impl Deref for UART5 {
722 type Target = uart0::RegisterBlock;
723 #[inline(always)]
724 fn deref(&self) -> &Self::Target {
725 unsafe { &*UART5::ptr() }
726 }
727}
728#[doc = "UART register offsets"]
729pub struct UART6 {
730 _marker: PhantomData<*const ()>,
731}
732unsafe impl Send for UART6 {}
733impl UART6 {
734 #[doc = r"Returns a pointer to the register block"]
735 #[inline(always)]
736 pub const fn ptr() -> *const uart0::RegisterBlock {
737 0x4001_2000 as *const _
738 }
739}
740impl Deref for UART6 {
741 type Target = uart0::RegisterBlock;
742 #[inline(always)]
743 fn deref(&self) -> &Self::Target {
744 unsafe { &*UART6::ptr() }
745 }
746}
747#[doc = "UART register offsets"]
748pub struct UART7 {
749 _marker: PhantomData<*const ()>,
750}
751unsafe impl Send for UART7 {}
752impl UART7 {
753 #[doc = r"Returns a pointer to the register block"]
754 #[inline(always)]
755 pub const fn ptr() -> *const uart0::RegisterBlock {
756 0x4001_3000 as *const _
757 }
758}
759impl Deref for UART7 {
760 type Target = uart0::RegisterBlock;
761 #[inline(always)]
762 fn deref(&self) -> &Self::Target {
763 unsafe { &*UART7::ptr() }
764 }
765}
766#[doc = "I2C register offsets"]
767pub struct I2C0 {
768 _marker: PhantomData<*const ()>,
769}
770unsafe impl Send for I2C0 {}
771impl I2C0 {
772 #[doc = r"Returns a pointer to the register block"]
773 #[inline(always)]
774 pub const fn ptr() -> *const i2c0::RegisterBlock {
775 0x4002_0000 as *const _
776 }
777}
778impl Deref for I2C0 {
779 type Target = i2c0::RegisterBlock;
780 #[inline(always)]
781 fn deref(&self) -> &Self::Target {
782 unsafe { &*I2C0::ptr() }
783 }
784}
785#[doc = "I2C register offsets"]
786pub mod i2c0;
787#[doc = "I2C register offsets"]
788pub struct I2C1 {
789 _marker: PhantomData<*const ()>,
790}
791unsafe impl Send for I2C1 {}
792impl I2C1 {
793 #[doc = r"Returns a pointer to the register block"]
794 #[inline(always)]
795 pub const fn ptr() -> *const i2c0::RegisterBlock {
796 0x4002_1000 as *const _
797 }
798}
799impl Deref for I2C1 {
800 type Target = i2c0::RegisterBlock;
801 #[inline(always)]
802 fn deref(&self) -> &Self::Target {
803 unsafe { &*I2C1::ptr() }
804 }
805}
806#[doc = "I2C register offsets"]
807pub struct I2C2 {
808 _marker: PhantomData<*const ()>,
809}
810unsafe impl Send for I2C2 {}
811impl I2C2 {
812 #[doc = r"Returns a pointer to the register block"]
813 #[inline(always)]
814 pub const fn ptr() -> *const i2c0::RegisterBlock {
815 0x4002_2000 as *const _
816 }
817}
818impl Deref for I2C2 {
819 type Target = i2c0::RegisterBlock;
820 #[inline(always)]
821 fn deref(&self) -> &Self::Target {
822 unsafe { &*I2C2::ptr() }
823 }
824}
825#[doc = "I2C register offsets"]
826pub struct I2C3 {
827 _marker: PhantomData<*const ()>,
828}
829unsafe impl Send for I2C3 {}
830impl I2C3 {
831 #[doc = r"Returns a pointer to the register block"]
832 #[inline(always)]
833 pub const fn ptr() -> *const i2c0::RegisterBlock {
834 0x4002_3000 as *const _
835 }
836}
837impl Deref for I2C3 {
838 type Target = i2c0::RegisterBlock;
839 #[inline(always)]
840 fn deref(&self) -> &Self::Target {
841 unsafe { &*I2C3::ptr() }
842 }
843}
844#[doc = "PWM register offsets"]
845pub struct PWM0 {
846 _marker: PhantomData<*const ()>,
847}
848unsafe impl Send for PWM0 {}
849impl PWM0 {
850 #[doc = r"Returns a pointer to the register block"]
851 #[inline(always)]
852 pub const fn ptr() -> *const pwm0::RegisterBlock {
853 0x4002_8000 as *const _
854 }
855}
856impl Deref for PWM0 {
857 type Target = pwm0::RegisterBlock;
858 #[inline(always)]
859 fn deref(&self) -> &Self::Target {
860 unsafe { &*PWM0::ptr() }
861 }
862}
863#[doc = "PWM register offsets"]
864pub mod pwm0;
865#[doc = "QEI register offsets"]
866pub struct QEI0 {
867 _marker: PhantomData<*const ()>,
868}
869unsafe impl Send for QEI0 {}
870impl QEI0 {
871 #[doc = r"Returns a pointer to the register block"]
872 #[inline(always)]
873 pub const fn ptr() -> *const qei0::RegisterBlock {
874 0x4002_c000 as *const _
875 }
876}
877impl Deref for QEI0 {
878 type Target = qei0::RegisterBlock;
879 #[inline(always)]
880 fn deref(&self) -> &Self::Target {
881 unsafe { &*QEI0::ptr() }
882 }
883}
884#[doc = "QEI register offsets"]
885pub mod qei0;
886#[doc = "Timer register offsets"]
887pub struct TIMER0 {
888 _marker: PhantomData<*const ()>,
889}
890unsafe impl Send for TIMER0 {}
891impl TIMER0 {
892 #[doc = r"Returns a pointer to the register block"]
893 #[inline(always)]
894 pub const fn ptr() -> *const timer0::RegisterBlock {
895 0x4003_0000 as *const _
896 }
897}
898impl Deref for TIMER0 {
899 type Target = timer0::RegisterBlock;
900 #[inline(always)]
901 fn deref(&self) -> &Self::Target {
902 unsafe { &*TIMER0::ptr() }
903 }
904}
905#[doc = "Timer register offsets"]
906pub mod timer0;
907#[doc = "Timer register offsets"]
908pub struct TIMER1 {
909 _marker: PhantomData<*const ()>,
910}
911unsafe impl Send for TIMER1 {}
912impl TIMER1 {
913 #[doc = r"Returns a pointer to the register block"]
914 #[inline(always)]
915 pub const fn ptr() -> *const timer0::RegisterBlock {
916 0x4003_1000 as *const _
917 }
918}
919impl Deref for TIMER1 {
920 type Target = timer0::RegisterBlock;
921 #[inline(always)]
922 fn deref(&self) -> &Self::Target {
923 unsafe { &*TIMER1::ptr() }
924 }
925}
926#[doc = "Timer register offsets"]
927pub struct TIMER2 {
928 _marker: PhantomData<*const ()>,
929}
930unsafe impl Send for TIMER2 {}
931impl TIMER2 {
932 #[doc = r"Returns a pointer to the register block"]
933 #[inline(always)]
934 pub const fn ptr() -> *const timer0::RegisterBlock {
935 0x4003_2000 as *const _
936 }
937}
938impl Deref for TIMER2 {
939 type Target = timer0::RegisterBlock;
940 #[inline(always)]
941 fn deref(&self) -> &Self::Target {
942 unsafe { &*TIMER2::ptr() }
943 }
944}
945#[doc = "Timer register offsets"]
946pub struct TIMER3 {
947 _marker: PhantomData<*const ()>,
948}
949unsafe impl Send for TIMER3 {}
950impl TIMER3 {
951 #[doc = r"Returns a pointer to the register block"]
952 #[inline(always)]
953 pub const fn ptr() -> *const timer0::RegisterBlock {
954 0x4003_3000 as *const _
955 }
956}
957impl Deref for TIMER3 {
958 type Target = timer0::RegisterBlock;
959 #[inline(always)]
960 fn deref(&self) -> &Self::Target {
961 unsafe { &*TIMER3::ptr() }
962 }
963}
964#[doc = "Timer register offsets"]
965pub struct TIMER4 {
966 _marker: PhantomData<*const ()>,
967}
968unsafe impl Send for TIMER4 {}
969impl TIMER4 {
970 #[doc = r"Returns a pointer to the register block"]
971 #[inline(always)]
972 pub const fn ptr() -> *const timer0::RegisterBlock {
973 0x4003_4000 as *const _
974 }
975}
976impl Deref for TIMER4 {
977 type Target = timer0::RegisterBlock;
978 #[inline(always)]
979 fn deref(&self) -> &Self::Target {
980 unsafe { &*TIMER4::ptr() }
981 }
982}
983#[doc = "Timer register offsets"]
984pub struct TIMER5 {
985 _marker: PhantomData<*const ()>,
986}
987unsafe impl Send for TIMER5 {}
988impl TIMER5 {
989 #[doc = r"Returns a pointer to the register block"]
990 #[inline(always)]
991 pub const fn ptr() -> *const timer0::RegisterBlock {
992 0x4003_5000 as *const _
993 }
994}
995impl Deref for TIMER5 {
996 type Target = timer0::RegisterBlock;
997 #[inline(always)]
998 fn deref(&self) -> &Self::Target {
999 unsafe { &*TIMER5::ptr() }
1000 }
1001}
1002#[doc = "ADC register offsets"]
1003pub struct ADC0 {
1004 _marker: PhantomData<*const ()>,
1005}
1006unsafe impl Send for ADC0 {}
1007impl ADC0 {
1008 #[doc = r"Returns a pointer to the register block"]
1009 #[inline(always)]
1010 pub const fn ptr() -> *const adc0::RegisterBlock {
1011 0x4003_8000 as *const _
1012 }
1013}
1014impl Deref for ADC0 {
1015 type Target = adc0::RegisterBlock;
1016 #[inline(always)]
1017 fn deref(&self) -> &Self::Target {
1018 unsafe { &*ADC0::ptr() }
1019 }
1020}
1021#[doc = "ADC register offsets"]
1022pub mod adc0;
1023#[doc = "ADC register offsets"]
1024pub struct ADC1 {
1025 _marker: PhantomData<*const ()>,
1026}
1027unsafe impl Send for ADC1 {}
1028impl ADC1 {
1029 #[doc = r"Returns a pointer to the register block"]
1030 #[inline(always)]
1031 pub const fn ptr() -> *const adc0::RegisterBlock {
1032 0x4003_9000 as *const _
1033 }
1034}
1035impl Deref for ADC1 {
1036 type Target = adc0::RegisterBlock;
1037 #[inline(always)]
1038 fn deref(&self) -> &Self::Target {
1039 unsafe { &*ADC1::ptr() }
1040 }
1041}
1042#[doc = "Comparator register offsets"]
1043pub struct COMP {
1044 _marker: PhantomData<*const ()>,
1045}
1046unsafe impl Send for COMP {}
1047impl COMP {
1048 #[doc = r"Returns a pointer to the register block"]
1049 #[inline(always)]
1050 pub const fn ptr() -> *const comp::RegisterBlock {
1051 0x4003_c000 as *const _
1052 }
1053}
1054impl Deref for COMP {
1055 type Target = comp::RegisterBlock;
1056 #[inline(always)]
1057 fn deref(&self) -> &Self::Target {
1058 unsafe { &*COMP::ptr() }
1059 }
1060}
1061#[doc = "Comparator register offsets"]
1062pub mod comp;
1063#[doc = "CAN register offsets"]
1064pub struct CAN0 {
1065 _marker: PhantomData<*const ()>,
1066}
1067unsafe impl Send for CAN0 {}
1068impl CAN0 {
1069 #[doc = r"Returns a pointer to the register block"]
1070 #[inline(always)]
1071 pub const fn ptr() -> *const can0::RegisterBlock {
1072 0x4004_0000 as *const _
1073 }
1074}
1075impl Deref for CAN0 {
1076 type Target = can0::RegisterBlock;
1077 #[inline(always)]
1078 fn deref(&self) -> &Self::Target {
1079 unsafe { &*CAN0::ptr() }
1080 }
1081}
1082#[doc = "CAN register offsets"]
1083pub mod can0;
1084#[doc = "CAN register offsets"]
1085pub struct CAN1 {
1086 _marker: PhantomData<*const ()>,
1087}
1088unsafe impl Send for CAN1 {}
1089impl CAN1 {
1090 #[doc = r"Returns a pointer to the register block"]
1091 #[inline(always)]
1092 pub const fn ptr() -> *const can0::RegisterBlock {
1093 0x4004_1000 as *const _
1094 }
1095}
1096impl Deref for CAN1 {
1097 type Target = can0::RegisterBlock;
1098 #[inline(always)]
1099 fn deref(&self) -> &Self::Target {
1100 unsafe { &*CAN1::ptr() }
1101 }
1102}
1103#[doc = "Univeral Serial Bus register offsets"]
1104pub struct USB0 {
1105 _marker: PhantomData<*const ()>,
1106}
1107unsafe impl Send for USB0 {}
1108impl USB0 {
1109 #[doc = r"Returns a pointer to the register block"]
1110 #[inline(always)]
1111 pub const fn ptr() -> *const usb0::RegisterBlock {
1112 0x4005_0000 as *const _
1113 }
1114}
1115impl Deref for USB0 {
1116 type Target = usb0::RegisterBlock;
1117 #[inline(always)]
1118 fn deref(&self) -> &Self::Target {
1119 unsafe { &*USB0::ptr() }
1120 }
1121}
1122#[doc = "Univeral Serial Bus register offsets"]
1123pub mod usb0;
1124#[doc = "GPIO register offsets"]
1125pub struct GPIO_PORTA_AHB {
1126 _marker: PhantomData<*const ()>,
1127}
1128unsafe impl Send for GPIO_PORTA_AHB {}
1129impl GPIO_PORTA_AHB {
1130 #[doc = r"Returns a pointer to the register block"]
1131 #[inline(always)]
1132 pub const fn ptr() -> *const gpio_porta_ahb::RegisterBlock {
1133 0x4005_8000 as *const _
1134 }
1135}
1136impl Deref for GPIO_PORTA_AHB {
1137 type Target = gpio_porta_ahb::RegisterBlock;
1138 #[inline(always)]
1139 fn deref(&self) -> &Self::Target {
1140 unsafe { &*GPIO_PORTA_AHB::ptr() }
1141 }
1142}
1143#[doc = "GPIO register offsets"]
1144pub mod gpio_porta_ahb;
1145#[doc = "GPIO register offsets"]
1146pub struct GPIO_PORTB_AHB {
1147 _marker: PhantomData<*const ()>,
1148}
1149unsafe impl Send for GPIO_PORTB_AHB {}
1150impl GPIO_PORTB_AHB {
1151 #[doc = r"Returns a pointer to the register block"]
1152 #[inline(always)]
1153 pub const fn ptr() -> *const gpio_porta_ahb::RegisterBlock {
1154 0x4005_9000 as *const _
1155 }
1156}
1157impl Deref for GPIO_PORTB_AHB {
1158 type Target = gpio_porta_ahb::RegisterBlock;
1159 #[inline(always)]
1160 fn deref(&self) -> &Self::Target {
1161 unsafe { &*GPIO_PORTB_AHB::ptr() }
1162 }
1163}
1164#[doc = "GPIO register offsets"]
1165pub struct GPIO_PORTC_AHB {
1166 _marker: PhantomData<*const ()>,
1167}
1168unsafe impl Send for GPIO_PORTC_AHB {}
1169impl GPIO_PORTC_AHB {
1170 #[doc = r"Returns a pointer to the register block"]
1171 #[inline(always)]
1172 pub const fn ptr() -> *const gpio_porta_ahb::RegisterBlock {
1173 0x4005_a000 as *const _
1174 }
1175}
1176impl Deref for GPIO_PORTC_AHB {
1177 type Target = gpio_porta_ahb::RegisterBlock;
1178 #[inline(always)]
1179 fn deref(&self) -> &Self::Target {
1180 unsafe { &*GPIO_PORTC_AHB::ptr() }
1181 }
1182}
1183#[doc = "GPIO register offsets"]
1184pub struct GPIO_PORTD_AHB {
1185 _marker: PhantomData<*const ()>,
1186}
1187unsafe impl Send for GPIO_PORTD_AHB {}
1188impl GPIO_PORTD_AHB {
1189 #[doc = r"Returns a pointer to the register block"]
1190 #[inline(always)]
1191 pub const fn ptr() -> *const gpio_porta_ahb::RegisterBlock {
1192 0x4005_b000 as *const _
1193 }
1194}
1195impl Deref for GPIO_PORTD_AHB {
1196 type Target = gpio_porta_ahb::RegisterBlock;
1197 #[inline(always)]
1198 fn deref(&self) -> &Self::Target {
1199 unsafe { &*GPIO_PORTD_AHB::ptr() }
1200 }
1201}
1202#[doc = "GPIO register offsets"]
1203pub struct GPIO_PORTE_AHB {
1204 _marker: PhantomData<*const ()>,
1205}
1206unsafe impl Send for GPIO_PORTE_AHB {}
1207impl GPIO_PORTE_AHB {
1208 #[doc = r"Returns a pointer to the register block"]
1209 #[inline(always)]
1210 pub const fn ptr() -> *const gpio_porta_ahb::RegisterBlock {
1211 0x4005_c000 as *const _
1212 }
1213}
1214impl Deref for GPIO_PORTE_AHB {
1215 type Target = gpio_porta_ahb::RegisterBlock;
1216 #[inline(always)]
1217 fn deref(&self) -> &Self::Target {
1218 unsafe { &*GPIO_PORTE_AHB::ptr() }
1219 }
1220}
1221#[doc = "GPIO register offsets"]
1222pub struct GPIO_PORTF_AHB {
1223 _marker: PhantomData<*const ()>,
1224}
1225unsafe impl Send for GPIO_PORTF_AHB {}
1226impl GPIO_PORTF_AHB {
1227 #[doc = r"Returns a pointer to the register block"]
1228 #[inline(always)]
1229 pub const fn ptr() -> *const gpio_porta_ahb::RegisterBlock {
1230 0x4005_d000 as *const _
1231 }
1232}
1233impl Deref for GPIO_PORTF_AHB {
1234 type Target = gpio_porta_ahb::RegisterBlock;
1235 #[inline(always)]
1236 fn deref(&self) -> &Self::Target {
1237 unsafe { &*GPIO_PORTF_AHB::ptr() }
1238 }
1239}
1240#[doc = "GPIO register offsets"]
1241pub struct GPIO_PORTG_AHB {
1242 _marker: PhantomData<*const ()>,
1243}
1244unsafe impl Send for GPIO_PORTG_AHB {}
1245impl GPIO_PORTG_AHB {
1246 #[doc = r"Returns a pointer to the register block"]
1247 #[inline(always)]
1248 pub const fn ptr() -> *const gpio_porta_ahb::RegisterBlock {
1249 0x4005_e000 as *const _
1250 }
1251}
1252impl Deref for GPIO_PORTG_AHB {
1253 type Target = gpio_porta_ahb::RegisterBlock;
1254 #[inline(always)]
1255 fn deref(&self) -> &Self::Target {
1256 unsafe { &*GPIO_PORTG_AHB::ptr() }
1257 }
1258}
1259#[doc = "GPIO register offsets"]
1260pub struct GPIO_PORTH_AHB {
1261 _marker: PhantomData<*const ()>,
1262}
1263unsafe impl Send for GPIO_PORTH_AHB {}
1264impl GPIO_PORTH_AHB {
1265 #[doc = r"Returns a pointer to the register block"]
1266 #[inline(always)]
1267 pub const fn ptr() -> *const gpio_porta_ahb::RegisterBlock {
1268 0x4005_f000 as *const _
1269 }
1270}
1271impl Deref for GPIO_PORTH_AHB {
1272 type Target = gpio_porta_ahb::RegisterBlock;
1273 #[inline(always)]
1274 fn deref(&self) -> &Self::Target {
1275 unsafe { &*GPIO_PORTH_AHB::ptr() }
1276 }
1277}
1278#[doc = "GPIO register offsets"]
1279pub struct GPIO_PORTJ_AHB {
1280 _marker: PhantomData<*const ()>,
1281}
1282unsafe impl Send for GPIO_PORTJ_AHB {}
1283impl GPIO_PORTJ_AHB {
1284 #[doc = r"Returns a pointer to the register block"]
1285 #[inline(always)]
1286 pub const fn ptr() -> *const gpio_porta_ahb::RegisterBlock {
1287 0x4006_0000 as *const _
1288 }
1289}
1290impl Deref for GPIO_PORTJ_AHB {
1291 type Target = gpio_porta_ahb::RegisterBlock;
1292 #[inline(always)]
1293 fn deref(&self) -> &Self::Target {
1294 unsafe { &*GPIO_PORTJ_AHB::ptr() }
1295 }
1296}
1297#[doc = "GPIO register offsets"]
1298pub struct GPIO_PORTK {
1299 _marker: PhantomData<*const ()>,
1300}
1301unsafe impl Send for GPIO_PORTK {}
1302impl GPIO_PORTK {
1303 #[doc = r"Returns a pointer to the register block"]
1304 #[inline(always)]
1305 pub const fn ptr() -> *const gpio_porta_ahb::RegisterBlock {
1306 0x4006_1000 as *const _
1307 }
1308}
1309impl Deref for GPIO_PORTK {
1310 type Target = gpio_porta_ahb::RegisterBlock;
1311 #[inline(always)]
1312 fn deref(&self) -> &Self::Target {
1313 unsafe { &*GPIO_PORTK::ptr() }
1314 }
1315}
1316#[doc = "GPIO register offsets"]
1317pub struct GPIO_PORTL {
1318 _marker: PhantomData<*const ()>,
1319}
1320unsafe impl Send for GPIO_PORTL {}
1321impl GPIO_PORTL {
1322 #[doc = r"Returns a pointer to the register block"]
1323 #[inline(always)]
1324 pub const fn ptr() -> *const gpio_porta_ahb::RegisterBlock {
1325 0x4006_2000 as *const _
1326 }
1327}
1328impl Deref for GPIO_PORTL {
1329 type Target = gpio_porta_ahb::RegisterBlock;
1330 #[inline(always)]
1331 fn deref(&self) -> &Self::Target {
1332 unsafe { &*GPIO_PORTL::ptr() }
1333 }
1334}
1335#[doc = "GPIO register offsets"]
1336pub struct GPIO_PORTM {
1337 _marker: PhantomData<*const ()>,
1338}
1339unsafe impl Send for GPIO_PORTM {}
1340impl GPIO_PORTM {
1341 #[doc = r"Returns a pointer to the register block"]
1342 #[inline(always)]
1343 pub const fn ptr() -> *const gpio_porta_ahb::RegisterBlock {
1344 0x4006_3000 as *const _
1345 }
1346}
1347impl Deref for GPIO_PORTM {
1348 type Target = gpio_porta_ahb::RegisterBlock;
1349 #[inline(always)]
1350 fn deref(&self) -> &Self::Target {
1351 unsafe { &*GPIO_PORTM::ptr() }
1352 }
1353}
1354#[doc = "GPIO register offsets"]
1355pub struct GPIO_PORTN {
1356 _marker: PhantomData<*const ()>,
1357}
1358unsafe impl Send for GPIO_PORTN {}
1359impl GPIO_PORTN {
1360 #[doc = r"Returns a pointer to the register block"]
1361 #[inline(always)]
1362 pub const fn ptr() -> *const gpio_porta_ahb::RegisterBlock {
1363 0x4006_4000 as *const _
1364 }
1365}
1366impl Deref for GPIO_PORTN {
1367 type Target = gpio_porta_ahb::RegisterBlock;
1368 #[inline(always)]
1369 fn deref(&self) -> &Self::Target {
1370 unsafe { &*GPIO_PORTN::ptr() }
1371 }
1372}
1373#[doc = "GPIO register offsets"]
1374pub struct GPIO_PORTP {
1375 _marker: PhantomData<*const ()>,
1376}
1377unsafe impl Send for GPIO_PORTP {}
1378impl GPIO_PORTP {
1379 #[doc = r"Returns a pointer to the register block"]
1380 #[inline(always)]
1381 pub const fn ptr() -> *const gpio_porta_ahb::RegisterBlock {
1382 0x4006_5000 as *const _
1383 }
1384}
1385impl Deref for GPIO_PORTP {
1386 type Target = gpio_porta_ahb::RegisterBlock;
1387 #[inline(always)]
1388 fn deref(&self) -> &Self::Target {
1389 unsafe { &*GPIO_PORTP::ptr() }
1390 }
1391}
1392#[doc = "GPIO register offsets"]
1393pub struct GPIO_PORTQ {
1394 _marker: PhantomData<*const ()>,
1395}
1396unsafe impl Send for GPIO_PORTQ {}
1397impl GPIO_PORTQ {
1398 #[doc = r"Returns a pointer to the register block"]
1399 #[inline(always)]
1400 pub const fn ptr() -> *const gpio_porta_ahb::RegisterBlock {
1401 0x4006_6000 as *const _
1402 }
1403}
1404impl Deref for GPIO_PORTQ {
1405 type Target = gpio_porta_ahb::RegisterBlock;
1406 #[inline(always)]
1407 fn deref(&self) -> &Self::Target {
1408 unsafe { &*GPIO_PORTQ::ptr() }
1409 }
1410}
1411#[doc = "EEPROM register offsets"]
1412pub struct EEPROM {
1413 _marker: PhantomData<*const ()>,
1414}
1415unsafe impl Send for EEPROM {}
1416impl EEPROM {
1417 #[doc = r"Returns a pointer to the register block"]
1418 #[inline(always)]
1419 pub const fn ptr() -> *const eeprom::RegisterBlock {
1420 0x400a_f000 as *const _
1421 }
1422}
1423impl Deref for EEPROM {
1424 type Target = eeprom::RegisterBlock;
1425 #[inline(always)]
1426 fn deref(&self) -> &Self::Target {
1427 unsafe { &*EEPROM::ptr() }
1428 }
1429}
1430#[doc = "EEPROM register offsets"]
1431pub mod eeprom;
1432#[doc = "I2C register offsets"]
1433pub struct I2C8 {
1434 _marker: PhantomData<*const ()>,
1435}
1436unsafe impl Send for I2C8 {}
1437impl I2C8 {
1438 #[doc = r"Returns a pointer to the register block"]
1439 #[inline(always)]
1440 pub const fn ptr() -> *const i2c0::RegisterBlock {
1441 0x400b_8000 as *const _
1442 }
1443}
1444impl Deref for I2C8 {
1445 type Target = i2c0::RegisterBlock;
1446 #[inline(always)]
1447 fn deref(&self) -> &Self::Target {
1448 unsafe { &*I2C8::ptr() }
1449 }
1450}
1451#[doc = "I2C register offsets"]
1452pub struct I2C9 {
1453 _marker: PhantomData<*const ()>,
1454}
1455unsafe impl Send for I2C9 {}
1456impl I2C9 {
1457 #[doc = r"Returns a pointer to the register block"]
1458 #[inline(always)]
1459 pub const fn ptr() -> *const i2c0::RegisterBlock {
1460 0x400b_9000 as *const _
1461 }
1462}
1463impl Deref for I2C9 {
1464 type Target = i2c0::RegisterBlock;
1465 #[inline(always)]
1466 fn deref(&self) -> &Self::Target {
1467 unsafe { &*I2C9::ptr() }
1468 }
1469}
1470#[doc = "I2C register offsets"]
1471pub struct I2C4 {
1472 _marker: PhantomData<*const ()>,
1473}
1474unsafe impl Send for I2C4 {}
1475impl I2C4 {
1476 #[doc = r"Returns a pointer to the register block"]
1477 #[inline(always)]
1478 pub const fn ptr() -> *const i2c0::RegisterBlock {
1479 0x400c_0000 as *const _
1480 }
1481}
1482impl Deref for I2C4 {
1483 type Target = i2c0::RegisterBlock;
1484 #[inline(always)]
1485 fn deref(&self) -> &Self::Target {
1486 unsafe { &*I2C4::ptr() }
1487 }
1488}
1489#[doc = "I2C register offsets"]
1490pub struct I2C5 {
1491 _marker: PhantomData<*const ()>,
1492}
1493unsafe impl Send for I2C5 {}
1494impl I2C5 {
1495 #[doc = r"Returns a pointer to the register block"]
1496 #[inline(always)]
1497 pub const fn ptr() -> *const i2c0::RegisterBlock {
1498 0x400c_1000 as *const _
1499 }
1500}
1501impl Deref for I2C5 {
1502 type Target = i2c0::RegisterBlock;
1503 #[inline(always)]
1504 fn deref(&self) -> &Self::Target {
1505 unsafe { &*I2C5::ptr() }
1506 }
1507}
1508#[doc = "I2C register offsets"]
1509pub struct I2C6 {
1510 _marker: PhantomData<*const ()>,
1511}
1512unsafe impl Send for I2C6 {}
1513impl I2C6 {
1514 #[doc = r"Returns a pointer to the register block"]
1515 #[inline(always)]
1516 pub const fn ptr() -> *const i2c0::RegisterBlock {
1517 0x400c_2000 as *const _
1518 }
1519}
1520impl Deref for I2C6 {
1521 type Target = i2c0::RegisterBlock;
1522 #[inline(always)]
1523 fn deref(&self) -> &Self::Target {
1524 unsafe { &*I2C6::ptr() }
1525 }
1526}
1527#[doc = "I2C register offsets"]
1528pub struct I2C7 {
1529 _marker: PhantomData<*const ()>,
1530}
1531unsafe impl Send for I2C7 {}
1532impl I2C7 {
1533 #[doc = r"Returns a pointer to the register block"]
1534 #[inline(always)]
1535 pub const fn ptr() -> *const i2c0::RegisterBlock {
1536 0x400c_3000 as *const _
1537 }
1538}
1539impl Deref for I2C7 {
1540 type Target = i2c0::RegisterBlock;
1541 #[inline(always)]
1542 fn deref(&self) -> &Self::Target {
1543 unsafe { &*I2C7::ptr() }
1544 }
1545}
1546#[doc = "External Peripheral Interface register offsets"]
1547pub struct EPI0 {
1548 _marker: PhantomData<*const ()>,
1549}
1550unsafe impl Send for EPI0 {}
1551impl EPI0 {
1552 #[doc = r"Returns a pointer to the register block"]
1553 #[inline(always)]
1554 pub const fn ptr() -> *const epi0::RegisterBlock {
1555 0x400d_0000 as *const _
1556 }
1557}
1558impl Deref for EPI0 {
1559 type Target = epi0::RegisterBlock;
1560 #[inline(always)]
1561 fn deref(&self) -> &Self::Target {
1562 unsafe { &*EPI0::ptr() }
1563 }
1564}
1565#[doc = "External Peripheral Interface register offsets"]
1566pub mod epi0;
1567#[doc = "Timer register offsets"]
1568pub struct TIMER6 {
1569 _marker: PhantomData<*const ()>,
1570}
1571unsafe impl Send for TIMER6 {}
1572impl TIMER6 {
1573 #[doc = r"Returns a pointer to the register block"]
1574 #[inline(always)]
1575 pub const fn ptr() -> *const timer0::RegisterBlock {
1576 0x400e_0000 as *const _
1577 }
1578}
1579impl Deref for TIMER6 {
1580 type Target = timer0::RegisterBlock;
1581 #[inline(always)]
1582 fn deref(&self) -> &Self::Target {
1583 unsafe { &*TIMER6::ptr() }
1584 }
1585}
1586#[doc = "Timer register offsets"]
1587pub struct TIMER7 {
1588 _marker: PhantomData<*const ()>,
1589}
1590unsafe impl Send for TIMER7 {}
1591impl TIMER7 {
1592 #[doc = r"Returns a pointer to the register block"]
1593 #[inline(always)]
1594 pub const fn ptr() -> *const timer0::RegisterBlock {
1595 0x400e_1000 as *const _
1596 }
1597}
1598impl Deref for TIMER7 {
1599 type Target = timer0::RegisterBlock;
1600 #[inline(always)]
1601 fn deref(&self) -> &Self::Target {
1602 unsafe { &*TIMER7::ptr() }
1603 }
1604}
1605#[doc = "EMAC register offsets"]
1606pub struct EMAC0 {
1607 _marker: PhantomData<*const ()>,
1608}
1609unsafe impl Send for EMAC0 {}
1610impl EMAC0 {
1611 #[doc = r"Returns a pointer to the register block"]
1612 #[inline(always)]
1613 pub const fn ptr() -> *const emac0::RegisterBlock {
1614 0x400e_c000 as *const _
1615 }
1616}
1617impl Deref for EMAC0 {
1618 type Target = emac0::RegisterBlock;
1619 #[inline(always)]
1620 fn deref(&self) -> &Self::Target {
1621 unsafe { &*EMAC0::ptr() }
1622 }
1623}
1624#[doc = "EMAC register offsets"]
1625pub mod emac0;
1626#[doc = "System Exception Module register addresses"]
1627pub struct SYSEXC {
1628 _marker: PhantomData<*const ()>,
1629}
1630unsafe impl Send for SYSEXC {}
1631impl SYSEXC {
1632 #[doc = r"Returns a pointer to the register block"]
1633 #[inline(always)]
1634 pub const fn ptr() -> *const sysexc::RegisterBlock {
1635 0x400f_9000 as *const _
1636 }
1637}
1638impl Deref for SYSEXC {
1639 type Target = sysexc::RegisterBlock;
1640 #[inline(always)]
1641 fn deref(&self) -> &Self::Target {
1642 unsafe { &*SYSEXC::ptr() }
1643 }
1644}
1645#[doc = "System Exception Module register addresses"]
1646pub mod sysexc;
1647#[doc = "Hibernation module register addresses"]
1648pub struct HIB {
1649 _marker: PhantomData<*const ()>,
1650}
1651unsafe impl Send for HIB {}
1652impl HIB {
1653 #[doc = r"Returns a pointer to the register block"]
1654 #[inline(always)]
1655 pub const fn ptr() -> *const hib::RegisterBlock {
1656 0x400f_c000 as *const _
1657 }
1658}
1659impl Deref for HIB {
1660 type Target = hib::RegisterBlock;
1661 #[inline(always)]
1662 fn deref(&self) -> &Self::Target {
1663 unsafe { &*HIB::ptr() }
1664 }
1665}
1666#[doc = "Hibernation module register addresses"]
1667pub mod hib;
1668#[doc = "FLASH register offsets"]
1669pub struct FLASH_CTRL {
1670 _marker: PhantomData<*const ()>,
1671}
1672unsafe impl Send for FLASH_CTRL {}
1673impl FLASH_CTRL {
1674 #[doc = r"Returns a pointer to the register block"]
1675 #[inline(always)]
1676 pub const fn ptr() -> *const flash_ctrl::RegisterBlock {
1677 0x400f_d000 as *const _
1678 }
1679}
1680impl Deref for FLASH_CTRL {
1681 type Target = flash_ctrl::RegisterBlock;
1682 #[inline(always)]
1683 fn deref(&self) -> &Self::Target {
1684 unsafe { &*FLASH_CTRL::ptr() }
1685 }
1686}
1687#[doc = "FLASH register offsets"]
1688pub mod flash_ctrl;
1689#[doc = "System Control register addresses"]
1690pub struct SYSCTL {
1691 _marker: PhantomData<*const ()>,
1692}
1693unsafe impl Send for SYSCTL {}
1694impl SYSCTL {
1695 #[doc = r"Returns a pointer to the register block"]
1696 #[inline(always)]
1697 pub const fn ptr() -> *const sysctl::RegisterBlock {
1698 0x400f_e000 as *const _
1699 }
1700}
1701impl Deref for SYSCTL {
1702 type Target = sysctl::RegisterBlock;
1703 #[inline(always)]
1704 fn deref(&self) -> &Self::Target {
1705 unsafe { &*SYSCTL::ptr() }
1706 }
1707}
1708#[doc = "System Control register addresses"]
1709pub mod sysctl;
1710#[doc = "Micro Direct Memory Access register addresses"]
1711pub struct UDMA {
1712 _marker: PhantomData<*const ()>,
1713}
1714unsafe impl Send for UDMA {}
1715impl UDMA {
1716 #[doc = r"Returns a pointer to the register block"]
1717 #[inline(always)]
1718 pub const fn ptr() -> *const udma::RegisterBlock {
1719 0x400f_f000 as *const _
1720 }
1721}
1722impl Deref for UDMA {
1723 type Target = udma::RegisterBlock;
1724 #[inline(always)]
1725 fn deref(&self) -> &Self::Target {
1726 unsafe { &*UDMA::ptr() }
1727 }
1728}
1729#[doc = "Micro Direct Memory Access register addresses"]
1730pub mod udma;
1731#[doc = "EC register offsets"]
1732pub struct CCM0 {
1733 _marker: PhantomData<*const ()>,
1734}
1735unsafe impl Send for CCM0 {}
1736impl CCM0 {
1737 #[doc = r"Returns a pointer to the register block"]
1738 #[inline(always)]
1739 pub const fn ptr() -> *const ccm0::RegisterBlock {
1740 0x4403_0000 as *const _
1741 }
1742}
1743impl Deref for CCM0 {
1744 type Target = ccm0::RegisterBlock;
1745 #[inline(always)]
1746 fn deref(&self) -> &Self::Target {
1747 unsafe { &*CCM0::ptr() }
1748 }
1749}
1750#[doc = "EC register offsets"]
1751pub mod ccm0;
1752#[no_mangle]
1753static mut DEVICE_PERIPHERALS: bool = false;
1754#[doc = r"All the peripherals"]
1755#[allow(non_snake_case)]
1756pub struct Peripherals {
1757 #[doc = "WATCHDOG0"]
1758 pub WATCHDOG0: WATCHDOG0,
1759 #[doc = "WATCHDOG1"]
1760 pub WATCHDOG1: WATCHDOG1,
1761 #[doc = "SSI0"]
1762 pub SSI0: SSI0,
1763 #[doc = "SSI1"]
1764 pub SSI1: SSI1,
1765 #[doc = "SSI2"]
1766 pub SSI2: SSI2,
1767 #[doc = "SSI3"]
1768 pub SSI3: SSI3,
1769 #[doc = "UART0"]
1770 pub UART0: UART0,
1771 #[doc = "UART1"]
1772 pub UART1: UART1,
1773 #[doc = "UART2"]
1774 pub UART2: UART2,
1775 #[doc = "UART3"]
1776 pub UART3: UART3,
1777 #[doc = "UART4"]
1778 pub UART4: UART4,
1779 #[doc = "UART5"]
1780 pub UART5: UART5,
1781 #[doc = "UART6"]
1782 pub UART6: UART6,
1783 #[doc = "UART7"]
1784 pub UART7: UART7,
1785 #[doc = "I2C0"]
1786 pub I2C0: I2C0,
1787 #[doc = "I2C1"]
1788 pub I2C1: I2C1,
1789 #[doc = "I2C2"]
1790 pub I2C2: I2C2,
1791 #[doc = "I2C3"]
1792 pub I2C3: I2C3,
1793 #[doc = "PWM0"]
1794 pub PWM0: PWM0,
1795 #[doc = "QEI0"]
1796 pub QEI0: QEI0,
1797 #[doc = "TIMER0"]
1798 pub TIMER0: TIMER0,
1799 #[doc = "TIMER1"]
1800 pub TIMER1: TIMER1,
1801 #[doc = "TIMER2"]
1802 pub TIMER2: TIMER2,
1803 #[doc = "TIMER3"]
1804 pub TIMER3: TIMER3,
1805 #[doc = "TIMER4"]
1806 pub TIMER4: TIMER4,
1807 #[doc = "TIMER5"]
1808 pub TIMER5: TIMER5,
1809 #[doc = "ADC0"]
1810 pub ADC0: ADC0,
1811 #[doc = "ADC1"]
1812 pub ADC1: ADC1,
1813 #[doc = "COMP"]
1814 pub COMP: COMP,
1815 #[doc = "CAN0"]
1816 pub CAN0: CAN0,
1817 #[doc = "CAN1"]
1818 pub CAN1: CAN1,
1819 #[doc = "USB0"]
1820 pub USB0: USB0,
1821 #[doc = "GPIO_PORTA_AHB"]
1822 pub GPIO_PORTA_AHB: GPIO_PORTA_AHB,
1823 #[doc = "GPIO_PORTB_AHB"]
1824 pub GPIO_PORTB_AHB: GPIO_PORTB_AHB,
1825 #[doc = "GPIO_PORTC_AHB"]
1826 pub GPIO_PORTC_AHB: GPIO_PORTC_AHB,
1827 #[doc = "GPIO_PORTD_AHB"]
1828 pub GPIO_PORTD_AHB: GPIO_PORTD_AHB,
1829 #[doc = "GPIO_PORTE_AHB"]
1830 pub GPIO_PORTE_AHB: GPIO_PORTE_AHB,
1831 #[doc = "GPIO_PORTF_AHB"]
1832 pub GPIO_PORTF_AHB: GPIO_PORTF_AHB,
1833 #[doc = "GPIO_PORTG_AHB"]
1834 pub GPIO_PORTG_AHB: GPIO_PORTG_AHB,
1835 #[doc = "GPIO_PORTH_AHB"]
1836 pub GPIO_PORTH_AHB: GPIO_PORTH_AHB,
1837 #[doc = "GPIO_PORTJ_AHB"]
1838 pub GPIO_PORTJ_AHB: GPIO_PORTJ_AHB,
1839 #[doc = "GPIO_PORTK"]
1840 pub GPIO_PORTK: GPIO_PORTK,
1841 #[doc = "GPIO_PORTL"]
1842 pub GPIO_PORTL: GPIO_PORTL,
1843 #[doc = "GPIO_PORTM"]
1844 pub GPIO_PORTM: GPIO_PORTM,
1845 #[doc = "GPIO_PORTN"]
1846 pub GPIO_PORTN: GPIO_PORTN,
1847 #[doc = "GPIO_PORTP"]
1848 pub GPIO_PORTP: GPIO_PORTP,
1849 #[doc = "GPIO_PORTQ"]
1850 pub GPIO_PORTQ: GPIO_PORTQ,
1851 #[doc = "EEPROM"]
1852 pub EEPROM: EEPROM,
1853 #[doc = "I2C8"]
1854 pub I2C8: I2C8,
1855 #[doc = "I2C9"]
1856 pub I2C9: I2C9,
1857 #[doc = "I2C4"]
1858 pub I2C4: I2C4,
1859 #[doc = "I2C5"]
1860 pub I2C5: I2C5,
1861 #[doc = "I2C6"]
1862 pub I2C6: I2C6,
1863 #[doc = "I2C7"]
1864 pub I2C7: I2C7,
1865 #[doc = "EPI0"]
1866 pub EPI0: EPI0,
1867 #[doc = "TIMER6"]
1868 pub TIMER6: TIMER6,
1869 #[doc = "TIMER7"]
1870 pub TIMER7: TIMER7,
1871 #[doc = "EMAC0"]
1872 pub EMAC0: EMAC0,
1873 #[doc = "SYSEXC"]
1874 pub SYSEXC: SYSEXC,
1875 #[doc = "HIB"]
1876 pub HIB: HIB,
1877 #[doc = "FLASH_CTRL"]
1878 pub FLASH_CTRL: FLASH_CTRL,
1879 #[doc = "SYSCTL"]
1880 pub SYSCTL: SYSCTL,
1881 #[doc = "UDMA"]
1882 pub UDMA: UDMA,
1883 #[doc = "CCM0"]
1884 pub CCM0: CCM0,
1885}
1886impl Peripherals {
1887 #[doc = r"Returns all the peripherals *once*"]
1888 #[inline]
1889 pub fn take() -> Option<Self> {
1890 cortex_m::interrupt::free(|_| if unsafe { DEVICE_PERIPHERALS } { None } else { Some(unsafe { Peripherals::steal() }) })
1891 }
1892 #[doc = r"Unchecked version of `Peripherals::take`"]
1893 #[inline]
1894 pub unsafe fn steal() -> Self {
1895 DEVICE_PERIPHERALS = true;
1896 Peripherals {
1897 WATCHDOG0: WATCHDOG0 { _marker: PhantomData },
1898 WATCHDOG1: WATCHDOG1 { _marker: PhantomData },
1899 SSI0: SSI0 { _marker: PhantomData },
1900 SSI1: SSI1 { _marker: PhantomData },
1901 SSI2: SSI2 { _marker: PhantomData },
1902 SSI3: SSI3 { _marker: PhantomData },
1903 UART0: UART0 { _marker: PhantomData },
1904 UART1: UART1 { _marker: PhantomData },
1905 UART2: UART2 { _marker: PhantomData },
1906 UART3: UART3 { _marker: PhantomData },
1907 UART4: UART4 { _marker: PhantomData },
1908 UART5: UART5 { _marker: PhantomData },
1909 UART6: UART6 { _marker: PhantomData },
1910 UART7: UART7 { _marker: PhantomData },
1911 I2C0: I2C0 { _marker: PhantomData },
1912 I2C1: I2C1 { _marker: PhantomData },
1913 I2C2: I2C2 { _marker: PhantomData },
1914 I2C3: I2C3 { _marker: PhantomData },
1915 PWM0: PWM0 { _marker: PhantomData },
1916 QEI0: QEI0 { _marker: PhantomData },
1917 TIMER0: TIMER0 { _marker: PhantomData },
1918 TIMER1: TIMER1 { _marker: PhantomData },
1919 TIMER2: TIMER2 { _marker: PhantomData },
1920 TIMER3: TIMER3 { _marker: PhantomData },
1921 TIMER4: TIMER4 { _marker: PhantomData },
1922 TIMER5: TIMER5 { _marker: PhantomData },
1923 ADC0: ADC0 { _marker: PhantomData },
1924 ADC1: ADC1 { _marker: PhantomData },
1925 COMP: COMP { _marker: PhantomData },
1926 CAN0: CAN0 { _marker: PhantomData },
1927 CAN1: CAN1 { _marker: PhantomData },
1928 USB0: USB0 { _marker: PhantomData },
1929 GPIO_PORTA_AHB: GPIO_PORTA_AHB { _marker: PhantomData },
1930 GPIO_PORTB_AHB: GPIO_PORTB_AHB { _marker: PhantomData },
1931 GPIO_PORTC_AHB: GPIO_PORTC_AHB { _marker: PhantomData },
1932 GPIO_PORTD_AHB: GPIO_PORTD_AHB { _marker: PhantomData },
1933 GPIO_PORTE_AHB: GPIO_PORTE_AHB { _marker: PhantomData },
1934 GPIO_PORTF_AHB: GPIO_PORTF_AHB { _marker: PhantomData },
1935 GPIO_PORTG_AHB: GPIO_PORTG_AHB { _marker: PhantomData },
1936 GPIO_PORTH_AHB: GPIO_PORTH_AHB { _marker: PhantomData },
1937 GPIO_PORTJ_AHB: GPIO_PORTJ_AHB { _marker: PhantomData },
1938 GPIO_PORTK: GPIO_PORTK { _marker: PhantomData },
1939 GPIO_PORTL: GPIO_PORTL { _marker: PhantomData },
1940 GPIO_PORTM: GPIO_PORTM { _marker: PhantomData },
1941 GPIO_PORTN: GPIO_PORTN { _marker: PhantomData },
1942 GPIO_PORTP: GPIO_PORTP { _marker: PhantomData },
1943 GPIO_PORTQ: GPIO_PORTQ { _marker: PhantomData },
1944 EEPROM: EEPROM { _marker: PhantomData },
1945 I2C8: I2C8 { _marker: PhantomData },
1946 I2C9: I2C9 { _marker: PhantomData },
1947 I2C4: I2C4 { _marker: PhantomData },
1948 I2C5: I2C5 { _marker: PhantomData },
1949 I2C6: I2C6 { _marker: PhantomData },
1950 I2C7: I2C7 { _marker: PhantomData },
1951 EPI0: EPI0 { _marker: PhantomData },
1952 TIMER6: TIMER6 { _marker: PhantomData },
1953 TIMER7: TIMER7 { _marker: PhantomData },
1954 EMAC0: EMAC0 { _marker: PhantomData },
1955 SYSEXC: SYSEXC { _marker: PhantomData },
1956 HIB: HIB { _marker: PhantomData },
1957 FLASH_CTRL: FLASH_CTRL { _marker: PhantomData },
1958 SYSCTL: SYSCTL { _marker: PhantomData },
1959 UDMA: UDMA { _marker: PhantomData },
1960 CCM0: CCM0 { _marker: PhantomData },
1961 }
1962 }
1963}