iwrl64xx_pac/
lib.rs

1#![doc = "Peripheral access API for IWRL6432 microcontrollers (generated using svd2rust v0.33.4 ( ))\n\nYou can find an overview of the generated API [here].\n\nAPI features to be included in the [next]
2svd2rust release can be generated by cloning the svd2rust [repository], checking out the above commit, and running `cargo doc --open`.\n\n[here]: https://docs.rs/svd2rust/0.33.4/svd2rust/#peripheral-api\n[next]: https://github.com/rust-embedded/svd2rust/blob/master/CHANGELOG.md#unreleased\n[repository]: https://github.com/rust-embedded/svd2rust"]
3#![allow(non_camel_case_types)]
4#![allow(non_snake_case)]
5#![no_std]
6use core::marker::PhantomData;
7use core::ops::Deref;
8#[doc = r"Number available in the NVIC for configuring priority"]
9pub const NVIC_PRIO_BITS: u8 = 3;
10#[allow(unused_imports)]
11use generic::*;
12#[doc = r"Common register and bit access and modify traits"]
13pub mod generic;
14#[cfg(feature = "rt")]
15extern "C" {}
16#[doc(hidden)]
17#[repr(C)]
18pub union Vector {
19    _handler: unsafe extern "C" fn(),
20    _reserved: u32,
21}
22#[cfg(feature = "rt")]
23#[doc(hidden)]
24#[link_section = ".vector_table.interrupts"]
25#[no_mangle]
26pub static __INTERRUPTS: [Vector; 0] = [];
27#[doc = r"Enumeration of all the interrupts."]
28#[derive(Copy, Clone, Debug, PartialEq, Eq)]
29pub enum Interrupt {}
30unsafe impl cortex_m::interrupt::InterruptNumber for Interrupt {
31    #[inline(always)]
32    fn number(self) -> u16 {
33        match self {}
34    }
35}
36#[doc = "GPADC_CTRL"]
37pub struct GpadcCtrl {
38    _marker: PhantomData<*const ()>,
39}
40unsafe impl Send for GpadcCtrl {}
41impl GpadcCtrl {
42    #[doc = r"Pointer to the register block"]
43    pub const PTR: *const gpadc_ctrl::RegisterBlock = 0x50f7_fc00 as *const _;
44    #[doc = r"Return the pointer to the register block"]
45    #[inline(always)]
46    pub const fn ptr() -> *const gpadc_ctrl::RegisterBlock {
47        Self::PTR
48    }
49    #[doc = r" Steal an instance of this peripheral"]
50    #[doc = r""]
51    #[doc = r" # Safety"]
52    #[doc = r""]
53    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
54    #[doc = r" that may race with any existing instances, for example by only"]
55    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
56    #[doc = r" original peripheral and using critical sections to coordinate"]
57    #[doc = r" access between multiple new instances."]
58    #[doc = r""]
59    #[doc = r" Additionally, other software such as HALs may rely on only one"]
60    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
61    #[doc = r" no stolen instances are passed to such software."]
62    pub unsafe fn steal() -> Self {
63        Self {
64            _marker: PhantomData,
65        }
66    }
67}
68impl Deref for GpadcCtrl {
69    type Target = gpadc_ctrl::RegisterBlock;
70    #[inline(always)]
71    fn deref(&self) -> &Self::Target {
72        unsafe { &*Self::PTR }
73    }
74}
75impl core::fmt::Debug for GpadcCtrl {
76    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
77        f.debug_struct("GpadcCtrl").finish()
78    }
79}
80#[doc = "GPADC_CTRL"]
81pub mod gpadc_ctrl;
82#[doc = "APP_LIN"]
83pub struct AppLin {
84    _marker: PhantomData<*const ()>,
85}
86unsafe impl Send for AppLin {}
87impl AppLin {
88    #[doc = r"Pointer to the register block"]
89    pub const PTR: *const app_lin::RegisterBlock = 0x5300_0000 as *const _;
90    #[doc = r"Return the pointer to the register block"]
91    #[inline(always)]
92    pub const fn ptr() -> *const app_lin::RegisterBlock {
93        Self::PTR
94    }
95    #[doc = r" Steal an instance of this peripheral"]
96    #[doc = r""]
97    #[doc = r" # Safety"]
98    #[doc = r""]
99    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
100    #[doc = r" that may race with any existing instances, for example by only"]
101    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
102    #[doc = r" original peripheral and using critical sections to coordinate"]
103    #[doc = r" access between multiple new instances."]
104    #[doc = r""]
105    #[doc = r" Additionally, other software such as HALs may rely on only one"]
106    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
107    #[doc = r" no stolen instances are passed to such software."]
108    pub unsafe fn steal() -> Self {
109        Self {
110            _marker: PhantomData,
111        }
112    }
113}
114impl Deref for AppLin {
115    type Target = app_lin::RegisterBlock;
116    #[inline(always)]
117    fn deref(&self) -> &Self::Target {
118        unsafe { &*Self::PTR }
119    }
120}
121impl core::fmt::Debug for AppLin {
122    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
123        f.debug_struct("AppLin").finish()
124    }
125}
126#[doc = "APP_LIN"]
127pub mod app_lin;
128#[doc = "APP_UART"]
129pub struct AppUart0 {
130    _marker: PhantomData<*const ()>,
131}
132unsafe impl Send for AppUart0 {}
133impl AppUart0 {
134    #[doc = r"Pointer to the register block"]
135    pub const PTR: *const app_uart_0::RegisterBlock = 0x53f7_f000 as *const _;
136    #[doc = r"Return the pointer to the register block"]
137    #[inline(always)]
138    pub const fn ptr() -> *const app_uart_0::RegisterBlock {
139        Self::PTR
140    }
141    #[doc = r" Steal an instance of this peripheral"]
142    #[doc = r""]
143    #[doc = r" # Safety"]
144    #[doc = r""]
145    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
146    #[doc = r" that may race with any existing instances, for example by only"]
147    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
148    #[doc = r" original peripheral and using critical sections to coordinate"]
149    #[doc = r" access between multiple new instances."]
150    #[doc = r""]
151    #[doc = r" Additionally, other software such as HALs may rely on only one"]
152    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
153    #[doc = r" no stolen instances are passed to such software."]
154    pub unsafe fn steal() -> Self {
155        Self {
156            _marker: PhantomData,
157        }
158    }
159}
160impl Deref for AppUart0 {
161    type Target = app_uart_0::RegisterBlock;
162    #[inline(always)]
163    fn deref(&self) -> &Self::Target {
164        unsafe { &*Self::PTR }
165    }
166}
167impl core::fmt::Debug for AppUart0 {
168    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
169        f.debug_struct("AppUart0").finish()
170    }
171}
172#[doc = "APP_UART"]
173pub mod app_uart_0;
174#[doc = "APP_SPI"]
175pub struct AppSpi0 {
176    _marker: PhantomData<*const ()>,
177}
178unsafe impl Send for AppSpi0 {}
179impl AppSpi0 {
180    #[doc = r"Pointer to the register block"]
181    pub const PTR: *const app_spi_0::RegisterBlock = 0x53f7_f400 as *const _;
182    #[doc = r"Return the pointer to the register block"]
183    #[inline(always)]
184    pub const fn ptr() -> *const app_spi_0::RegisterBlock {
185        Self::PTR
186    }
187    #[doc = r" Steal an instance of this peripheral"]
188    #[doc = r""]
189    #[doc = r" # Safety"]
190    #[doc = r""]
191    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
192    #[doc = r" that may race with any existing instances, for example by only"]
193    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
194    #[doc = r" original peripheral and using critical sections to coordinate"]
195    #[doc = r" access between multiple new instances."]
196    #[doc = r""]
197    #[doc = r" Additionally, other software such as HALs may rely on only one"]
198    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
199    #[doc = r" no stolen instances are passed to such software."]
200    pub unsafe fn steal() -> Self {
201        Self {
202            _marker: PhantomData,
203        }
204    }
205}
206impl Deref for AppSpi0 {
207    type Target = app_spi_0::RegisterBlock;
208    #[inline(always)]
209    fn deref(&self) -> &Self::Target {
210        unsafe { &*Self::PTR }
211    }
212}
213impl core::fmt::Debug for AppSpi0 {
214    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
215        f.debug_struct("AppSpi0").finish()
216    }
217}
218#[doc = "APP_SPI"]
219pub mod app_spi_0;
220#[doc = "APP_CANCFG"]
221pub struct AppCancfg {
222    _marker: PhantomData<*const ()>,
223}
224unsafe impl Send for AppCancfg {}
225impl AppCancfg {
226    #[doc = r"Pointer to the register block"]
227    pub const PTR: *const app_cancfg::RegisterBlock = 0x53f7_f800 as *const _;
228    #[doc = r"Return the pointer to the register block"]
229    #[inline(always)]
230    pub const fn ptr() -> *const app_cancfg::RegisterBlock {
231        Self::PTR
232    }
233    #[doc = r" Steal an instance of this peripheral"]
234    #[doc = r""]
235    #[doc = r" # Safety"]
236    #[doc = r""]
237    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
238    #[doc = r" that may race with any existing instances, for example by only"]
239    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
240    #[doc = r" original peripheral and using critical sections to coordinate"]
241    #[doc = r" access between multiple new instances."]
242    #[doc = r""]
243    #[doc = r" Additionally, other software such as HALs may rely on only one"]
244    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
245    #[doc = r" no stolen instances are passed to such software."]
246    pub unsafe fn steal() -> Self {
247        Self {
248            _marker: PhantomData,
249        }
250    }
251}
252impl Deref for AppCancfg {
253    type Target = app_cancfg::RegisterBlock;
254    #[inline(always)]
255    fn deref(&self) -> &Self::Target {
256        unsafe { &*Self::PTR }
257    }
258}
259impl core::fmt::Debug for AppCancfg {
260    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
261        f.debug_struct("AppCancfg").finish()
262    }
263}
264#[doc = "APP_CANCFG"]
265pub mod app_cancfg;
266#[doc = "APP_CANECC"]
267pub struct AppCanecc {
268    _marker: PhantomData<*const ()>,
269}
270unsafe impl Send for AppCanecc {}
271impl AppCanecc {
272    #[doc = r"Pointer to the register block"]
273    pub const PTR: *const app_canecc::RegisterBlock = 0x53f7_fc00 as *const _;
274    #[doc = r"Return the pointer to the register block"]
275    #[inline(always)]
276    pub const fn ptr() -> *const app_canecc::RegisterBlock {
277        Self::PTR
278    }
279    #[doc = r" Steal an instance of this peripheral"]
280    #[doc = r""]
281    #[doc = r" # Safety"]
282    #[doc = r""]
283    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
284    #[doc = r" that may race with any existing instances, for example by only"]
285    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
286    #[doc = r" original peripheral and using critical sections to coordinate"]
287    #[doc = r" access between multiple new instances."]
288    #[doc = r""]
289    #[doc = r" Additionally, other software such as HALs may rely on only one"]
290    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
291    #[doc = r" no stolen instances are passed to such software."]
292    pub unsafe fn steal() -> Self {
293        Self {
294            _marker: PhantomData,
295        }
296    }
297}
298impl Deref for AppCanecc {
299    type Target = app_canecc::RegisterBlock;
300    #[inline(always)]
301    fn deref(&self) -> &Self::Target {
302        unsafe { &*Self::PTR }
303    }
304}
305impl core::fmt::Debug for AppCanecc {
306    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
307        f.debug_struct("AppCanecc").finish()
308    }
309}
310#[doc = "APP_CANECC"]
311pub mod app_canecc;
312#[doc = "Register test environment"]
313pub struct TptcA0 {
314    _marker: PhantomData<*const ()>,
315}
316unsafe impl Send for TptcA0 {}
317impl TptcA0 {
318    #[doc = r"Pointer to the register block"]
319    pub const PTR: *const tptc_a0::RegisterBlock = 0x5400_0000 as *const _;
320    #[doc = r"Return the pointer to the register block"]
321    #[inline(always)]
322    pub const fn ptr() -> *const tptc_a0::RegisterBlock {
323        Self::PTR
324    }
325    #[doc = r" Steal an instance of this peripheral"]
326    #[doc = r""]
327    #[doc = r" # Safety"]
328    #[doc = r""]
329    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
330    #[doc = r" that may race with any existing instances, for example by only"]
331    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
332    #[doc = r" original peripheral and using critical sections to coordinate"]
333    #[doc = r" access between multiple new instances."]
334    #[doc = r""]
335    #[doc = r" Additionally, other software such as HALs may rely on only one"]
336    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
337    #[doc = r" no stolen instances are passed to such software."]
338    pub unsafe fn steal() -> Self {
339        Self {
340            _marker: PhantomData,
341        }
342    }
343}
344impl Deref for TptcA0 {
345    type Target = tptc_a0::RegisterBlock;
346    #[inline(always)]
347    fn deref(&self) -> &Self::Target {
348        unsafe { &*Self::PTR }
349    }
350}
351impl core::fmt::Debug for TptcA0 {
352    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
353        f.debug_struct("TptcA0").finish()
354    }
355}
356#[doc = "Register test environment"]
357pub mod tptc_a0;
358#[doc = "Register test environment"]
359pub struct TptcA1 {
360    _marker: PhantomData<*const ()>,
361}
362unsafe impl Send for TptcA1 {}
363impl TptcA1 {
364    #[doc = r"Pointer to the register block"]
365    pub const PTR: *const tptc_a1::RegisterBlock = 0x5401_0000 as *const _;
366    #[doc = r"Return the pointer to the register block"]
367    #[inline(always)]
368    pub const fn ptr() -> *const tptc_a1::RegisterBlock {
369        Self::PTR
370    }
371    #[doc = r" Steal an instance of this peripheral"]
372    #[doc = r""]
373    #[doc = r" # Safety"]
374    #[doc = r""]
375    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
376    #[doc = r" that may race with any existing instances, for example by only"]
377    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
378    #[doc = r" original peripheral and using critical sections to coordinate"]
379    #[doc = r" access between multiple new instances."]
380    #[doc = r""]
381    #[doc = r" Additionally, other software such as HALs may rely on only one"]
382    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
383    #[doc = r" no stolen instances are passed to such software."]
384    pub unsafe fn steal() -> Self {
385        Self {
386            _marker: PhantomData,
387        }
388    }
389}
390impl Deref for TptcA1 {
391    type Target = tptc_a1::RegisterBlock;
392    #[inline(always)]
393    fn deref(&self) -> &Self::Target {
394        unsafe { &*Self::PTR }
395    }
396}
397impl core::fmt::Debug for TptcA1 {
398    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
399        f.debug_struct("TptcA1").finish()
400    }
401}
402#[doc = "Register test environment"]
403pub mod tptc_a1;
404#[doc = "APP_CRC"]
405pub struct AppCrc {
406    _marker: PhantomData<*const ()>,
407}
408unsafe impl Send for AppCrc {}
409impl AppCrc {
410    #[doc = r"Pointer to the register block"]
411    pub const PTR: *const app_crc::RegisterBlock = 0x5402_0000 as *const _;
412    #[doc = r"Return the pointer to the register block"]
413    #[inline(always)]
414    pub const fn ptr() -> *const app_crc::RegisterBlock {
415        Self::PTR
416    }
417    #[doc = r" Steal an instance of this peripheral"]
418    #[doc = r""]
419    #[doc = r" # Safety"]
420    #[doc = r""]
421    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
422    #[doc = r" that may race with any existing instances, for example by only"]
423    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
424    #[doc = r" original peripheral and using critical sections to coordinate"]
425    #[doc = r" access between multiple new instances."]
426    #[doc = r""]
427    #[doc = r" Additionally, other software such as HALs may rely on only one"]
428    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
429    #[doc = r" no stolen instances are passed to such software."]
430    pub unsafe fn steal() -> Self {
431        Self {
432            _marker: PhantomData,
433        }
434    }
435}
436impl Deref for AppCrc {
437    type Target = app_crc::RegisterBlock;
438    #[inline(always)]
439    fn deref(&self) -> &Self::Target {
440        unsafe { &*Self::PTR }
441    }
442}
443impl core::fmt::Debug for AppCrc {
444    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
445        f.debug_struct("AppCrc").finish()
446    }
447}
448#[doc = "APP_CRC"]
449pub mod app_crc;
450#[doc = "HWA_CFG"]
451pub struct HwaCfg {
452    _marker: PhantomData<*const ()>,
453}
454unsafe impl Send for HwaCfg {}
455impl HwaCfg {
456    #[doc = r"Pointer to the register block"]
457    pub const PTR: *const hwa_cfg::RegisterBlock = 0x5501_0000 as *const _;
458    #[doc = r"Return the pointer to the register block"]
459    #[inline(always)]
460    pub const fn ptr() -> *const hwa_cfg::RegisterBlock {
461        Self::PTR
462    }
463    #[doc = r" Steal an instance of this peripheral"]
464    #[doc = r""]
465    #[doc = r" # Safety"]
466    #[doc = r""]
467    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
468    #[doc = r" that may race with any existing instances, for example by only"]
469    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
470    #[doc = r" original peripheral and using critical sections to coordinate"]
471    #[doc = r" access between multiple new instances."]
472    #[doc = r""]
473    #[doc = r" Additionally, other software such as HALs may rely on only one"]
474    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
475    #[doc = r" no stolen instances are passed to such software."]
476    pub unsafe fn steal() -> Self {
477        Self {
478            _marker: PhantomData,
479        }
480    }
481}
482impl Deref for HwaCfg {
483    type Target = hwa_cfg::RegisterBlock;
484    #[inline(always)]
485    fn deref(&self) -> &Self::Target {
486        unsafe { &*Self::PTR }
487    }
488}
489impl core::fmt::Debug for HwaCfg {
490    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
491        f.debug_struct("HwaCfg").finish()
492    }
493}
494#[doc = "HWA_CFG"]
495pub mod hwa_cfg;
496#[doc = "Register test environment"]
497pub struct TptcB0 {
498    _marker: PhantomData<*const ()>,
499}
500unsafe impl Send for TptcB0 {}
501impl TptcB0 {
502    #[doc = r"Pointer to the register block"]
503    pub const PTR: *const tptc_b0::RegisterBlock = 0x5502_0000 as *const _;
504    #[doc = r"Return the pointer to the register block"]
505    #[inline(always)]
506    pub const fn ptr() -> *const tptc_b0::RegisterBlock {
507        Self::PTR
508    }
509    #[doc = r" Steal an instance of this peripheral"]
510    #[doc = r""]
511    #[doc = r" # Safety"]
512    #[doc = r""]
513    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
514    #[doc = r" that may race with any existing instances, for example by only"]
515    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
516    #[doc = r" original peripheral and using critical sections to coordinate"]
517    #[doc = r" access between multiple new instances."]
518    #[doc = r""]
519    #[doc = r" Additionally, other software such as HALs may rely on only one"]
520    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
521    #[doc = r" no stolen instances are passed to such software."]
522    pub unsafe fn steal() -> Self {
523        Self {
524            _marker: PhantomData,
525        }
526    }
527}
528impl Deref for TptcB0 {
529    type Target = tptc_b0::RegisterBlock;
530    #[inline(always)]
531    fn deref(&self) -> &Self::Target {
532        unsafe { &*Self::PTR }
533    }
534}
535impl core::fmt::Debug for TptcB0 {
536    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
537        f.debug_struct("TptcB0").finish()
538    }
539}
540#[doc = "Register test environment"]
541pub mod tptc_b0;
542#[doc = "Register test environment"]
543pub struct TptcB0_1 {
544    _marker: PhantomData<*const ()>,
545}
546unsafe impl Send for TptcB0_1 {}
547impl TptcB0_1 {
548    #[doc = r"Pointer to the register block"]
549    pub const PTR: *const tptc_b0_1::RegisterBlock = 0x5504_0000 as *const _;
550    #[doc = r"Return the pointer to the register block"]
551    #[inline(always)]
552    pub const fn ptr() -> *const tptc_b0_1::RegisterBlock {
553        Self::PTR
554    }
555    #[doc = r" Steal an instance of this peripheral"]
556    #[doc = r""]
557    #[doc = r" # Safety"]
558    #[doc = r""]
559    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
560    #[doc = r" that may race with any existing instances, for example by only"]
561    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
562    #[doc = r" original peripheral and using critical sections to coordinate"]
563    #[doc = r" access between multiple new instances."]
564    #[doc = r""]
565    #[doc = r" Additionally, other software such as HALs may rely on only one"]
566    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
567    #[doc = r" no stolen instances are passed to such software."]
568    pub unsafe fn steal() -> Self {
569        Self {
570            _marker: PhantomData,
571        }
572    }
573}
574impl Deref for TptcB0_1 {
575    type Target = tptc_b0_1::RegisterBlock;
576    #[inline(always)]
577    fn deref(&self) -> &Self::Target {
578        unsafe { &*Self::PTR }
579    }
580}
581impl core::fmt::Debug for TptcB0_1 {
582    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
583        f.debug_struct("TptcB0_1").finish()
584    }
585}
586#[doc = "Register test environment"]
587pub mod tptc_b0_1;
588#[doc = "TPCC"]
589pub struct TpccB {
590    _marker: PhantomData<*const ()>,
591}
592unsafe impl Send for TpccB {}
593impl TpccB {
594    #[doc = r"Pointer to the register block"]
595    pub const PTR: *const tpcc_b::RegisterBlock = 0x5508_0000 as *const _;
596    #[doc = r"Return the pointer to the register block"]
597    #[inline(always)]
598    pub const fn ptr() -> *const tpcc_b::RegisterBlock {
599        Self::PTR
600    }
601    #[doc = r" Steal an instance of this peripheral"]
602    #[doc = r""]
603    #[doc = r" # Safety"]
604    #[doc = r""]
605    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
606    #[doc = r" that may race with any existing instances, for example by only"]
607    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
608    #[doc = r" original peripheral and using critical sections to coordinate"]
609    #[doc = r" access between multiple new instances."]
610    #[doc = r""]
611    #[doc = r" Additionally, other software such as HALs may rely on only one"]
612    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
613    #[doc = r" no stolen instances are passed to such software."]
614    pub unsafe fn steal() -> Self {
615        Self {
616            _marker: PhantomData,
617        }
618    }
619}
620impl Deref for TpccB {
621    type Target = tpcc_b::RegisterBlock;
622    #[inline(always)]
623    fn deref(&self) -> &Self::Target {
624        unsafe { &*Self::PTR }
625    }
626}
627impl core::fmt::Debug for TpccB {
628    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
629        f.debug_struct("TpccB").finish()
630    }
631}
632#[doc = "TPCC"]
633pub mod tpcc_b;
634#[doc = "TPCC"]
635pub struct TpccA {
636    _marker: PhantomData<*const ()>,
637}
638unsafe impl Send for TpccA {}
639impl TpccA {
640    #[doc = r"Pointer to the register block"]
641    pub const PTR: *const tpcc_a::RegisterBlock = 0x5600_0000 as *const _;
642    #[doc = r"Return the pointer to the register block"]
643    #[inline(always)]
644    pub const fn ptr() -> *const tpcc_a::RegisterBlock {
645        Self::PTR
646    }
647    #[doc = r" Steal an instance of this peripheral"]
648    #[doc = r""]
649    #[doc = r" # Safety"]
650    #[doc = r""]
651    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
652    #[doc = r" that may race with any existing instances, for example by only"]
653    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
654    #[doc = r" original peripheral and using critical sections to coordinate"]
655    #[doc = r" access between multiple new instances."]
656    #[doc = r""]
657    #[doc = r" Additionally, other software such as HALs may rely on only one"]
658    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
659    #[doc = r" no stolen instances are passed to such software."]
660    pub unsafe fn steal() -> Self {
661        Self {
662            _marker: PhantomData,
663        }
664    }
665}
666impl Deref for TpccA {
667    type Target = tpcc_a::RegisterBlock;
668    #[inline(always)]
669    fn deref(&self) -> &Self::Target {
670        unsafe { &*Self::PTR }
671    }
672}
673impl core::fmt::Debug for TpccA {
674    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
675        f.debug_struct("TpccA").finish()
676    }
677}
678#[doc = "TPCC"]
679pub mod tpcc_a;
680#[doc = "APP_RCM"]
681pub struct AppRcm {
682    _marker: PhantomData<*const ()>,
683}
684unsafe impl Send for AppRcm {}
685impl AppRcm {
686    #[doc = r"Pointer to the register block"]
687    pub const PTR: *const app_rcm::RegisterBlock = 0x5604_0000 as *const _;
688    #[doc = r"Return the pointer to the register block"]
689    #[inline(always)]
690    pub const fn ptr() -> *const app_rcm::RegisterBlock {
691        Self::PTR
692    }
693    #[doc = r" Steal an instance of this peripheral"]
694    #[doc = r""]
695    #[doc = r" # Safety"]
696    #[doc = r""]
697    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
698    #[doc = r" that may race with any existing instances, for example by only"]
699    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
700    #[doc = r" original peripheral and using critical sections to coordinate"]
701    #[doc = r" access between multiple new instances."]
702    #[doc = r""]
703    #[doc = r" Additionally, other software such as HALs may rely on only one"]
704    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
705    #[doc = r" no stolen instances are passed to such software."]
706    pub unsafe fn steal() -> Self {
707        Self {
708            _marker: PhantomData,
709        }
710    }
711}
712impl Deref for AppRcm {
713    type Target = app_rcm::RegisterBlock;
714    #[inline(always)]
715    fn deref(&self) -> &Self::Target {
716        unsafe { &*Self::PTR }
717    }
718}
719impl core::fmt::Debug for AppRcm {
720    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
721        f.debug_struct("AppRcm").finish()
722    }
723}
724#[doc = "APP_RCM"]
725pub mod app_rcm;
726#[doc = "APP_CTRL"]
727pub struct AppCtrl {
728    _marker: PhantomData<*const ()>,
729}
730unsafe impl Send for AppCtrl {}
731impl AppCtrl {
732    #[doc = r"Pointer to the register block"]
733    pub const PTR: *const app_ctrl::RegisterBlock = 0x5606_0000 as *const _;
734    #[doc = r"Return the pointer to the register block"]
735    #[inline(always)]
736    pub const fn ptr() -> *const app_ctrl::RegisterBlock {
737        Self::PTR
738    }
739    #[doc = r" Steal an instance of this peripheral"]
740    #[doc = r""]
741    #[doc = r" # Safety"]
742    #[doc = r""]
743    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
744    #[doc = r" that may race with any existing instances, for example by only"]
745    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
746    #[doc = r" original peripheral and using critical sections to coordinate"]
747    #[doc = r" access between multiple new instances."]
748    #[doc = r""]
749    #[doc = r" Additionally, other software such as HALs may rely on only one"]
750    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
751    #[doc = r" no stolen instances are passed to such software."]
752    pub unsafe fn steal() -> Self {
753        Self {
754            _marker: PhantomData,
755        }
756    }
757}
758impl Deref for AppCtrl {
759    type Target = app_ctrl::RegisterBlock;
760    #[inline(always)]
761    fn deref(&self) -> &Self::Target {
762        unsafe { &*Self::PTR }
763    }
764}
765impl core::fmt::Debug for AppCtrl {
766    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
767        f.debug_struct("AppCtrl").finish()
768    }
769}
770#[doc = "APP_CTRL"]
771pub mod app_ctrl;
772#[doc = "APP_HWA_ADCBUF_CTRL"]
773pub struct AppHwaAdcbufCtrl {
774    _marker: PhantomData<*const ()>,
775}
776unsafe impl Send for AppHwaAdcbufCtrl {}
777impl AppHwaAdcbufCtrl {
778    #[doc = r"Pointer to the register block"]
779    pub const PTR: *const app_hwa_adcbuf_ctrl::RegisterBlock = 0x5608_0000 as *const _;
780    #[doc = r"Return the pointer to the register block"]
781    #[inline(always)]
782    pub const fn ptr() -> *const app_hwa_adcbuf_ctrl::RegisterBlock {
783        Self::PTR
784    }
785    #[doc = r" Steal an instance of this peripheral"]
786    #[doc = r""]
787    #[doc = r" # Safety"]
788    #[doc = r""]
789    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
790    #[doc = r" that may race with any existing instances, for example by only"]
791    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
792    #[doc = r" original peripheral and using critical sections to coordinate"]
793    #[doc = r" access between multiple new instances."]
794    #[doc = r""]
795    #[doc = r" Additionally, other software such as HALs may rely on only one"]
796    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
797    #[doc = r" no stolen instances are passed to such software."]
798    pub unsafe fn steal() -> Self {
799        Self {
800            _marker: PhantomData,
801        }
802    }
803}
804impl Deref for AppHwaAdcbufCtrl {
805    type Target = app_hwa_adcbuf_ctrl::RegisterBlock;
806    #[inline(always)]
807    fn deref(&self) -> &Self::Target {
808        unsafe { &*Self::PTR }
809    }
810}
811impl core::fmt::Debug for AppHwaAdcbufCtrl {
812    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
813        f.debug_struct("AppHwaAdcbufCtrl").finish()
814    }
815}
816#[doc = "APP_HWA_ADCBUF_CTRL"]
817pub mod app_hwa_adcbuf_ctrl;
818#[doc = "APP_ECC_AGG"]
819pub struct AppEccAgg {
820    _marker: PhantomData<*const ()>,
821}
822unsafe impl Send for AppEccAgg {}
823impl AppEccAgg {
824    #[doc = r"Pointer to the register block"]
825    pub const PTR: *const app_ecc_agg::RegisterBlock = 0x56f7_ec00 as *const _;
826    #[doc = r"Return the pointer to the register block"]
827    #[inline(always)]
828    pub const fn ptr() -> *const app_ecc_agg::RegisterBlock {
829        Self::PTR
830    }
831    #[doc = r" Steal an instance of this peripheral"]
832    #[doc = r""]
833    #[doc = r" # Safety"]
834    #[doc = r""]
835    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
836    #[doc = r" that may race with any existing instances, for example by only"]
837    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
838    #[doc = r" original peripheral and using critical sections to coordinate"]
839    #[doc = r" access between multiple new instances."]
840    #[doc = r""]
841    #[doc = r" Additionally, other software such as HALs may rely on only one"]
842    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
843    #[doc = r" no stolen instances are passed to such software."]
844    pub unsafe fn steal() -> Self {
845        Self {
846            _marker: PhantomData,
847        }
848    }
849}
850impl Deref for AppEccAgg {
851    type Target = app_ecc_agg::RegisterBlock;
852    #[inline(always)]
853    fn deref(&self) -> &Self::Target {
854        unsafe { &*Self::PTR }
855    }
856}
857impl core::fmt::Debug for AppEccAgg {
858    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
859        f.debug_struct("AppEccAgg").finish()
860    }
861}
862#[doc = "APP_ECC_AGG"]
863pub mod app_ecc_agg;
864#[doc = "APP_RTI"]
865pub struct AppRti {
866    _marker: PhantomData<*const ()>,
867}
868unsafe impl Send for AppRti {}
869impl AppRti {
870    #[doc = r"Pointer to the register block"]
871    pub const PTR: *const app_rti::RegisterBlock = 0x56f7_f000 as *const _;
872    #[doc = r"Return the pointer to the register block"]
873    #[inline(always)]
874    pub const fn ptr() -> *const app_rti::RegisterBlock {
875        Self::PTR
876    }
877    #[doc = r" Steal an instance of this peripheral"]
878    #[doc = r""]
879    #[doc = r" # Safety"]
880    #[doc = r""]
881    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
882    #[doc = r" that may race with any existing instances, for example by only"]
883    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
884    #[doc = r" original peripheral and using critical sections to coordinate"]
885    #[doc = r" access between multiple new instances."]
886    #[doc = r""]
887    #[doc = r" Additionally, other software such as HALs may rely on only one"]
888    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
889    #[doc = r" no stolen instances are passed to such software."]
890    pub unsafe fn steal() -> Self {
891        Self {
892            _marker: PhantomData,
893        }
894    }
895}
896impl Deref for AppRti {
897    type Target = app_rti::RegisterBlock;
898    #[inline(always)]
899    fn deref(&self) -> &Self::Target {
900        unsafe { &*Self::PTR }
901    }
902}
903impl core::fmt::Debug for AppRti {
904    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
905        f.debug_struct("AppRti").finish()
906    }
907}
908#[doc = "APP_RTI"]
909pub mod app_rti;
910#[doc = "APP_WD"]
911pub struct AppWd {
912    _marker: PhantomData<*const ()>,
913}
914unsafe impl Send for AppWd {}
915impl AppWd {
916    #[doc = r"Pointer to the register block"]
917    pub const PTR: *const app_wd::RegisterBlock = 0x56f7_f400 as *const _;
918    #[doc = r"Return the pointer to the register block"]
919    #[inline(always)]
920    pub const fn ptr() -> *const app_wd::RegisterBlock {
921        Self::PTR
922    }
923    #[doc = r" Steal an instance of this peripheral"]
924    #[doc = r""]
925    #[doc = r" # Safety"]
926    #[doc = r""]
927    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
928    #[doc = r" that may race with any existing instances, for example by only"]
929    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
930    #[doc = r" original peripheral and using critical sections to coordinate"]
931    #[doc = r" access between multiple new instances."]
932    #[doc = r""]
933    #[doc = r" Additionally, other software such as HALs may rely on only one"]
934    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
935    #[doc = r" no stolen instances are passed to such software."]
936    pub unsafe fn steal() -> Self {
937        Self {
938            _marker: PhantomData,
939        }
940    }
941}
942impl Deref for AppWd {
943    type Target = app_wd::RegisterBlock;
944    #[inline(always)]
945    fn deref(&self) -> &Self::Target {
946        unsafe { &*Self::PTR }
947    }
948}
949impl core::fmt::Debug for AppWd {
950    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
951        f.debug_struct("AppWd").finish()
952    }
953}
954#[doc = "APP_WD"]
955pub mod app_wd;
956#[doc = "APP_DCC"]
957pub struct AppDcc {
958    _marker: PhantomData<*const ()>,
959}
960unsafe impl Send for AppDcc {}
961impl AppDcc {
962    #[doc = r"Pointer to the register block"]
963    pub const PTR: *const app_dcc::RegisterBlock = 0x56f7_f800 as *const _;
964    #[doc = r"Return the pointer to the register block"]
965    #[inline(always)]
966    pub const fn ptr() -> *const app_dcc::RegisterBlock {
967        Self::PTR
968    }
969    #[doc = r" Steal an instance of this peripheral"]
970    #[doc = r""]
971    #[doc = r" # Safety"]
972    #[doc = r""]
973    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
974    #[doc = r" that may race with any existing instances, for example by only"]
975    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
976    #[doc = r" original peripheral and using critical sections to coordinate"]
977    #[doc = r" access between multiple new instances."]
978    #[doc = r""]
979    #[doc = r" Additionally, other software such as HALs may rely on only one"]
980    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
981    #[doc = r" no stolen instances are passed to such software."]
982    pub unsafe fn steal() -> Self {
983        Self {
984            _marker: PhantomData,
985        }
986    }
987}
988impl Deref for AppDcc {
989    type Target = app_dcc::RegisterBlock;
990    #[inline(always)]
991    fn deref(&self) -> &Self::Target {
992        unsafe { &*Self::PTR }
993    }
994}
995impl core::fmt::Debug for AppDcc {
996    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
997        f.debug_struct("AppDcc").finish()
998    }
999}
1000#[doc = "APP_DCC"]
1001pub mod app_dcc;
1002#[doc = "APP_ESM"]
1003pub struct AppEsm {
1004    _marker: PhantomData<*const ()>,
1005}
1006unsafe impl Send for AppEsm {}
1007impl AppEsm {
1008    #[doc = r"Pointer to the register block"]
1009    pub const PTR: *const app_esm::RegisterBlock = 0x56f7_fc00 as *const _;
1010    #[doc = r"Return the pointer to the register block"]
1011    #[inline(always)]
1012    pub const fn ptr() -> *const app_esm::RegisterBlock {
1013        Self::PTR
1014    }
1015    #[doc = r" Steal an instance of this peripheral"]
1016    #[doc = r""]
1017    #[doc = r" # Safety"]
1018    #[doc = r""]
1019    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1020    #[doc = r" that may race with any existing instances, for example by only"]
1021    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1022    #[doc = r" original peripheral and using critical sections to coordinate"]
1023    #[doc = r" access between multiple new instances."]
1024    #[doc = r""]
1025    #[doc = r" Additionally, other software such as HALs may rely on only one"]
1026    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1027    #[doc = r" no stolen instances are passed to such software."]
1028    pub unsafe fn steal() -> Self {
1029        Self {
1030            _marker: PhantomData,
1031        }
1032    }
1033}
1034impl Deref for AppEsm {
1035    type Target = app_esm::RegisterBlock;
1036    #[inline(always)]
1037    fn deref(&self) -> &Self::Target {
1038        unsafe { &*Self::PTR }
1039    }
1040}
1041impl core::fmt::Debug for AppEsm {
1042    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1043        f.debug_struct("AppEsm").finish()
1044    }
1045}
1046#[doc = "APP_ESM"]
1047pub mod app_esm;
1048#[doc = "APP_UART"]
1049pub struct AppUart1 {
1050    _marker: PhantomData<*const ()>,
1051}
1052unsafe impl Send for AppUart1 {}
1053impl AppUart1 {
1054    #[doc = r"Pointer to the register block"]
1055    pub const PTR: *const app_uart_1::RegisterBlock = 0x57f7_f000 as *const _;
1056    #[doc = r"Return the pointer to the register block"]
1057    #[inline(always)]
1058    pub const fn ptr() -> *const app_uart_1::RegisterBlock {
1059        Self::PTR
1060    }
1061    #[doc = r" Steal an instance of this peripheral"]
1062    #[doc = r""]
1063    #[doc = r" # Safety"]
1064    #[doc = r""]
1065    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1066    #[doc = r" that may race with any existing instances, for example by only"]
1067    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1068    #[doc = r" original peripheral and using critical sections to coordinate"]
1069    #[doc = r" access between multiple new instances."]
1070    #[doc = r""]
1071    #[doc = r" Additionally, other software such as HALs may rely on only one"]
1072    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1073    #[doc = r" no stolen instances are passed to such software."]
1074    pub unsafe fn steal() -> Self {
1075        Self {
1076            _marker: PhantomData,
1077        }
1078    }
1079}
1080impl Deref for AppUart1 {
1081    type Target = app_uart_1::RegisterBlock;
1082    #[inline(always)]
1083    fn deref(&self) -> &Self::Target {
1084        unsafe { &*Self::PTR }
1085    }
1086}
1087impl core::fmt::Debug for AppUart1 {
1088    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1089        f.debug_struct("AppUart1").finish()
1090    }
1091}
1092#[doc = "APP_UART"]
1093pub mod app_uart_1;
1094#[doc = "APP_SPI"]
1095pub struct AppSpi1 {
1096    _marker: PhantomData<*const ()>,
1097}
1098unsafe impl Send for AppSpi1 {}
1099impl AppSpi1 {
1100    #[doc = r"Pointer to the register block"]
1101    pub const PTR: *const app_spi_1::RegisterBlock = 0x57f7_f400 as *const _;
1102    #[doc = r"Return the pointer to the register block"]
1103    #[inline(always)]
1104    pub const fn ptr() -> *const app_spi_1::RegisterBlock {
1105        Self::PTR
1106    }
1107    #[doc = r" Steal an instance of this peripheral"]
1108    #[doc = r""]
1109    #[doc = r" # Safety"]
1110    #[doc = r""]
1111    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1112    #[doc = r" that may race with any existing instances, for example by only"]
1113    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1114    #[doc = r" original peripheral and using critical sections to coordinate"]
1115    #[doc = r" access between multiple new instances."]
1116    #[doc = r""]
1117    #[doc = r" Additionally, other software such as HALs may rely on only one"]
1118    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1119    #[doc = r" no stolen instances are passed to such software."]
1120    pub unsafe fn steal() -> Self {
1121        Self {
1122            _marker: PhantomData,
1123        }
1124    }
1125}
1126impl Deref for AppSpi1 {
1127    type Target = app_spi_1::RegisterBlock;
1128    #[inline(always)]
1129    fn deref(&self) -> &Self::Target {
1130        unsafe { &*Self::PTR }
1131    }
1132}
1133impl core::fmt::Debug for AppSpi1 {
1134    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1135        f.debug_struct("AppSpi1").finish()
1136    }
1137}
1138#[doc = "APP_SPI"]
1139pub mod app_spi_1;
1140#[doc = "APP_I2C"]
1141pub struct AppI2c {
1142    _marker: PhantomData<*const ()>,
1143}
1144unsafe impl Send for AppI2c {}
1145impl AppI2c {
1146    #[doc = r"Pointer to the register block"]
1147    pub const PTR: *const app_i2c::RegisterBlock = 0x57f7_f800 as *const _;
1148    #[doc = r"Return the pointer to the register block"]
1149    #[inline(always)]
1150    pub const fn ptr() -> *const app_i2c::RegisterBlock {
1151        Self::PTR
1152    }
1153    #[doc = r" Steal an instance of this peripheral"]
1154    #[doc = r""]
1155    #[doc = r" # Safety"]
1156    #[doc = r""]
1157    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1158    #[doc = r" that may race with any existing instances, for example by only"]
1159    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1160    #[doc = r" original peripheral and using critical sections to coordinate"]
1161    #[doc = r" access between multiple new instances."]
1162    #[doc = r""]
1163    #[doc = r" Additionally, other software such as HALs may rely on only one"]
1164    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1165    #[doc = r" no stolen instances are passed to such software."]
1166    pub unsafe fn steal() -> Self {
1167        Self {
1168            _marker: PhantomData,
1169        }
1170    }
1171}
1172impl Deref for AppI2c {
1173    type Target = app_i2c::RegisterBlock;
1174    #[inline(always)]
1175    fn deref(&self) -> &Self::Target {
1176        unsafe { &*Self::PTR }
1177    }
1178}
1179impl core::fmt::Debug for AppI2c {
1180    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1181        f.debug_struct("AppI2c").finish()
1182    }
1183}
1184#[doc = "APP_I2C"]
1185pub mod app_i2c;
1186#[doc = "APP_PWM"]
1187pub struct AppPwm {
1188    _marker: PhantomData<*const ()>,
1189}
1190unsafe impl Send for AppPwm {}
1191impl AppPwm {
1192    #[doc = r"Pointer to the register block"]
1193    pub const PTR: *const app_pwm::RegisterBlock = 0x57f7_fc00 as *const _;
1194    #[doc = r"Return the pointer to the register block"]
1195    #[inline(always)]
1196    pub const fn ptr() -> *const app_pwm::RegisterBlock {
1197        Self::PTR
1198    }
1199    #[doc = r" Steal an instance of this peripheral"]
1200    #[doc = r""]
1201    #[doc = r" # Safety"]
1202    #[doc = r""]
1203    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1204    #[doc = r" that may race with any existing instances, for example by only"]
1205    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1206    #[doc = r" original peripheral and using critical sections to coordinate"]
1207    #[doc = r" access between multiple new instances."]
1208    #[doc = r""]
1209    #[doc = r" Additionally, other software such as HALs may rely on only one"]
1210    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1211    #[doc = r" no stolen instances are passed to such software."]
1212    pub unsafe fn steal() -> Self {
1213        Self {
1214            _marker: PhantomData,
1215        }
1216    }
1217}
1218impl Deref for AppPwm {
1219    type Target = app_pwm::RegisterBlock;
1220    #[inline(always)]
1221    fn deref(&self) -> &Self::Target {
1222        unsafe { &*Self::PTR }
1223    }
1224}
1225impl core::fmt::Debug for AppPwm {
1226    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1227        f.debug_struct("AppPwm").finish()
1228    }
1229}
1230#[doc = "APP_PWM"]
1231pub mod app_pwm;
1232#[doc = "TOP_IO_MUX"]
1233pub struct TopIoMux {
1234    _marker: PhantomData<*const ()>,
1235}
1236unsafe impl Send for TopIoMux {}
1237impl TopIoMux {
1238    #[doc = r"Pointer to the register block"]
1239    pub const PTR: *const top_io_mux::RegisterBlock = 0x5a00_0000 as *const _;
1240    #[doc = r"Return the pointer to the register block"]
1241    #[inline(always)]
1242    pub const fn ptr() -> *const top_io_mux::RegisterBlock {
1243        Self::PTR
1244    }
1245    #[doc = r" Steal an instance of this peripheral"]
1246    #[doc = r""]
1247    #[doc = r" # Safety"]
1248    #[doc = r""]
1249    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1250    #[doc = r" that may race with any existing instances, for example by only"]
1251    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1252    #[doc = r" original peripheral and using critical sections to coordinate"]
1253    #[doc = r" access between multiple new instances."]
1254    #[doc = r""]
1255    #[doc = r" Additionally, other software such as HALs may rely on only one"]
1256    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1257    #[doc = r" no stolen instances are passed to such software."]
1258    pub unsafe fn steal() -> Self {
1259        Self {
1260            _marker: PhantomData,
1261        }
1262    }
1263}
1264impl Deref for TopIoMux {
1265    type Target = top_io_mux::RegisterBlock;
1266    #[inline(always)]
1267    fn deref(&self) -> &Self::Target {
1268        unsafe { &*Self::PTR }
1269    }
1270}
1271impl core::fmt::Debug for TopIoMux {
1272    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1273        f.debug_struct("TopIoMux").finish()
1274    }
1275}
1276#[doc = "TOP_IO_MUX"]
1277pub mod top_io_mux;
1278#[doc = "APP_PRCM"]
1279pub struct AppPrcm {
1280    _marker: PhantomData<*const ()>,
1281}
1282unsafe impl Send for AppPrcm {}
1283impl AppPrcm {
1284    #[doc = r"Pointer to the register block"]
1285    pub const PTR: *const app_prcm::RegisterBlock = 0x5a04_0000 as *const _;
1286    #[doc = r"Return the pointer to the register block"]
1287    #[inline(always)]
1288    pub const fn ptr() -> *const app_prcm::RegisterBlock {
1289        Self::PTR
1290    }
1291    #[doc = r" Steal an instance of this peripheral"]
1292    #[doc = r""]
1293    #[doc = r" # Safety"]
1294    #[doc = r""]
1295    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1296    #[doc = r" that may race with any existing instances, for example by only"]
1297    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1298    #[doc = r" original peripheral and using critical sections to coordinate"]
1299    #[doc = r" access between multiple new instances."]
1300    #[doc = r""]
1301    #[doc = r" Additionally, other software such as HALs may rely on only one"]
1302    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1303    #[doc = r" no stolen instances are passed to such software."]
1304    pub unsafe fn steal() -> Self {
1305        Self {
1306            _marker: PhantomData,
1307        }
1308    }
1309}
1310impl Deref for AppPrcm {
1311    type Target = app_prcm::RegisterBlock;
1312    #[inline(always)]
1313    fn deref(&self) -> &Self::Target {
1314        unsafe { &*Self::PTR }
1315    }
1316}
1317impl core::fmt::Debug for AppPrcm {
1318    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1319        f.debug_struct("AppPrcm").finish()
1320    }
1321}
1322#[doc = "APP_PRCM"]
1323pub mod app_prcm;
1324#[doc = "TOP_GIO"]
1325pub struct TopGio {
1326    _marker: PhantomData<*const ()>,
1327}
1328unsafe impl Send for TopGio {}
1329impl TopGio {
1330    #[doc = r"Pointer to the register block"]
1331    pub const PTR: *const top_gio::RegisterBlock = 0x5af7_fc00 as *const _;
1332    #[doc = r"Return the pointer to the register block"]
1333    #[inline(always)]
1334    pub const fn ptr() -> *const top_gio::RegisterBlock {
1335        Self::PTR
1336    }
1337    #[doc = r" Steal an instance of this peripheral"]
1338    #[doc = r""]
1339    #[doc = r" # Safety"]
1340    #[doc = r""]
1341    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1342    #[doc = r" that may race with any existing instances, for example by only"]
1343    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1344    #[doc = r" original peripheral and using critical sections to coordinate"]
1345    #[doc = r" access between multiple new instances."]
1346    #[doc = r""]
1347    #[doc = r" Additionally, other software such as HALs may rely on only one"]
1348    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1349    #[doc = r" no stolen instances are passed to such software."]
1350    pub unsafe fn steal() -> Self {
1351        Self {
1352            _marker: PhantomData,
1353        }
1354    }
1355}
1356impl Deref for TopGio {
1357    type Target = top_gio::RegisterBlock;
1358    #[inline(always)]
1359    fn deref(&self) -> &Self::Target {
1360        unsafe { &*Self::PTR }
1361    }
1362}
1363impl core::fmt::Debug for TopGio {
1364    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1365        f.debug_struct("TopGio").finish()
1366    }
1367}
1368#[doc = "TOP_GIO"]
1369pub mod top_gio;
1370#[doc = "TOPSS_CTRL"]
1371pub struct TopssCtrl {
1372    _marker: PhantomData<*const ()>,
1373}
1374unsafe impl Send for TopssCtrl {}
1375impl TopssCtrl {
1376    #[doc = r"Pointer to the register block"]
1377    pub const PTR: *const topss_ctrl::RegisterBlock = 0x5b02_0000 as *const _;
1378    #[doc = r"Return the pointer to the register block"]
1379    #[inline(always)]
1380    pub const fn ptr() -> *const topss_ctrl::RegisterBlock {
1381        Self::PTR
1382    }
1383    #[doc = r" Steal an instance of this peripheral"]
1384    #[doc = r""]
1385    #[doc = r" # Safety"]
1386    #[doc = r""]
1387    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1388    #[doc = r" that may race with any existing instances, for example by only"]
1389    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1390    #[doc = r" original peripheral and using critical sections to coordinate"]
1391    #[doc = r" access between multiple new instances."]
1392    #[doc = r""]
1393    #[doc = r" Additionally, other software such as HALs may rely on only one"]
1394    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1395    #[doc = r" no stolen instances are passed to such software."]
1396    pub unsafe fn steal() -> Self {
1397        Self {
1398            _marker: PhantomData,
1399        }
1400    }
1401}
1402impl Deref for TopssCtrl {
1403    type Target = topss_ctrl::RegisterBlock;
1404    #[inline(always)]
1405    fn deref(&self) -> &Self::Target {
1406        unsafe { &*Self::PTR }
1407    }
1408}
1409impl core::fmt::Debug for TopssCtrl {
1410    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1411        f.debug_struct("TopssCtrl").finish()
1412    }
1413}
1414#[doc = "TOPSS_CTRL"]
1415pub mod topss_ctrl;
1416#[doc = "PLLDIG_CTRL"]
1417pub struct PlldigCtrl {
1418    _marker: PhantomData<*const ()>,
1419}
1420unsafe impl Send for PlldigCtrl {}
1421impl PlldigCtrl {
1422    #[doc = r"Pointer to the register block"]
1423    pub const PTR: *const plldig_ctrl::RegisterBlock = 0x5b04_0000 as *const _;
1424    #[doc = r"Return the pointer to the register block"]
1425    #[inline(always)]
1426    pub const fn ptr() -> *const plldig_ctrl::RegisterBlock {
1427        Self::PTR
1428    }
1429    #[doc = r" Steal an instance of this peripheral"]
1430    #[doc = r""]
1431    #[doc = r" # Safety"]
1432    #[doc = r""]
1433    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1434    #[doc = r" that may race with any existing instances, for example by only"]
1435    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1436    #[doc = r" original peripheral and using critical sections to coordinate"]
1437    #[doc = r" access between multiple new instances."]
1438    #[doc = r""]
1439    #[doc = r" Additionally, other software such as HALs may rely on only one"]
1440    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1441    #[doc = r" no stolen instances are passed to such software."]
1442    pub unsafe fn steal() -> Self {
1443        Self {
1444            _marker: PhantomData,
1445        }
1446    }
1447}
1448impl Deref for PlldigCtrl {
1449    type Target = plldig_ctrl::RegisterBlock;
1450    #[inline(always)]
1451    fn deref(&self) -> &Self::Target {
1452        unsafe { &*Self::PTR }
1453    }
1454}
1455impl core::fmt::Debug for PlldigCtrl {
1456    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1457        f.debug_struct("PlldigCtrl").finish()
1458    }
1459}
1460#[doc = "PLLDIG_CTRL"]
1461pub mod plldig_ctrl;
1462#[doc = "PBIST"]
1463pub struct Pbist {
1464    _marker: PhantomData<*const ()>,
1465}
1466unsafe impl Send for Pbist {}
1467impl Pbist {
1468    #[doc = r"Pointer to the register block"]
1469    pub const PTR: *const pbist::RegisterBlock = 0x5c02_0000 as *const _;
1470    #[doc = r"Return the pointer to the register block"]
1471    #[inline(always)]
1472    pub const fn ptr() -> *const pbist::RegisterBlock {
1473        Self::PTR
1474    }
1475    #[doc = r" Steal an instance of this peripheral"]
1476    #[doc = r""]
1477    #[doc = r" # Safety"]
1478    #[doc = r""]
1479    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1480    #[doc = r" that may race with any existing instances, for example by only"]
1481    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1482    #[doc = r" original peripheral and using critical sections to coordinate"]
1483    #[doc = r" access between multiple new instances."]
1484    #[doc = r""]
1485    #[doc = r" Additionally, other software such as HALs may rely on only one"]
1486    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1487    #[doc = r" no stolen instances are passed to such software."]
1488    pub unsafe fn steal() -> Self {
1489        Self {
1490            _marker: PhantomData,
1491        }
1492    }
1493}
1494impl Deref for Pbist {
1495    type Target = pbist::RegisterBlock;
1496    #[inline(always)]
1497    fn deref(&self) -> &Self::Target {
1498        unsafe { &*Self::PTR }
1499    }
1500}
1501impl core::fmt::Debug for Pbist {
1502    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1503        f.debug_struct("Pbist").finish()
1504    }
1505}
1506#[doc = "PBIST"]
1507pub mod pbist;
1508#[doc = "TOP_DEBUGSS"]
1509pub struct TopDebugss {
1510    _marker: PhantomData<*const ()>,
1511}
1512unsafe impl Send for TopDebugss {}
1513impl TopDebugss {
1514    #[doc = r"Pointer to the register block"]
1515    pub const PTR: *const top_debugss::RegisterBlock = 0x5ca0_0000 as *const _;
1516    #[doc = r"Return the pointer to the register block"]
1517    #[inline(always)]
1518    pub const fn ptr() -> *const top_debugss::RegisterBlock {
1519        Self::PTR
1520    }
1521    #[doc = r" Steal an instance of this peripheral"]
1522    #[doc = r""]
1523    #[doc = r" # Safety"]
1524    #[doc = r""]
1525    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1526    #[doc = r" that may race with any existing instances, for example by only"]
1527    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1528    #[doc = r" original peripheral and using critical sections to coordinate"]
1529    #[doc = r" access between multiple new instances."]
1530    #[doc = r""]
1531    #[doc = r" Additionally, other software such as HALs may rely on only one"]
1532    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1533    #[doc = r" no stolen instances are passed to such software."]
1534    pub unsafe fn steal() -> Self {
1535        Self {
1536            _marker: PhantomData,
1537        }
1538    }
1539}
1540impl Deref for TopDebugss {
1541    type Target = top_debugss::RegisterBlock;
1542    #[inline(always)]
1543    fn deref(&self) -> &Self::Target {
1544        unsafe { &*Self::PTR }
1545    }
1546}
1547impl core::fmt::Debug for TopDebugss {
1548    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1549        f.debug_struct("TopDebugss").finish()
1550    }
1551}
1552#[doc = "TOP_DEBUGSS"]
1553pub mod top_debugss;
1554#[doc = "APP_CFG_QSPI"]
1555pub struct AppCfgQspi {
1556    _marker: PhantomData<*const ()>,
1557}
1558unsafe impl Send for AppCfgQspi {}
1559impl AppCfgQspi {
1560    #[doc = r"Pointer to the register block"]
1561    pub const PTR: *const app_cfg_qspi::RegisterBlock = 0x7800_0000 as *const _;
1562    #[doc = r"Return the pointer to the register block"]
1563    #[inline(always)]
1564    pub const fn ptr() -> *const app_cfg_qspi::RegisterBlock {
1565        Self::PTR
1566    }
1567    #[doc = r" Steal an instance of this peripheral"]
1568    #[doc = r""]
1569    #[doc = r" # Safety"]
1570    #[doc = r""]
1571    #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1572    #[doc = r" that may race with any existing instances, for example by only"]
1573    #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1574    #[doc = r" original peripheral and using critical sections to coordinate"]
1575    #[doc = r" access between multiple new instances."]
1576    #[doc = r""]
1577    #[doc = r" Additionally, other software such as HALs may rely on only one"]
1578    #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1579    #[doc = r" no stolen instances are passed to such software."]
1580    pub unsafe fn steal() -> Self {
1581        Self {
1582            _marker: PhantomData,
1583        }
1584    }
1585}
1586impl Deref for AppCfgQspi {
1587    type Target = app_cfg_qspi::RegisterBlock;
1588    #[inline(always)]
1589    fn deref(&self) -> &Self::Target {
1590        unsafe { &*Self::PTR }
1591    }
1592}
1593impl core::fmt::Debug for AppCfgQspi {
1594    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1595        f.debug_struct("AppCfgQspi").finish()
1596    }
1597}
1598#[doc = "APP_CFG_QSPI"]
1599pub mod app_cfg_qspi;
1600#[no_mangle]
1601static mut DEVICE_PERIPHERALS: bool = false;
1602#[doc = r" All the peripherals."]
1603#[allow(non_snake_case)]
1604pub struct Peripherals {
1605    #[doc = "GPADC_CTRL"]
1606    pub gpadc_ctrl: GpadcCtrl,
1607    #[doc = "APP_LIN"]
1608    pub app_lin: AppLin,
1609    #[doc = "APP_UART_0"]
1610    pub app_uart_0: AppUart0,
1611    #[doc = "APP_SPI_0"]
1612    pub app_spi_0: AppSpi0,
1613    #[doc = "APP_CANCFG"]
1614    pub app_cancfg: AppCancfg,
1615    #[doc = "APP_CANECC"]
1616    pub app_canecc: AppCanecc,
1617    #[doc = "TPTC_A0"]
1618    pub tptc_a0: TptcA0,
1619    #[doc = "TPTC_A1"]
1620    pub tptc_a1: TptcA1,
1621    #[doc = "APP_CRC"]
1622    pub app_crc: AppCrc,
1623    #[doc = "HWA_CFG"]
1624    pub hwa_cfg: HwaCfg,
1625    #[doc = "TPTC_B0"]
1626    pub tptc_b0: TptcB0,
1627    #[doc = "TPTC_B0_1"]
1628    pub tptc_b0_1: TptcB0_1,
1629    #[doc = "TPCC_B"]
1630    pub tpcc_b: TpccB,
1631    #[doc = "TPCC_A"]
1632    pub tpcc_a: TpccA,
1633    #[doc = "APP_RCM"]
1634    pub app_rcm: AppRcm,
1635    #[doc = "APP_CTRL"]
1636    pub app_ctrl: AppCtrl,
1637    #[doc = "APP_HWA_ADCBUF_CTRL"]
1638    pub app_hwa_adcbuf_ctrl: AppHwaAdcbufCtrl,
1639    #[doc = "APP_ECC_AGG"]
1640    pub app_ecc_agg: AppEccAgg,
1641    #[doc = "APP_RTI"]
1642    pub app_rti: AppRti,
1643    #[doc = "APP_WD"]
1644    pub app_wd: AppWd,
1645    #[doc = "APP_DCC"]
1646    pub app_dcc: AppDcc,
1647    #[doc = "APP_ESM"]
1648    pub app_esm: AppEsm,
1649    #[doc = "APP_UART_1"]
1650    pub app_uart_1: AppUart1,
1651    #[doc = "APP_SPI_1"]
1652    pub app_spi_1: AppSpi1,
1653    #[doc = "APP_I2C"]
1654    pub app_i2c: AppI2c,
1655    #[doc = "APP_PWM"]
1656    pub app_pwm: AppPwm,
1657    #[doc = "TOP_IO_MUX"]
1658    pub top_io_mux: TopIoMux,
1659    #[doc = "APP_PRCM"]
1660    pub app_prcm: AppPrcm,
1661    #[doc = "TOP_GIO"]
1662    pub top_gio: TopGio,
1663    #[doc = "TOPSS_CTRL"]
1664    pub topss_ctrl: TopssCtrl,
1665    #[doc = "PLLDIG_CTRL"]
1666    pub plldig_ctrl: PlldigCtrl,
1667    #[doc = "PBIST"]
1668    pub pbist: Pbist,
1669    #[doc = "TOP_DEBUGSS"]
1670    pub top_debugss: TopDebugss,
1671    #[doc = "APP_CFG_QSPI"]
1672    pub app_cfg_qspi: AppCfgQspi,
1673}
1674impl Peripherals {
1675    #[doc = r" Returns all the peripherals *once*."]
1676    #[cfg(feature = "critical-section")]
1677    #[inline]
1678    pub fn take() -> Option<Self> {
1679        critical_section::with(|_| {
1680            if unsafe { DEVICE_PERIPHERALS } {
1681                return None;
1682            }
1683            Some(unsafe { Peripherals::steal() })
1684        })
1685    }
1686    #[doc = r" Unchecked version of `Peripherals::take`."]
1687    #[doc = r""]
1688    #[doc = r" # Safety"]
1689    #[doc = r""]
1690    #[doc = r" Each of the returned peripherals must be used at most once."]
1691    #[inline]
1692    pub unsafe fn steal() -> Self {
1693        DEVICE_PERIPHERALS = true;
1694        Peripherals {
1695            gpadc_ctrl: GpadcCtrl::steal(),
1696            app_lin: AppLin::steal(),
1697            app_uart_0: AppUart0::steal(),
1698            app_spi_0: AppSpi0::steal(),
1699            app_cancfg: AppCancfg::steal(),
1700            app_canecc: AppCanecc::steal(),
1701            tptc_a0: TptcA0::steal(),
1702            tptc_a1: TptcA1::steal(),
1703            app_crc: AppCrc::steal(),
1704            hwa_cfg: HwaCfg::steal(),
1705            tptc_b0: TptcB0::steal(),
1706            tptc_b0_1: TptcB0_1::steal(),
1707            tpcc_b: TpccB::steal(),
1708            tpcc_a: TpccA::steal(),
1709            app_rcm: AppRcm::steal(),
1710            app_ctrl: AppCtrl::steal(),
1711            app_hwa_adcbuf_ctrl: AppHwaAdcbufCtrl::steal(),
1712            app_ecc_agg: AppEccAgg::steal(),
1713            app_rti: AppRti::steal(),
1714            app_wd: AppWd::steal(),
1715            app_dcc: AppDcc::steal(),
1716            app_esm: AppEsm::steal(),
1717            app_uart_1: AppUart1::steal(),
1718            app_spi_1: AppSpi1::steal(),
1719            app_i2c: AppI2c::steal(),
1720            app_pwm: AppPwm::steal(),
1721            top_io_mux: TopIoMux::steal(),
1722            app_prcm: AppPrcm::steal(),
1723            top_gio: TopGio::steal(),
1724            topss_ctrl: TopssCtrl::steal(),
1725            plldig_ctrl: PlldigCtrl::steal(),
1726            pbist: Pbist::steal(),
1727            top_debugss: TopDebugss::steal(),
1728            app_cfg_qspi: AppCfgQspi::steal(),
1729        }
1730    }
1731}
iwrl64xx_pac/lib.rs

iwrl64xx_pac/
lib.rs
