1#![doc = "Peripheral access API for CC2650F128 microcontrollers (generated using svd2rust v0.14.0)\n\nYou can find an overview of the API [here].\n\n[here]: https://docs.rs/svd2rust/0.14.0/svd2rust/#peripheral-api"]
2#![deny(missing_docs)]
3#![deny(warnings)]
4#![allow(non_camel_case_types)]
5#![no_std]
6extern crate bare_metal;
7extern crate cortex_m;
8#[cfg(feature = "rt")]
9extern crate cortex_m_rt;
10extern crate vcell;
11use core::marker::PhantomData;
12use core::ops::Deref;
13#[cfg(feature = "rt")]
14extern "C" {
15 fn GPIO();
16 fn I2C();
17 fn RFC_PE0();
18 fn AON_RTC();
19 fn UART0();
20 fn UART1();
21 fn SSI0();
22 fn SSI1();
23 fn RFC_PE1();
24 fn RFC();
25 fn RFC_CA();
26 fn I2S();
27 fn WDT();
28 fn GPT0A();
29 fn GPT0B();
30 fn GPT1A();
31 fn GPT1B();
32 fn GPT2A();
33 fn GPT2B();
34 fn GPT3A();
35 fn GPT3B();
36 fn CRYPTO();
37 fn UDMA();
38 fn UDMA_ERR();
39 fn FLASH();
40 fn SWE0();
41 fn AUX_CE();
42 fn AON_EVENT();
43 fn DYN_EVENT();
44 fn AUX_COMPA();
45 fn AUX_MISC();
46 fn TRNG();
47}
48#[doc(hidden)]
49pub union Vector {
50 _handler: unsafe extern "C" fn(),
51 _reserved: u32,
52}
53#[cfg(feature = "rt")]
54#[doc(hidden)]
55#[link_section = ".vector_table.interrupts"]
56#[no_mangle]
57pub static __INTERRUPTS: [Vector; 34] = [Vector { _handler: GPIO }, Vector { _handler: I2C }, Vector { _handler: RFC_PE0 }, Vector { _reserved: 0 }, Vector { _handler: AON_RTC }, Vector { _handler: UART0 }, Vector { _handler: UART1 }, Vector { _handler: SSI0 }, Vector { _handler: SSI1 }, Vector { _handler: RFC_PE1 }, Vector { _handler: RFC }, Vector { _handler: RFC_CA }, Vector { _handler: I2S }, Vector { _reserved: 0 }, Vector { _handler: WDT }, Vector { _handler: GPT0A }, Vector { _handler: GPT0B }, Vector { _handler: GPT1A }, Vector { _handler: GPT1B }, Vector { _handler: GPT2A }, Vector { _handler: GPT2B }, Vector { _handler: GPT3A }, Vector { _handler: GPT3B }, Vector { _handler: CRYPTO }, Vector { _handler: UDMA }, Vector { _handler: UDMA_ERR }, Vector { _handler: FLASH }, Vector { _handler: SWE0 }, Vector { _handler: AUX_CE }, Vector { _handler: AON_EVENT }, Vector { _handler: DYN_EVENT }, Vector { _handler: AUX_COMPA }, Vector { _handler: AUX_MISC }, Vector { _handler: TRNG }];
58#[doc = r" Enumeration of all the interrupts"]
59#[derive(Copy, Clone, Debug)]
60pub enum Interrupt {
61 #[doc = "0 - GPIO edge detect"]
62 GPIO,
63 #[doc = "1 - I2C"]
64 I2C,
65 #[doc = "2 - RF Core and packet engine 1"]
66 RFC_PE0,
67 #[doc = "4 - AON RTC"]
68 AON_RTC,
69 #[doc = "5 - UART0"]
70 UART0,
71 #[doc = "6 - UART1"]
72 UART1,
73 #[doc = "7 - SSI0"]
74 SSI0,
75 #[doc = "8 - SSI1"]
76 SSI1,
77 #[doc = "9 - RF Core and packet engine 2"]
78 RFC_PE1,
79 #[doc = "10 - RF Core hardware"]
80 RFC,
81 #[doc = "11 - RF command acknowledge"]
82 RFC_CA,
83 #[doc = "12 - I2S"]
84 I2S,
85 #[doc = "14 - Watchdog timer"]
86 WDT,
87 #[doc = "15 - GPTimer 0A"]
88 GPT0A,
89 #[doc = "16 - GPTimer 0B"]
90 GPT0B,
91 #[doc = "17 - GPTimer 1A"]
92 GPT1A,
93 #[doc = "18 - GPTimer 1B"]
94 GPT1B,
95 #[doc = "19 - GPTimer 2A"]
96 GPT2A,
97 #[doc = "20 - GPTimer 2B"]
98 GPT2B,
99 #[doc = "21 - GPTimer 3A"]
100 GPT3A,
101 #[doc = "22 - GPTimer 3B"]
102 GPT3B,
103 #[doc = "23 - Crypto"]
104 CRYPTO,
105 #[doc = "24 - \u{3bc}DMA software defined"]
106 UDMA,
107 #[doc = "25 - \u{3bc}DMA error"]
108 UDMA_ERR,
109 #[doc = "26 - Flash"]
110 FLASH,
111 #[doc = "27 - Software event 0"]
112 SWE0,
113 #[doc = "28 - AUX combined event"]
114 AUX_CE,
115 #[doc = "29 - AON programmable event"]
116 AON_EVENT,
117 #[doc = "30 - Dynamic programmable event"]
118 DYN_EVENT,
119 #[doc = "31 - AUX comparator A"]
120 AUX_COMPA,
121 #[doc = "32 - AUX ADC new sample available or ADC DMA done, ADC underflow and overflow"]
122 AUX_MISC,
123 #[doc = "33 - True random number generator"]
124 TRNG,
125}
126unsafe impl ::bare_metal::Nr for Interrupt {
127 #[inline]
128 fn nr(&self) -> u8 {
129 match *self {
130 Interrupt::GPIO => 0,
131 Interrupt::I2C => 1,
132 Interrupt::RFC_PE0 => 2,
133 Interrupt::AON_RTC => 4,
134 Interrupt::UART0 => 5,
135 Interrupt::UART1 => 6,
136 Interrupt::SSI0 => 7,
137 Interrupt::SSI1 => 8,
138 Interrupt::RFC_PE1 => 9,
139 Interrupt::RFC => 10,
140 Interrupt::RFC_CA => 11,
141 Interrupt::I2S => 12,
142 Interrupt::WDT => 14,
143 Interrupt::GPT0A => 15,
144 Interrupt::GPT0B => 16,
145 Interrupt::GPT1A => 17,
146 Interrupt::GPT1B => 18,
147 Interrupt::GPT2A => 19,
148 Interrupt::GPT2B => 20,
149 Interrupt::GPT3A => 21,
150 Interrupt::GPT3B => 22,
151 Interrupt::CRYPTO => 23,
152 Interrupt::UDMA => 24,
153 Interrupt::UDMA_ERR => 25,
154 Interrupt::FLASH => 26,
155 Interrupt::SWE0 => 27,
156 Interrupt::AUX_CE => 28,
157 Interrupt::AON_EVENT => 29,
158 Interrupt::DYN_EVENT => 30,
159 Interrupt::AUX_COMPA => 31,
160 Interrupt::AUX_MISC => 32,
161 Interrupt::TRNG => 33,
162 }
163 }
164}
165#[cfg(feature = "rt")]
166pub use self::Interrupt as interrupt;
167pub use cortex_m::peripheral::Peripherals as CorePeripherals;
168pub use cortex_m::peripheral::{CBP, CPUID, DCB, DWT, FPB, FPU, ITM, MPU, NVIC, SCB, SYST, TPIU};
169#[cfg(feature = "rt")]
170pub use cortex_m_rt::interrupt;
171#[doc = "Always On (AON) Battery And Temperature MONitor (BATMON) residing in the AON domain Note: This module only supports 32 bit Read/Write access from MCU."]
172pub struct AON_BATMON {
173 _marker: PhantomData<*const ()>,
174}
175unsafe impl Send for AON_BATMON {}
176impl AON_BATMON {
177 #[doc = r" Returns a pointer to the register block"]
178 pub fn ptr() -> *const aon_batmon::RegisterBlock {
179 1074352128 as *const _
180 }
181}
182impl Deref for AON_BATMON {
183 type Target = aon_batmon::RegisterBlock;
184 fn deref(&self) -> &aon_batmon::RegisterBlock {
185 unsafe { &*AON_BATMON::ptr() }
186 }
187}
188#[doc = "Always On (AON) Battery And Temperature MONitor (BATMON) residing in the AON domain Note: This module only supports 32 bit Read/Write access from MCU."]
189pub mod aon_batmon;
190#[doc = "This module configures the event fabric located in the AON domain. Note: This module is only supporting 32 bit ReadWrite access from MCU"]
191pub struct AON_EVENT {
192 _marker: PhantomData<*const ()>,
193}
194unsafe impl Send for AON_EVENT {}
195impl AON_EVENT {
196 #[doc = r" Returns a pointer to the register block"]
197 pub fn ptr() -> *const aon_event::RegisterBlock {
198 1074343936 as *const _
199 }
200}
201impl Deref for AON_EVENT {
202 type Target = aon_event::RegisterBlock;
203 fn deref(&self) -> &aon_event::RegisterBlock {
204 unsafe { &*AON_EVENT::ptr() }
205 }
206}
207#[doc = "This module configures the event fabric located in the AON domain. Note: This module is only supporting 32 bit ReadWrite access from MCU"]
208pub mod aon_event;
209#[doc = "Always On (AON) IO Controller - controls IO operation when the MCU IO Controller (IOC) is powered off and resides in the AON domain. Note: This module only supports 32 bit Read/Write access from MCU."]
210pub struct AON_IOC {
211 _marker: PhantomData<*const ()>,
212}
213unsafe impl Send for AON_IOC {}
214impl AON_IOC {
215 #[doc = r" Returns a pointer to the register block"]
216 pub fn ptr() -> *const aon_ioc::RegisterBlock {
217 1074348032 as *const _
218 }
219}
220impl Deref for AON_IOC {
221 type Target = aon_ioc::RegisterBlock;
222 fn deref(&self) -> &aon_ioc::RegisterBlock {
223 unsafe { &*AON_IOC::ptr() }
224 }
225}
226#[doc = "Always On (AON) IO Controller - controls IO operation when the MCU IO Controller (IOC) is powered off and resides in the AON domain. Note: This module only supports 32 bit Read/Write access from MCU."]
227pub mod aon_ioc;
228#[doc = "This component control the Real Time Clock residing in AON Note: This module is only supporting 32 bit ReadWrite access."]
229pub struct AON_RTC {
230 _marker: PhantomData<*const ()>,
231}
232unsafe impl Send for AON_RTC {}
233impl AON_RTC {
234 #[doc = r" Returns a pointer to the register block"]
235 pub fn ptr() -> *const aon_rtc::RegisterBlock {
236 1074339840 as *const _
237 }
238}
239impl Deref for AON_RTC {
240 type Target = aon_rtc::RegisterBlock;
241 fn deref(&self) -> &aon_rtc::RegisterBlock {
242 unsafe { &*AON_RTC::ptr() }
243 }
244}
245#[doc = "This component control the Real Time Clock residing in AON Note: This module is only supporting 32 bit ReadWrite access."]
246pub mod aon_rtc;
247#[doc = "This component controls AON_SYSCTL, which is the device's system controller. Note: This module is only supporting 32 bit ReadWrite access from MCU"]
248pub struct AON_SYSCTL {
249 _marker: PhantomData<*const ()>,
250}
251unsafe impl Send for AON_SYSCTL {}
252impl AON_SYSCTL {
253 #[doc = r" Returns a pointer to the register block"]
254 pub fn ptr() -> *const aon_sysctl::RegisterBlock {
255 1074331648 as *const _
256 }
257}
258impl Deref for AON_SYSCTL {
259 type Target = aon_sysctl::RegisterBlock;
260 fn deref(&self) -> &aon_sysctl::RegisterBlock {
261 unsafe { &*AON_SYSCTL::ptr() }
262 }
263}
264#[doc = "This component controls AON_SYSCTL, which is the device's system controller. Note: This module is only supporting 32 bit ReadWrite access from MCU"]
265pub mod aon_sysctl;
266#[doc = "This component control the Wakeup controller residing in the AON domain. Note: This module is only supporting 32 bit ReadWrite access from MCU"]
267pub struct AON_WUC {
268 _marker: PhantomData<*const ()>,
269}
270unsafe impl Send for AON_WUC {}
271impl AON_WUC {
272 #[doc = r" Returns a pointer to the register block"]
273 pub fn ptr() -> *const aon_wuc::RegisterBlock {
274 1074335744 as *const _
275 }
276}
277impl Deref for AON_WUC {
278 type Target = aon_wuc::RegisterBlock;
279 fn deref(&self) -> &aon_wuc::RegisterBlock {
280 unsafe { &*AON_WUC::ptr() }
281 }
282}
283#[doc = "This component control the Wakeup controller residing in the AON domain. Note: This module is only supporting 32 bit ReadWrite access from MCU"]
284pub mod aon_wuc;
285#[doc = "Configuration registers controlling analog peripherals of AUX. Registers Fields should be considered static unless otherwise noted (as dynamic)"]
286pub struct AUX_ADI4 {
287 _marker: PhantomData<*const ()>,
288}
289unsafe impl Send for AUX_ADI4 {}
290impl AUX_ADI4 {
291 #[doc = r" Returns a pointer to the register block"]
292 pub fn ptr() -> *const aux_adi4::RegisterBlock {
293 1074573312 as *const _
294 }
295}
296impl Deref for AUX_ADI4 {
297 type Target = aux_adi4::RegisterBlock;
298 fn deref(&self) -> &aux_adi4::RegisterBlock {
299 unsafe { &*AUX_ADI4::ptr() }
300 }
301}
302#[doc = "Configuration registers controlling analog peripherals of AUX. Registers Fields should be considered static unless otherwise noted (as dynamic)"]
303pub mod aux_adi4;
304#[doc = "AUX Analog/Digital Input Output Controller"]
305pub struct AUX_AIODIO0 {
306 _marker: PhantomData<*const ()>,
307}
308unsafe impl Send for AUX_AIODIO0 {}
309impl AUX_AIODIO0 {
310 #[doc = r" Returns a pointer to the register block"]
311 pub fn ptr() -> *const aux_aiodio0::RegisterBlock {
312 1074532352 as *const _
313 }
314}
315impl Deref for AUX_AIODIO0 {
316 type Target = aux_aiodio0::RegisterBlock;
317 fn deref(&self) -> &aux_aiodio0::RegisterBlock {
318 unsafe { &*AUX_AIODIO0::ptr() }
319 }
320}
321#[doc = "AUX Analog/Digital Input Output Controller"]
322pub mod aux_aiodio0;
323#[doc = "AUX_AIODIO1"]
324pub struct AUX_AIODIO1 {
325 _marker: PhantomData<*const ()>,
326}
327unsafe impl Send for AUX_AIODIO1 {}
328impl AUX_AIODIO1 {
329 #[doc = r" Returns a pointer to the register block"]
330 pub fn ptr() -> *const aux_aiodio0::RegisterBlock {
331 1074536448 as *const _
332 }
333}
334impl Deref for AUX_AIODIO1 {
335 type Target = aux_aiodio0::RegisterBlock;
336 fn deref(&self) -> &aux_aiodio0::RegisterBlock {
337 unsafe { &*AUX_AIODIO1::ptr() }
338 }
339}
340#[doc = "AUX Analog Peripheral Control Module"]
341pub struct AUX_ANAIF {
342 _marker: PhantomData<*const ()>,
343}
344unsafe impl Send for AUX_ANAIF {}
345impl AUX_ANAIF {
346 #[doc = r" Returns a pointer to the register block"]
347 pub fn ptr() -> *const aux_anaif::RegisterBlock {
348 1074565120 as *const _
349 }
350}
351impl Deref for AUX_ANAIF {
352 type Target = aux_anaif::RegisterBlock;
353 fn deref(&self) -> &aux_anaif::RegisterBlock {
354 unsafe { &*AUX_ANAIF::ptr() }
355 }
356}
357#[doc = "AUX Analog Peripheral Control Module"]
358pub mod aux_anaif;
359#[doc = "This is the DDI for the digital block that controls all the analog clock oscillators (OSC_DIG) and performs qualification of the clocks generated."]
360pub struct AUX_DDI0_OSC {
361 _marker: PhantomData<*const ()>,
362}
363unsafe impl Send for AUX_DDI0_OSC {}
364impl AUX_DDI0_OSC {
365 #[doc = r" Returns a pointer to the register block"]
366 pub fn ptr() -> *const aux_ddi0_osc::RegisterBlock {
367 1074569216 as *const _
368 }
369}
370impl Deref for AUX_DDI0_OSC {
371 type Target = aux_ddi0_osc::RegisterBlock;
372 fn deref(&self) -> &aux_ddi0_osc::RegisterBlock {
373 unsafe { &*AUX_DDI0_OSC::ptr() }
374 }
375}
376#[doc = "This is the DDI for the digital block that controls all the analog clock oscillators (OSC_DIG) and performs qualification of the clocks generated."]
377pub mod aux_ddi0_osc;
378#[doc = "AUX Event Controller"]
379pub struct AUX_EVCTL {
380 _marker: PhantomData<*const ()>,
381}
382unsafe impl Send for AUX_EVCTL {}
383impl AUX_EVCTL {
384 #[doc = r" Returns a pointer to the register block"]
385 pub fn ptr() -> *const aux_evctl::RegisterBlock {
386 1074548736 as *const _
387 }
388}
389impl Deref for AUX_EVCTL {
390 type Target = aux_evctl::RegisterBlock;
391 fn deref(&self) -> &aux_evctl::RegisterBlock {
392 unsafe { &*AUX_EVCTL::ptr() }
393 }
394}
395#[doc = "AUX Event Controller"]
396pub mod aux_evctl;
397#[doc = "AUX Sensor Control Engine Control Module"]
398pub struct AUX_SCE {
399 _marker: PhantomData<*const ()>,
400}
401unsafe impl Send for AUX_SCE {}
402impl AUX_SCE {
403 #[doc = r" Returns a pointer to the register block"]
404 pub fn ptr() -> *const aux_sce::RegisterBlock {
405 1074663424 as *const _
406 }
407}
408impl Deref for AUX_SCE {
409 type Target = aux_sce::RegisterBlock;
410 fn deref(&self) -> &aux_sce::RegisterBlock {
411 unsafe { &*AUX_SCE::ptr() }
412 }
413}
414#[doc = "AUX Sensor Control Engine Control Module"]
415pub mod aux_sce;
416#[doc = "AUX Semaphore Controller"]
417pub struct AUX_SMPH {
418 _marker: PhantomData<*const ()>,
419}
420unsafe impl Send for AUX_SMPH {}
421impl AUX_SMPH {
422 #[doc = r" Returns a pointer to the register block"]
423 pub fn ptr() -> *const aux_smph::RegisterBlock {
424 1074561024 as *const _
425 }
426}
427impl Deref for AUX_SMPH {
428 type Target = aux_smph::RegisterBlock;
429 fn deref(&self) -> &aux_smph::RegisterBlock {
430 unsafe { &*AUX_SMPH::ptr() }
431 }
432}
433#[doc = "AUX Semaphore Controller"]
434pub mod aux_smph;
435#[doc = "AUX Time To Digital Converter"]
436pub struct AUX_TDCIF {
437 _marker: PhantomData<*const ()>,
438}
439unsafe impl Send for AUX_TDCIF {}
440impl AUX_TDCIF {
441 #[doc = r" Returns a pointer to the register block"]
442 pub fn ptr() -> *const aux_tdcif::RegisterBlock {
443 1074544640 as *const _
444 }
445}
446impl Deref for AUX_TDCIF {
447 type Target = aux_tdcif::RegisterBlock;
448 fn deref(&self) -> &aux_tdcif::RegisterBlock {
449 unsafe { &*AUX_TDCIF::ptr() }
450 }
451}
452#[doc = "AUX Time To Digital Converter"]
453pub mod aux_tdcif;
454#[doc = "AUX Timer"]
455pub struct AUX_TIMER {
456 _marker: PhantomData<*const ()>,
457}
458unsafe impl Send for AUX_TIMER {}
459impl AUX_TIMER {
460 #[doc = r" Returns a pointer to the register block"]
461 pub fn ptr() -> *const aux_timer::RegisterBlock {
462 1074556928 as *const _
463 }
464}
465impl Deref for AUX_TIMER {
466 type Target = aux_timer::RegisterBlock;
467 fn deref(&self) -> &aux_timer::RegisterBlock {
468 unsafe { &*AUX_TIMER::ptr() }
469 }
470}
471#[doc = "AUX Timer"]
472pub mod aux_timer;
473#[doc = "AUX Wake-up controller"]
474pub struct AUX_WUC {
475 _marker: PhantomData<*const ()>,
476}
477unsafe impl Send for AUX_WUC {}
478impl AUX_WUC {
479 #[doc = r" Returns a pointer to the register block"]
480 pub fn ptr() -> *const aux_wuc::RegisterBlock {
481 1074552832 as *const _
482 }
483}
484impl Deref for AUX_WUC {
485 type Target = aux_wuc::RegisterBlock;
486 fn deref(&self) -> &aux_wuc::RegisterBlock {
487 unsafe { &*AUX_WUC::ptr() }
488 }
489}
490#[doc = "AUX Wake-up controller"]
491pub mod aux_wuc;
492#[doc = "Customer configuration area (CCFG)"]
493pub struct CCFG {
494 _marker: PhantomData<*const ()>,
495}
496unsafe impl Send for CCFG {}
497impl CCFG {
498 #[doc = r" Returns a pointer to the register block"]
499 pub fn ptr() -> *const ccfg::RegisterBlock {
500 1342189568 as *const _
501 }
502}
503impl Deref for CCFG {
504 type Target = ccfg::RegisterBlock;
505 fn deref(&self) -> &ccfg::RegisterBlock {
506 unsafe { &*CCFG::ptr() }
507 }
508}
509#[doc = "Customer configuration area (CCFG)"]
510pub mod ccfg;
511#[doc = "Cortex-M's Data watchpoint and Trace (DWT)"]
512pub struct CPU_DWT {
513 _marker: PhantomData<*const ()>,
514}
515unsafe impl Send for CPU_DWT {}
516impl CPU_DWT {
517 #[doc = r" Returns a pointer to the register block"]
518 pub fn ptr() -> *const cpu_dwt::RegisterBlock {
519 3758100480 as *const _
520 }
521}
522impl Deref for CPU_DWT {
523 type Target = cpu_dwt::RegisterBlock;
524 fn deref(&self) -> &cpu_dwt::RegisterBlock {
525 unsafe { &*CPU_DWT::ptr() }
526 }
527}
528#[doc = "Cortex-M's Data watchpoint and Trace (DWT)"]
529pub mod cpu_dwt;
530#[doc = "Cortex-M's Flash Patch and Breakpoint (FPB)"]
531pub struct CPU_FPB {
532 _marker: PhantomData<*const ()>,
533}
534unsafe impl Send for CPU_FPB {}
535impl CPU_FPB {
536 #[doc = r" Returns a pointer to the register block"]
537 pub fn ptr() -> *const cpu_fpb::RegisterBlock {
538 3758104576 as *const _
539 }
540}
541impl Deref for CPU_FPB {
542 type Target = cpu_fpb::RegisterBlock;
543 fn deref(&self) -> &cpu_fpb::RegisterBlock {
544 unsafe { &*CPU_FPB::ptr() }
545 }
546}
547#[doc = "Cortex-M's Flash Patch and Breakpoint (FPB)"]
548pub mod cpu_fpb;
549#[doc = "Cortex-M's Instrumentation Trace Macrocell (ITM)"]
550pub struct CPU_ITM {
551 _marker: PhantomData<*const ()>,
552}
553unsafe impl Send for CPU_ITM {}
554impl CPU_ITM {
555 #[doc = r" Returns a pointer to the register block"]
556 pub fn ptr() -> *const cpu_itm::RegisterBlock {
557 3758096384 as *const _
558 }
559}
560impl Deref for CPU_ITM {
561 type Target = cpu_itm::RegisterBlock;
562 fn deref(&self) -> &cpu_itm::RegisterBlock {
563 unsafe { &*CPU_ITM::ptr() }
564 }
565}
566#[doc = "Cortex-M's Instrumentation Trace Macrocell (ITM)"]
567pub mod cpu_itm;
568#[doc = "Cortex-M's System Control Space (SCS)"]
569pub struct CPU_SCS {
570 _marker: PhantomData<*const ()>,
571}
572unsafe impl Send for CPU_SCS {}
573impl CPU_SCS {
574 #[doc = r" Returns a pointer to the register block"]
575 pub fn ptr() -> *const cpu_scs::RegisterBlock {
576 3758153728 as *const _
577 }
578}
579impl Deref for CPU_SCS {
580 type Target = cpu_scs::RegisterBlock;
581 fn deref(&self) -> &cpu_scs::RegisterBlock {
582 unsafe { &*CPU_SCS::ptr() }
583 }
584}
585#[doc = "Cortex-M's System Control Space (SCS)"]
586pub mod cpu_scs;
587#[doc = "Cortex-M's TI proprietary registers"]
588pub struct CPU_TIPROP {
589 _marker: PhantomData<*const ()>,
590}
591unsafe impl Send for CPU_TIPROP {}
592impl CPU_TIPROP {
593 #[doc = r" Returns a pointer to the register block"]
594 pub fn ptr() -> *const cpu_tiprop::RegisterBlock {
595 3759136768 as *const _
596 }
597}
598impl Deref for CPU_TIPROP {
599 type Target = cpu_tiprop::RegisterBlock;
600 fn deref(&self) -> &cpu_tiprop::RegisterBlock {
601 unsafe { &*CPU_TIPROP::ptr() }
602 }
603}
604#[doc = "Cortex-M's TI proprietary registers"]
605pub mod cpu_tiprop;
606#[doc = "Cortex-M3's Trace Port Interface Unit (TPIU)"]
607pub struct CPU_TPIU {
608 _marker: PhantomData<*const ()>,
609}
610unsafe impl Send for CPU_TPIU {}
611impl CPU_TPIU {
612 #[doc = r" Returns a pointer to the register block"]
613 pub fn ptr() -> *const cpu_tpiu::RegisterBlock {
614 3758358528 as *const _
615 }
616}
617impl Deref for CPU_TPIU {
618 type Target = cpu_tpiu::RegisterBlock;
619 fn deref(&self) -> &cpu_tpiu::RegisterBlock {
620 unsafe { &*CPU_TPIU::ptr() }
621 }
622}
623#[doc = "Cortex-M3's Trace Port Interface Unit (TPIU)"]
624pub mod cpu_tpiu;
625#[doc = "Crypto core with DMA capability and local key storage"]
626pub struct CRYPTO {
627 _marker: PhantomData<*const ()>,
628}
629unsafe impl Send for CRYPTO {}
630impl CRYPTO {
631 #[doc = r" Returns a pointer to the register block"]
632 pub fn ptr() -> *const crypto::RegisterBlock {
633 1073889280 as *const _
634 }
635}
636impl Deref for CRYPTO {
637 type Target = crypto::RegisterBlock;
638 fn deref(&self) -> &crypto::RegisterBlock {
639 unsafe { &*CRYPTO::ptr() }
640 }
641}
642#[doc = "Crypto core with DMA capability and local key storage"]
643pub mod crypto;
644#[doc = "Event Fabric Component Definition"]
645pub struct EVENT {
646 _marker: PhantomData<*const ()>,
647}
648unsafe impl Send for EVENT {}
649impl EVENT {
650 #[doc = r" Returns a pointer to the register block"]
651 pub fn ptr() -> *const event::RegisterBlock {
652 1074278400 as *const _
653 }
654}
655impl Deref for EVENT {
656 type Target = event::RegisterBlock;
657 fn deref(&self) -> &event::RegisterBlock {
658 unsafe { &*EVENT::ptr() }
659 }
660}
661#[doc = "Event Fabric Component Definition"]
662pub mod event;
663#[doc = "Factory configuration area (FCFG1)"]
664pub struct FCFG1 {
665 _marker: PhantomData<*const ()>,
666}
667unsafe impl Send for FCFG1 {}
668impl FCFG1 {
669 #[doc = r" Returns a pointer to the register block"]
670 pub fn ptr() -> *const fcfg1::RegisterBlock {
671 1342181376 as *const _
672 }
673}
674impl Deref for FCFG1 {
675 type Target = fcfg1::RegisterBlock;
676 fn deref(&self) -> &fcfg1::RegisterBlock {
677 unsafe { &*FCFG1::ptr() }
678 }
679}
680#[doc = "Factory configuration area (FCFG1)"]
681pub mod fcfg1;
682#[doc = "Flash sub-system registers, includes the Flash Memory Controller (FMC), flash read path, and an integrated Efuse controller and EFUSEROM."]
683pub struct FLASH {
684 _marker: PhantomData<*const ()>,
685}
686unsafe impl Send for FLASH {}
687impl FLASH {
688 #[doc = r" Returns a pointer to the register block"]
689 pub fn ptr() -> *const flash::RegisterBlock {
690 1073938432 as *const _
691 }
692}
693impl Deref for FLASH {
694 type Target = flash::RegisterBlock;
695 fn deref(&self) -> &flash::RegisterBlock {
696 unsafe { &*FLASH::ptr() }
697 }
698}
699#[doc = "Flash sub-system registers, includes the Flash Memory Controller (FMC), flash read path, and an integrated Efuse controller and EFUSEROM."]
700pub mod flash;
701#[doc = "MCU GPIO - I/F for controlling and reading IO status and IO event status"]
702pub struct GPIO {
703 _marker: PhantomData<*const ()>,
704}
705unsafe impl Send for GPIO {}
706impl GPIO {
707 #[doc = r" Returns a pointer to the register block"]
708 pub fn ptr() -> *const gpio::RegisterBlock {
709 1073881088 as *const _
710 }
711}
712impl Deref for GPIO {
713 type Target = gpio::RegisterBlock;
714 fn deref(&self) -> &gpio::RegisterBlock {
715 unsafe { &*GPIO::ptr() }
716 }
717}
718#[doc = "MCU GPIO - I/F for controlling and reading IO status and IO event status"]
719pub mod gpio;
720#[doc = "General Purpose Timer."]
721pub struct GPT0 {
722 _marker: PhantomData<*const ()>,
723}
724unsafe impl Send for GPT0 {}
725impl GPT0 {
726 #[doc = r" Returns a pointer to the register block"]
727 pub fn ptr() -> *const gpt0::RegisterBlock {
728 1073807360 as *const _
729 }
730}
731impl Deref for GPT0 {
732 type Target = gpt0::RegisterBlock;
733 fn deref(&self) -> &gpt0::RegisterBlock {
734 unsafe { &*GPT0::ptr() }
735 }
736}
737#[doc = "General Purpose Timer."]
738pub mod gpt0;
739#[doc = "GPT1"]
740pub struct GPT1 {
741 _marker: PhantomData<*const ()>,
742}
743unsafe impl Send for GPT1 {}
744impl GPT1 {
745 #[doc = r" Returns a pointer to the register block"]
746 pub fn ptr() -> *const gpt0::RegisterBlock {
747 1073811456 as *const _
748 }
749}
750impl Deref for GPT1 {
751 type Target = gpt0::RegisterBlock;
752 fn deref(&self) -> &gpt0::RegisterBlock {
753 unsafe { &*GPT1::ptr() }
754 }
755}
756#[doc = "GPT2"]
757pub struct GPT2 {
758 _marker: PhantomData<*const ()>,
759}
760unsafe impl Send for GPT2 {}
761impl GPT2 {
762 #[doc = r" Returns a pointer to the register block"]
763 pub fn ptr() -> *const gpt0::RegisterBlock {
764 1073815552 as *const _
765 }
766}
767impl Deref for GPT2 {
768 type Target = gpt0::RegisterBlock;
769 fn deref(&self) -> &gpt0::RegisterBlock {
770 unsafe { &*GPT2::ptr() }
771 }
772}
773#[doc = "GPT3"]
774pub struct GPT3 {
775 _marker: PhantomData<*const ()>,
776}
777unsafe impl Send for GPT3 {}
778impl GPT3 {
779 #[doc = r" Returns a pointer to the register block"]
780 pub fn ptr() -> *const gpt0::RegisterBlock {
781 1073819648 as *const _
782 }
783}
784impl Deref for GPT3 {
785 type Target = gpt0::RegisterBlock;
786 fn deref(&self) -> &gpt0::RegisterBlock {
787 unsafe { &*GPT3::ptr() }
788 }
789}
790#[doc = "I2CMaster/Slave Serial Controler"]
791pub struct I2C0 {
792 _marker: PhantomData<*const ()>,
793}
794unsafe impl Send for I2C0 {}
795impl I2C0 {
796 #[doc = r" Returns a pointer to the register block"]
797 pub fn ptr() -> *const i2c0::RegisterBlock {
798 1073750016 as *const _
799 }
800}
801impl Deref for I2C0 {
802 type Target = i2c0::RegisterBlock;
803 fn deref(&self) -> &i2c0::RegisterBlock {
804 unsafe { &*I2C0::ptr() }
805 }
806}
807#[doc = "I2CMaster/Slave Serial Controler"]
808pub mod i2c0;
809#[doc = "I2S Audio DMA module supporting formats I2S, LJF, RJF and DSP"]
810pub struct I2S0 {
811 _marker: PhantomData<*const ()>,
812}
813unsafe impl Send for I2S0 {}
814impl I2S0 {
815 #[doc = r" Returns a pointer to the register block"]
816 pub fn ptr() -> *const i2s0::RegisterBlock {
817 1073876992 as *const _
818 }
819}
820impl Deref for I2S0 {
821 type Target = i2s0::RegisterBlock;
822 fn deref(&self) -> &i2s0::RegisterBlock {
823 unsafe { &*I2S0::ptr() }
824 }
825}
826#[doc = "I2S Audio DMA module supporting formats I2S, LJF, RJF and DSP"]
827pub mod i2s0;
828#[doc = "IO Controller (IOC) - configures all the DIOs and resides in the MCU domain."]
829pub struct IOC {
830 _marker: PhantomData<*const ()>,
831}
832unsafe impl Send for IOC {}
833impl IOC {
834 #[doc = r" Returns a pointer to the register block"]
835 pub fn ptr() -> *const ioc::RegisterBlock {
836 1074270208 as *const _
837 }
838}
839impl Deref for IOC {
840 type Target = ioc::RegisterBlock;
841 fn deref(&self) -> &ioc::RegisterBlock {
842 unsafe { &*IOC::ptr() }
843 }
844}
845#[doc = "IO Controller (IOC) - configures all the DIOs and resides in the MCU domain."]
846pub mod ioc;
847#[doc = "Power, Reset and Clock Management"]
848pub struct PRCM {
849 _marker: PhantomData<*const ()>,
850}
851unsafe impl Send for PRCM {}
852impl PRCM {
853 #[doc = r" Returns a pointer to the register block"]
854 pub fn ptr() -> *const prcm::RegisterBlock {
855 1074274304 as *const _
856 }
857}
858impl Deref for PRCM {
859 type Target = prcm::RegisterBlock;
860 fn deref(&self) -> &prcm::RegisterBlock {
861 unsafe { &*PRCM::ptr() }
862 }
863}
864#[doc = "Power, Reset and Clock Management"]
865pub mod prcm;
866#[doc = "RF Core Doorbell"]
867pub struct RFC_DBELL {
868 _marker: PhantomData<*const ()>,
869}
870unsafe impl Send for RFC_DBELL {}
871impl RFC_DBELL {
872 #[doc = r" Returns a pointer to the register block"]
873 pub fn ptr() -> *const rfc_dbell::RegisterBlock {
874 1074008064 as *const _
875 }
876}
877impl Deref for RFC_DBELL {
878 type Target = rfc_dbell::RegisterBlock;
879 fn deref(&self) -> &rfc_dbell::RegisterBlock {
880 unsafe { &*RFC_DBELL::ptr() }
881 }
882}
883#[doc = "RF Core Doorbell"]
884pub mod rfc_dbell;
885#[doc = "RF Core Power Management"]
886pub struct RFC_PWR {
887 _marker: PhantomData<*const ()>,
888}
889unsafe impl Send for RFC_PWR {}
890impl RFC_PWR {
891 #[doc = r" Returns a pointer to the register block"]
892 pub fn ptr() -> *const rfc_pwr::RegisterBlock {
893 1074003968 as *const _
894 }
895}
896impl Deref for RFC_PWR {
897 type Target = rfc_pwr::RegisterBlock;
898 fn deref(&self) -> &rfc_pwr::RegisterBlock {
899 unsafe { &*RFC_PWR::ptr() }
900 }
901}
902#[doc = "RF Core Power Management"]
903pub mod rfc_pwr;
904#[doc = "RF Core Radio Timer"]
905pub struct RFC_RAT {
906 _marker: PhantomData<*const ()>,
907}
908unsafe impl Send for RFC_RAT {}
909impl RFC_RAT {
910 #[doc = r" Returns a pointer to the register block"]
911 pub fn ptr() -> *const rfc_rat::RegisterBlock {
912 1074016256 as *const _
913 }
914}
915impl Deref for RFC_RAT {
916 type Target = rfc_rat::RegisterBlock;
917 fn deref(&self) -> &rfc_rat::RegisterBlock {
918 unsafe { &*RFC_RAT::ptr() }
919 }
920}
921#[doc = "RF Core Radio Timer"]
922pub mod rfc_rat;
923#[doc = "MCU Semaphore Module This module provides 32 binary semaphores. The state of a binary semaphore is either taken or available. A semaphore does not implement any ownership attribute. Still, a semaphore can be used to handle mutual exclusion scenarios."]
924pub struct SMPH {
925 _marker: PhantomData<*const ()>,
926}
927unsafe impl Send for SMPH {}
928impl SMPH {
929 #[doc = r" Returns a pointer to the register block"]
930 pub fn ptr() -> *const smph::RegisterBlock {
931 1074282496 as *const _
932 }
933}
934impl Deref for SMPH {
935 type Target = smph::RegisterBlock;
936 fn deref(&self) -> &smph::RegisterBlock {
937 unsafe { &*SMPH::ptr() }
938 }
939}
940#[doc = "MCU Semaphore Module This module provides 32 binary semaphores. The state of a binary semaphore is either taken or available. A semaphore does not implement any ownership attribute. Still, a semaphore can be used to handle mutual exclusion scenarios."]
941pub mod smph;
942#[doc = "Synchronous Serial Interface with master and slave capabilities"]
943pub struct SSI0 {
944 _marker: PhantomData<*const ()>,
945}
946unsafe impl Send for SSI0 {}
947impl SSI0 {
948 #[doc = r" Returns a pointer to the register block"]
949 pub fn ptr() -> *const ssi0::RegisterBlock {
950 1073741824 as *const _
951 }
952}
953impl Deref for SSI0 {
954 type Target = ssi0::RegisterBlock;
955 fn deref(&self) -> &ssi0::RegisterBlock {
956 unsafe { &*SSI0::ptr() }
957 }
958}
959#[doc = "Synchronous Serial Interface with master and slave capabilities"]
960pub mod ssi0;
961#[doc = "SSI1"]
962pub struct SSI1 {
963 _marker: PhantomData<*const ()>,
964}
965unsafe impl Send for SSI1 {}
966impl SSI1 {
967 #[doc = r" Returns a pointer to the register block"]
968 pub fn ptr() -> *const ssi0::RegisterBlock {
969 1073774592 as *const _
970 }
971}
972impl Deref for SSI1 {
973 type Target = ssi0::RegisterBlock;
974 fn deref(&self) -> &ssi0::RegisterBlock {
975 unsafe { &*SSI1::ptr() }
976 }
977}
978#[doc = "True Random Number Generator"]
979pub struct TRNG {
980 _marker: PhantomData<*const ()>,
981}
982unsafe impl Send for TRNG {}
983impl TRNG {
984 #[doc = r" Returns a pointer to the register block"]
985 pub fn ptr() -> *const trng::RegisterBlock {
986 1073905664 as *const _
987 }
988}
989impl Deref for TRNG {
990 type Target = trng::RegisterBlock;
991 fn deref(&self) -> &trng::RegisterBlock {
992 unsafe { &*TRNG::ptr() }
993 }
994}
995#[doc = "True Random Number Generator"]
996pub mod trng;
997#[doc = "Universal Asynchronous Receiver/Transmitter (UART) interface"]
998pub struct UART0 {
999 _marker: PhantomData<*const ()>,
1000}
1001unsafe impl Send for UART0 {}
1002impl UART0 {
1003 #[doc = r" Returns a pointer to the register block"]
1004 pub fn ptr() -> *const uart0::RegisterBlock {
1005 1073745920 as *const _
1006 }
1007}
1008impl Deref for UART0 {
1009 type Target = uart0::RegisterBlock;
1010 fn deref(&self) -> &uart0::RegisterBlock {
1011 unsafe { &*UART0::ptr() }
1012 }
1013}
1014#[doc = "Universal Asynchronous Receiver/Transmitter (UART) interface"]
1015pub mod uart0;
1016#[doc = "ARM Micro Direct Memory Access Controller"]
1017pub struct UDMA0 {
1018 _marker: PhantomData<*const ()>,
1019}
1020unsafe impl Send for UDMA0 {}
1021impl UDMA0 {
1022 #[doc = r" Returns a pointer to the register block"]
1023 pub fn ptr() -> *const udma0::RegisterBlock {
1024 1073872896 as *const _
1025 }
1026}
1027impl Deref for UDMA0 {
1028 type Target = udma0::RegisterBlock;
1029 fn deref(&self) -> &udma0::RegisterBlock {
1030 unsafe { &*UDMA0::ptr() }
1031 }
1032}
1033#[doc = "ARM Micro Direct Memory Access Controller"]
1034pub mod udma0;
1035#[doc = "Versatile Instruction Memory System Controls memory access to the Flash and encapsulates the following instruction memories: - Boot ROM - Cache / GPRAM"]
1036pub struct VIMS {
1037 _marker: PhantomData<*const ()>,
1038}
1039unsafe impl Send for VIMS {}
1040impl VIMS {
1041 #[doc = r" Returns a pointer to the register block"]
1042 pub fn ptr() -> *const vims::RegisterBlock {
1043 1073954816 as *const _
1044 }
1045}
1046impl Deref for VIMS {
1047 type Target = vims::RegisterBlock;
1048 fn deref(&self) -> &vims::RegisterBlock {
1049 unsafe { &*VIMS::ptr() }
1050 }
1051}
1052#[doc = "Versatile Instruction Memory System Controls memory access to the Flash and encapsulates the following instruction memories: - Boot ROM - Cache / GPRAM"]
1053pub mod vims;
1054#[doc = "Watchdog Timer"]
1055pub struct WDT {
1056 _marker: PhantomData<*const ()>,
1057}
1058unsafe impl Send for WDT {}
1059impl WDT {
1060 #[doc = r" Returns a pointer to the register block"]
1061 pub fn ptr() -> *const wdt::RegisterBlock {
1062 1074266112 as *const _
1063 }
1064}
1065impl Deref for WDT {
1066 type Target = wdt::RegisterBlock;
1067 fn deref(&self) -> &wdt::RegisterBlock {
1068 unsafe { &*WDT::ptr() }
1069 }
1070}
1071#[doc = "Watchdog Timer"]
1072pub mod wdt;
1073#[no_mangle]
1074static mut DEVICE_PERIPHERALS: bool = false;
1075#[doc = r" All the peripherals"]
1076#[allow(non_snake_case)]
1077pub struct Peripherals {
1078 #[doc = "AON_BATMON"]
1079 pub AON_BATMON: AON_BATMON,
1080 #[doc = "AON_EVENT"]
1081 pub AON_EVENT: AON_EVENT,
1082 #[doc = "AON_IOC"]
1083 pub AON_IOC: AON_IOC,
1084 #[doc = "AON_RTC"]
1085 pub AON_RTC: AON_RTC,
1086 #[doc = "AON_SYSCTL"]
1087 pub AON_SYSCTL: AON_SYSCTL,
1088 #[doc = "AON_WUC"]
1089 pub AON_WUC: AON_WUC,
1090 #[doc = "AUX_ADI4"]
1091 pub AUX_ADI4: AUX_ADI4,
1092 #[doc = "AUX_AIODIO0"]
1093 pub AUX_AIODIO0: AUX_AIODIO0,
1094 #[doc = "AUX_AIODIO1"]
1095 pub AUX_AIODIO1: AUX_AIODIO1,
1096 #[doc = "AUX_ANAIF"]
1097 pub AUX_ANAIF: AUX_ANAIF,
1098 #[doc = "AUX_DDI0_OSC"]
1099 pub AUX_DDI0_OSC: AUX_DDI0_OSC,
1100 #[doc = "AUX_EVCTL"]
1101 pub AUX_EVCTL: AUX_EVCTL,
1102 #[doc = "AUX_SCE"]
1103 pub AUX_SCE: AUX_SCE,
1104 #[doc = "AUX_SMPH"]
1105 pub AUX_SMPH: AUX_SMPH,
1106 #[doc = "AUX_TDCIF"]
1107 pub AUX_TDCIF: AUX_TDCIF,
1108 #[doc = "AUX_TIMER"]
1109 pub AUX_TIMER: AUX_TIMER,
1110 #[doc = "AUX_WUC"]
1111 pub AUX_WUC: AUX_WUC,
1112 #[doc = "CCFG"]
1113 pub CCFG: CCFG,
1114 #[doc = "CPU_DWT"]
1115 pub CPU_DWT: CPU_DWT,
1116 #[doc = "CPU_FPB"]
1117 pub CPU_FPB: CPU_FPB,
1118 #[doc = "CPU_ITM"]
1119 pub CPU_ITM: CPU_ITM,
1120 #[doc = "CPU_SCS"]
1121 pub CPU_SCS: CPU_SCS,
1122 #[doc = "CPU_TIPROP"]
1123 pub CPU_TIPROP: CPU_TIPROP,
1124 #[doc = "CPU_TPIU"]
1125 pub CPU_TPIU: CPU_TPIU,
1126 #[doc = "CRYPTO"]
1127 pub CRYPTO: CRYPTO,
1128 #[doc = "EVENT"]
1129 pub EVENT: EVENT,
1130 #[doc = "FCFG1"]
1131 pub FCFG1: FCFG1,
1132 #[doc = "FLASH"]
1133 pub FLASH: FLASH,
1134 #[doc = "GPIO"]
1135 pub GPIO: GPIO,
1136 #[doc = "GPT0"]
1137 pub GPT0: GPT0,
1138 #[doc = "GPT1"]
1139 pub GPT1: GPT1,
1140 #[doc = "GPT2"]
1141 pub GPT2: GPT2,
1142 #[doc = "GPT3"]
1143 pub GPT3: GPT3,
1144 #[doc = "I2C0"]
1145 pub I2C0: I2C0,
1146 #[doc = "I2S0"]
1147 pub I2S0: I2S0,
1148 #[doc = "IOC"]
1149 pub IOC: IOC,
1150 #[doc = "PRCM"]
1151 pub PRCM: PRCM,
1152 #[doc = "RFC_DBELL"]
1153 pub RFC_DBELL: RFC_DBELL,
1154 #[doc = "RFC_PWR"]
1155 pub RFC_PWR: RFC_PWR,
1156 #[doc = "RFC_RAT"]
1157 pub RFC_RAT: RFC_RAT,
1158 #[doc = "SMPH"]
1159 pub SMPH: SMPH,
1160 #[doc = "SSI0"]
1161 pub SSI0: SSI0,
1162 #[doc = "SSI1"]
1163 pub SSI1: SSI1,
1164 #[doc = "TRNG"]
1165 pub TRNG: TRNG,
1166 #[doc = "UART0"]
1167 pub UART0: UART0,
1168 #[doc = "UDMA0"]
1169 pub UDMA0: UDMA0,
1170 #[doc = "VIMS"]
1171 pub VIMS: VIMS,
1172 #[doc = "WDT"]
1173 pub WDT: WDT,
1174}
1175impl Peripherals {
1176 #[doc = r" Returns all the peripherals *once*"]
1177 #[inline]
1178 pub fn take() -> Option<Self> {
1179 cortex_m::interrupt::free(|_| if unsafe { DEVICE_PERIPHERALS } { None } else { Some(unsafe { Peripherals::steal() }) })
1180 }
1181 #[doc = r" Unchecked version of `Peripherals::take`"]
1182 pub unsafe fn steal() -> Self {
1183 debug_assert!(!DEVICE_PERIPHERALS);
1184 DEVICE_PERIPHERALS = true;
1185 Peripherals {
1186 AON_BATMON: AON_BATMON { _marker: PhantomData },
1187 AON_EVENT: AON_EVENT { _marker: PhantomData },
1188 AON_IOC: AON_IOC { _marker: PhantomData },
1189 AON_RTC: AON_RTC { _marker: PhantomData },
1190 AON_SYSCTL: AON_SYSCTL { _marker: PhantomData },
1191 AON_WUC: AON_WUC { _marker: PhantomData },
1192 AUX_ADI4: AUX_ADI4 { _marker: PhantomData },
1193 AUX_AIODIO0: AUX_AIODIO0 { _marker: PhantomData },
1194 AUX_AIODIO1: AUX_AIODIO1 { _marker: PhantomData },
1195 AUX_ANAIF: AUX_ANAIF { _marker: PhantomData },
1196 AUX_DDI0_OSC: AUX_DDI0_OSC { _marker: PhantomData },
1197 AUX_EVCTL: AUX_EVCTL { _marker: PhantomData },
1198 AUX_SCE: AUX_SCE { _marker: PhantomData },
1199 AUX_SMPH: AUX_SMPH { _marker: PhantomData },
1200 AUX_TDCIF: AUX_TDCIF { _marker: PhantomData },
1201 AUX_TIMER: AUX_TIMER { _marker: PhantomData },
1202 AUX_WUC: AUX_WUC { _marker: PhantomData },
1203 CCFG: CCFG { _marker: PhantomData },
1204 CPU_DWT: CPU_DWT { _marker: PhantomData },
1205 CPU_FPB: CPU_FPB { _marker: PhantomData },
1206 CPU_ITM: CPU_ITM { _marker: PhantomData },
1207 CPU_SCS: CPU_SCS { _marker: PhantomData },
1208 CPU_TIPROP: CPU_TIPROP { _marker: PhantomData },
1209 CPU_TPIU: CPU_TPIU { _marker: PhantomData },
1210 CRYPTO: CRYPTO { _marker: PhantomData },
1211 EVENT: EVENT { _marker: PhantomData },
1212 FCFG1: FCFG1 { _marker: PhantomData },
1213 FLASH: FLASH { _marker: PhantomData },
1214 GPIO: GPIO { _marker: PhantomData },
1215 GPT0: GPT0 { _marker: PhantomData },
1216 GPT1: GPT1 { _marker: PhantomData },
1217 GPT2: GPT2 { _marker: PhantomData },
1218 GPT3: GPT3 { _marker: PhantomData },
1219 I2C0: I2C0 { _marker: PhantomData },
1220 I2S0: I2S0 { _marker: PhantomData },
1221 IOC: IOC { _marker: PhantomData },
1222 PRCM: PRCM { _marker: PhantomData },
1223 RFC_DBELL: RFC_DBELL { _marker: PhantomData },
1224 RFC_PWR: RFC_PWR { _marker: PhantomData },
1225 RFC_RAT: RFC_RAT { _marker: PhantomData },
1226 SMPH: SMPH { _marker: PhantomData },
1227 SSI0: SSI0 { _marker: PhantomData },
1228 SSI1: SSI1 { _marker: PhantomData },
1229 TRNG: TRNG { _marker: PhantomData },
1230 UART0: UART0 { _marker: PhantomData },
1231 UDMA0: UDMA0 { _marker: PhantomData },
1232 VIMS: VIMS { _marker: PhantomData },
1233 WDT: WDT { _marker: PhantomData },
1234 }
1235 }
1236}