1#![doc = "Peripheral access API for AWR2544 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#[doc = "MSS_VIM"]
15pub struct MssVimR5a {
16 _marker: PhantomData<*const ()>,
17}
18unsafe impl Send for MssVimR5a {}
19impl MssVimR5a {
20 #[doc = r"Pointer to the register block"]
21 pub const PTR: *const mss_vim_r5a::RegisterBlock = 0x0208_0000 as *const _;
22 #[doc = r"Return the pointer to the register block"]
23 #[inline(always)]
24 pub const fn ptr() -> *const mss_vim_r5a::RegisterBlock {
25 Self::PTR
26 }
27 #[doc = r" Steal an instance of this peripheral"]
28 #[doc = r""]
29 #[doc = r" # Safety"]
30 #[doc = r""]
31 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
32 #[doc = r" that may race with any existing instances, for example by only"]
33 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
34 #[doc = r" original peripheral and using critical sections to coordinate"]
35 #[doc = r" access between multiple new instances."]
36 #[doc = r""]
37 #[doc = r" Additionally, other software such as HALs may rely on only one"]
38 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
39 #[doc = r" no stolen instances are passed to such software."]
40 pub unsafe fn steal() -> Self {
41 Self {
42 _marker: PhantomData,
43 }
44 }
45}
46impl Deref for MssVimR5a {
47 type Target = mss_vim_r5a::RegisterBlock;
48 #[inline(always)]
49 fn deref(&self) -> &Self::Target {
50 unsafe { &*Self::PTR }
51 }
52}
53impl core::fmt::Debug for MssVimR5a {
54 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
55 f.debug_struct("MssVimR5a").finish()
56 }
57}
58#[doc = "MSS_VIM"]
59pub mod mss_vim_r5a;
60#[doc = "MSS_IOMUX"]
61pub struct MssIomux {
62 _marker: PhantomData<*const ()>,
63}
64unsafe impl Send for MssIomux {}
65impl MssIomux {
66 #[doc = r"Pointer to the register block"]
67 pub const PTR: *const mss_iomux::RegisterBlock = 0x020c_0000 as *const _;
68 #[doc = r"Return the pointer to the register block"]
69 #[inline(always)]
70 pub const fn ptr() -> *const mss_iomux::RegisterBlock {
71 Self::PTR
72 }
73 #[doc = r" Steal an instance of this peripheral"]
74 #[doc = r""]
75 #[doc = r" # Safety"]
76 #[doc = r""]
77 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
78 #[doc = r" that may race with any existing instances, for example by only"]
79 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
80 #[doc = r" original peripheral and using critical sections to coordinate"]
81 #[doc = r" access between multiple new instances."]
82 #[doc = r""]
83 #[doc = r" Additionally, other software such as HALs may rely on only one"]
84 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
85 #[doc = r" no stolen instances are passed to such software."]
86 pub unsafe fn steal() -> Self {
87 Self {
88 _marker: PhantomData,
89 }
90 }
91}
92impl Deref for MssIomux {
93 type Target = mss_iomux::RegisterBlock;
94 #[inline(always)]
95 fn deref(&self) -> &Self::Target {
96 unsafe { &*Self::PTR }
97 }
98}
99impl core::fmt::Debug for MssIomux {
100 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
101 f.debug_struct("MssIomux").finish()
102 }
103}
104#[doc = "MSS_IOMUX"]
105pub mod mss_iomux;
106#[doc = "MSS_RCM"]
107pub struct MssRcm {
108 _marker: PhantomData<*const ()>,
109}
110unsafe impl Send for MssRcm {}
111impl MssRcm {
112 #[doc = r"Pointer to the register block"]
113 pub const PTR: *const mss_rcm::RegisterBlock = 0x0210_0000 as *const _;
114 #[doc = r"Return the pointer to the register block"]
115 #[inline(always)]
116 pub const fn ptr() -> *const mss_rcm::RegisterBlock {
117 Self::PTR
118 }
119 #[doc = r" Steal an instance of this peripheral"]
120 #[doc = r""]
121 #[doc = r" # Safety"]
122 #[doc = r""]
123 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
124 #[doc = r" that may race with any existing instances, for example by only"]
125 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
126 #[doc = r" original peripheral and using critical sections to coordinate"]
127 #[doc = r" access between multiple new instances."]
128 #[doc = r""]
129 #[doc = r" Additionally, other software such as HALs may rely on only one"]
130 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
131 #[doc = r" no stolen instances are passed to such software."]
132 pub unsafe fn steal() -> Self {
133 Self {
134 _marker: PhantomData,
135 }
136 }
137}
138impl Deref for MssRcm {
139 type Target = mss_rcm::RegisterBlock;
140 #[inline(always)]
141 fn deref(&self) -> &Self::Target {
142 unsafe { &*Self::PTR }
143 }
144}
145impl core::fmt::Debug for MssRcm {
146 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
147 f.debug_struct("MssRcm").finish()
148 }
149}
150#[doc = "MSS_RCM"]
151pub mod mss_rcm;
152#[doc = "MSS_CTRL"]
153pub struct MssCtrl {
154 _marker: PhantomData<*const ()>,
155}
156unsafe impl Send for MssCtrl {}
157impl MssCtrl {
158 #[doc = r"Pointer to the register block"]
159 pub const PTR: *const mss_ctrl::RegisterBlock = 0x0212_0000 as *const _;
160 #[doc = r"Return the pointer to the register block"]
161 #[inline(always)]
162 pub const fn ptr() -> *const mss_ctrl::RegisterBlock {
163 Self::PTR
164 }
165 #[doc = r" Steal an instance of this peripheral"]
166 #[doc = r""]
167 #[doc = r" # Safety"]
168 #[doc = r""]
169 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
170 #[doc = r" that may race with any existing instances, for example by only"]
171 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
172 #[doc = r" original peripheral and using critical sections to coordinate"]
173 #[doc = r" access between multiple new instances."]
174 #[doc = r""]
175 #[doc = r" Additionally, other software such as HALs may rely on only one"]
176 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
177 #[doc = r" no stolen instances are passed to such software."]
178 pub unsafe fn steal() -> Self {
179 Self {
180 _marker: PhantomData,
181 }
182 }
183}
184impl Deref for MssCtrl {
185 type Target = mss_ctrl::RegisterBlock;
186 #[inline(always)]
187 fn deref(&self) -> &Self::Target {
188 unsafe { &*Self::PTR }
189 }
190}
191impl core::fmt::Debug for MssCtrl {
192 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
193 f.debug_struct("MssCtrl").finish()
194 }
195}
196#[doc = "MSS_CTRL"]
197pub mod mss_ctrl;
198#[doc = "MSS_TOPRCM"]
199pub struct MssToprcm {
200 _marker: PhantomData<*const ()>,
201}
202unsafe impl Send for MssToprcm {}
203impl MssToprcm {
204 #[doc = r"Pointer to the register block"]
205 pub const PTR: *const mss_toprcm::RegisterBlock = 0x0214_0000 as *const _;
206 #[doc = r"Return the pointer to the register block"]
207 #[inline(always)]
208 pub const fn ptr() -> *const mss_toprcm::RegisterBlock {
209 Self::PTR
210 }
211 #[doc = r" Steal an instance of this peripheral"]
212 #[doc = r""]
213 #[doc = r" # Safety"]
214 #[doc = r""]
215 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
216 #[doc = r" that may race with any existing instances, for example by only"]
217 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
218 #[doc = r" original peripheral and using critical sections to coordinate"]
219 #[doc = r" access between multiple new instances."]
220 #[doc = r""]
221 #[doc = r" Additionally, other software such as HALs may rely on only one"]
222 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
223 #[doc = r" no stolen instances are passed to such software."]
224 pub unsafe fn steal() -> Self {
225 Self {
226 _marker: PhantomData,
227 }
228 }
229}
230impl Deref for MssToprcm {
231 type Target = mss_toprcm::RegisterBlock;
232 #[inline(always)]
233 fn deref(&self) -> &Self::Target {
234 unsafe { &*Self::PTR }
235 }
236}
237impl core::fmt::Debug for MssToprcm {
238 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
239 f.debug_struct("MssToprcm").finish()
240 }
241}
242#[doc = "MSS_TOPRCM"]
243pub mod mss_toprcm;
244#[doc = "MSS_PCR1"]
245pub struct MssPcr1 {
246 _marker: PhantomData<*const ()>,
247}
248unsafe impl Send for MssPcr1 {}
249impl MssPcr1 {
250 #[doc = r"Pointer to the register block"]
251 pub const PTR: *const mss_pcr1::RegisterBlock = 0x02f7_8000 as *const _;
252 #[doc = r"Return the pointer to the register block"]
253 #[inline(always)]
254 pub const fn ptr() -> *const mss_pcr1::RegisterBlock {
255 Self::PTR
256 }
257 #[doc = r" Steal an instance of this peripheral"]
258 #[doc = r""]
259 #[doc = r" # Safety"]
260 #[doc = r""]
261 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
262 #[doc = r" that may race with any existing instances, for example by only"]
263 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
264 #[doc = r" original peripheral and using critical sections to coordinate"]
265 #[doc = r" access between multiple new instances."]
266 #[doc = r""]
267 #[doc = r" Additionally, other software such as HALs may rely on only one"]
268 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
269 #[doc = r" no stolen instances are passed to such software."]
270 pub unsafe fn steal() -> Self {
271 Self {
272 _marker: PhantomData,
273 }
274 }
275}
276impl Deref for MssPcr1 {
277 type Target = mss_pcr1::RegisterBlock;
278 #[inline(always)]
279 fn deref(&self) -> &Self::Target {
280 unsafe { &*Self::PTR }
281 }
282}
283impl core::fmt::Debug for MssPcr1 {
284 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
285 f.debug_struct("MssPcr1").finish()
286 }
287}
288#[doc = "MSS_PCR1"]
289pub mod mss_pcr1;
290#[doc = "PBIST"]
291pub struct TopPbist {
292 _marker: PhantomData<*const ()>,
293}
294unsafe impl Send for TopPbist {}
295impl TopPbist {
296 #[doc = r"Pointer to the register block"]
297 pub const PTR: *const top_pbist::RegisterBlock = 0x02f7_9400 as *const _;
298 #[doc = r"Return the pointer to the register block"]
299 #[inline(always)]
300 pub const fn ptr() -> *const top_pbist::RegisterBlock {
301 Self::PTR
302 }
303 #[doc = r" Steal an instance of this peripheral"]
304 #[doc = r""]
305 #[doc = r" # Safety"]
306 #[doc = r""]
307 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
308 #[doc = r" that may race with any existing instances, for example by only"]
309 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
310 #[doc = r" original peripheral and using critical sections to coordinate"]
311 #[doc = r" access between multiple new instances."]
312 #[doc = r""]
313 #[doc = r" Additionally, other software such as HALs may rely on only one"]
314 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
315 #[doc = r" no stolen instances are passed to such software."]
316 pub unsafe fn steal() -> Self {
317 Self {
318 _marker: PhantomData,
319 }
320 }
321}
322impl Deref for TopPbist {
323 type Target = top_pbist::RegisterBlock;
324 #[inline(always)]
325 fn deref(&self) -> &Self::Target {
326 unsafe { &*Self::PTR }
327 }
328}
329impl core::fmt::Debug for TopPbist {
330 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
331 f.debug_struct("TopPbist").finish()
332 }
333}
334#[doc = "PBIST"]
335pub mod top_pbist;
336#[doc = "STC"]
337pub struct MssR5ssStc {
338 _marker: PhantomData<*const ()>,
339}
340unsafe impl Send for MssR5ssStc {}
341impl MssR5ssStc {
342 #[doc = r"Pointer to the register block"]
343 pub const PTR: *const mss_r5ss_stc::RegisterBlock = 0x02f7_9800 as *const _;
344 #[doc = r"Return the pointer to the register block"]
345 #[inline(always)]
346 pub const fn ptr() -> *const mss_r5ss_stc::RegisterBlock {
347 Self::PTR
348 }
349 #[doc = r" Steal an instance of this peripheral"]
350 #[doc = r""]
351 #[doc = r" # Safety"]
352 #[doc = r""]
353 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
354 #[doc = r" that may race with any existing instances, for example by only"]
355 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
356 #[doc = r" original peripheral and using critical sections to coordinate"]
357 #[doc = r" access between multiple new instances."]
358 #[doc = r""]
359 #[doc = r" Additionally, other software such as HALs may rely on only one"]
360 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
361 #[doc = r" no stolen instances are passed to such software."]
362 pub unsafe fn steal() -> Self {
363 Self {
364 _marker: PhantomData,
365 }
366 }
367}
368impl Deref for MssR5ssStc {
369 type Target = mss_r5ss_stc::RegisterBlock;
370 #[inline(always)]
371 fn deref(&self) -> &Self::Target {
372 unsafe { &*Self::PTR }
373 }
374}
375impl core::fmt::Debug for MssR5ssStc {
376 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
377 f.debug_struct("MssR5ssStc").finish()
378 }
379}
380#[doc = "STC"]
381pub mod mss_r5ss_stc;
382#[doc = "MSS_DCC"]
383pub struct MssDcca {
384 _marker: PhantomData<*const ()>,
385}
386unsafe impl Send for MssDcca {}
387impl MssDcca {
388 #[doc = r"Pointer to the register block"]
389 pub const PTR: *const mss_dcca::RegisterBlock = 0x02f7_9c00 as *const _;
390 #[doc = r"Return the pointer to the register block"]
391 #[inline(always)]
392 pub const fn ptr() -> *const mss_dcca::RegisterBlock {
393 Self::PTR
394 }
395 #[doc = r" Steal an instance of this peripheral"]
396 #[doc = r""]
397 #[doc = r" # Safety"]
398 #[doc = r""]
399 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
400 #[doc = r" that may race with any existing instances, for example by only"]
401 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
402 #[doc = r" original peripheral and using critical sections to coordinate"]
403 #[doc = r" access between multiple new instances."]
404 #[doc = r""]
405 #[doc = r" Additionally, other software such as HALs may rely on only one"]
406 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
407 #[doc = r" no stolen instances are passed to such software."]
408 pub unsafe fn steal() -> Self {
409 Self {
410 _marker: PhantomData,
411 }
412 }
413}
414impl Deref for MssDcca {
415 type Target = mss_dcca::RegisterBlock;
416 #[inline(always)]
417 fn deref(&self) -> &Self::Target {
418 unsafe { &*Self::PTR }
419 }
420}
421impl core::fmt::Debug for MssDcca {
422 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
423 f.debug_struct("MssDcca").finish()
424 }
425}
426#[doc = "MSS_DCC"]
427pub mod mss_dcca;
428#[doc = "MSS_DCC"]
429pub struct MssDccb {
430 _marker: PhantomData<*const ()>,
431}
432unsafe impl Send for MssDccb {}
433impl MssDccb {
434 #[doc = r"Pointer to the register block"]
435 pub const PTR: *const mss_dccb::RegisterBlock = 0x02f7_9d00 as *const _;
436 #[doc = r"Return the pointer to the register block"]
437 #[inline(always)]
438 pub const fn ptr() -> *const mss_dccb::RegisterBlock {
439 Self::PTR
440 }
441 #[doc = r" Steal an instance of this peripheral"]
442 #[doc = r""]
443 #[doc = r" # Safety"]
444 #[doc = r""]
445 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
446 #[doc = r" that may race with any existing instances, for example by only"]
447 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
448 #[doc = r" original peripheral and using critical sections to coordinate"]
449 #[doc = r" access between multiple new instances."]
450 #[doc = r""]
451 #[doc = r" Additionally, other software such as HALs may rely on only one"]
452 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
453 #[doc = r" no stolen instances are passed to such software."]
454 pub unsafe fn steal() -> Self {
455 Self {
456 _marker: PhantomData,
457 }
458 }
459}
460impl Deref for MssDccb {
461 type Target = mss_dccb::RegisterBlock;
462 #[inline(always)]
463 fn deref(&self) -> &Self::Target {
464 unsafe { &*Self::PTR }
465 }
466}
467impl core::fmt::Debug for MssDccb {
468 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
469 f.debug_struct("MssDccb").finish()
470 }
471}
472#[doc = "MSS_DCC"]
473pub mod mss_dccb;
474#[doc = "MSS_DCC"]
475pub struct MssDccc {
476 _marker: PhantomData<*const ()>,
477}
478unsafe impl Send for MssDccc {}
479impl MssDccc {
480 #[doc = r"Pointer to the register block"]
481 pub const PTR: *const mss_dccc::RegisterBlock = 0x02f7_9e00 as *const _;
482 #[doc = r"Return the pointer to the register block"]
483 #[inline(always)]
484 pub const fn ptr() -> *const mss_dccc::RegisterBlock {
485 Self::PTR
486 }
487 #[doc = r" Steal an instance of this peripheral"]
488 #[doc = r""]
489 #[doc = r" # Safety"]
490 #[doc = r""]
491 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
492 #[doc = r" that may race with any existing instances, for example by only"]
493 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
494 #[doc = r" original peripheral and using critical sections to coordinate"]
495 #[doc = r" access between multiple new instances."]
496 #[doc = r""]
497 #[doc = r" Additionally, other software such as HALs may rely on only one"]
498 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
499 #[doc = r" no stolen instances are passed to such software."]
500 pub unsafe fn steal() -> Self {
501 Self {
502 _marker: PhantomData,
503 }
504 }
505}
506impl Deref for MssDccc {
507 type Target = mss_dccc::RegisterBlock;
508 #[inline(always)]
509 fn deref(&self) -> &Self::Target {
510 unsafe { &*Self::PTR }
511 }
512}
513impl core::fmt::Debug for MssDccc {
514 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
515 f.debug_struct("MssDccc").finish()
516 }
517}
518#[doc = "MSS_DCC"]
519pub mod mss_dccc;
520#[doc = "MSS_DCC"]
521pub struct MssDccd {
522 _marker: PhantomData<*const ()>,
523}
524unsafe impl Send for MssDccd {}
525impl MssDccd {
526 #[doc = r"Pointer to the register block"]
527 pub const PTR: *const mss_dccd::RegisterBlock = 0x02f7_9f00 as *const _;
528 #[doc = r"Return the pointer to the register block"]
529 #[inline(always)]
530 pub const fn ptr() -> *const mss_dccd::RegisterBlock {
531 Self::PTR
532 }
533 #[doc = r" Steal an instance of this peripheral"]
534 #[doc = r""]
535 #[doc = r" # Safety"]
536 #[doc = r""]
537 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
538 #[doc = r" that may race with any existing instances, for example by only"]
539 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
540 #[doc = r" original peripheral and using critical sections to coordinate"]
541 #[doc = r" access between multiple new instances."]
542 #[doc = r""]
543 #[doc = r" Additionally, other software such as HALs may rely on only one"]
544 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
545 #[doc = r" no stolen instances are passed to such software."]
546 pub unsafe fn steal() -> Self {
547 Self {
548 _marker: PhantomData,
549 }
550 }
551}
552impl Deref for MssDccd {
553 type Target = mss_dccd::RegisterBlock;
554 #[inline(always)]
555 fn deref(&self) -> &Self::Target {
556 unsafe { &*Self::PTR }
557 }
558}
559impl core::fmt::Debug for MssDccd {
560 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
561 f.debug_struct("MssDccd").finish()
562 }
563}
564#[doc = "MSS_DCC"]
565pub mod mss_dccd;
566#[doc = "MSS_RTI"]
567pub struct MssRtia {
568 _marker: PhantomData<*const ()>,
569}
570unsafe impl Send for MssRtia {}
571impl MssRtia {
572 #[doc = r"Pointer to the register block"]
573 pub const PTR: *const mss_rtia::RegisterBlock = 0x02f7_a000 as *const _;
574 #[doc = r"Return the pointer to the register block"]
575 #[inline(always)]
576 pub const fn ptr() -> *const mss_rtia::RegisterBlock {
577 Self::PTR
578 }
579 #[doc = r" Steal an instance of this peripheral"]
580 #[doc = r""]
581 #[doc = r" # Safety"]
582 #[doc = r""]
583 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
584 #[doc = r" that may race with any existing instances, for example by only"]
585 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
586 #[doc = r" original peripheral and using critical sections to coordinate"]
587 #[doc = r" access between multiple new instances."]
588 #[doc = r""]
589 #[doc = r" Additionally, other software such as HALs may rely on only one"]
590 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
591 #[doc = r" no stolen instances are passed to such software."]
592 pub unsafe fn steal() -> Self {
593 Self {
594 _marker: PhantomData,
595 }
596 }
597}
598impl Deref for MssRtia {
599 type Target = mss_rtia::RegisterBlock;
600 #[inline(always)]
601 fn deref(&self) -> &Self::Target {
602 unsafe { &*Self::PTR }
603 }
604}
605impl core::fmt::Debug for MssRtia {
606 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
607 f.debug_struct("MssRtia").finish()
608 }
609}
610#[doc = "MSS_RTI"]
611pub mod mss_rtia;
612#[doc = "MSS_RTI"]
613pub struct MssRtib {
614 _marker: PhantomData<*const ()>,
615}
616unsafe impl Send for MssRtib {}
617impl MssRtib {
618 #[doc = r"Pointer to the register block"]
619 pub const PTR: *const mss_rtib::RegisterBlock = 0x02f7_a100 as *const _;
620 #[doc = r"Return the pointer to the register block"]
621 #[inline(always)]
622 pub const fn ptr() -> *const mss_rtib::RegisterBlock {
623 Self::PTR
624 }
625 #[doc = r" Steal an instance of this peripheral"]
626 #[doc = r""]
627 #[doc = r" # Safety"]
628 #[doc = r""]
629 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
630 #[doc = r" that may race with any existing instances, for example by only"]
631 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
632 #[doc = r" original peripheral and using critical sections to coordinate"]
633 #[doc = r" access between multiple new instances."]
634 #[doc = r""]
635 #[doc = r" Additionally, other software such as HALs may rely on only one"]
636 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
637 #[doc = r" no stolen instances are passed to such software."]
638 pub unsafe fn steal() -> Self {
639 Self {
640 _marker: PhantomData,
641 }
642 }
643}
644impl Deref for MssRtib {
645 type Target = mss_rtib::RegisterBlock;
646 #[inline(always)]
647 fn deref(&self) -> &Self::Target {
648 unsafe { &*Self::PTR }
649 }
650}
651impl core::fmt::Debug for MssRtib {
652 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
653 f.debug_struct("MssRtib").finish()
654 }
655}
656#[doc = "MSS_RTI"]
657pub mod mss_rtib;
658#[doc = "MSS_RTI"]
659pub struct MssRtic {
660 _marker: PhantomData<*const ()>,
661}
662unsafe impl Send for MssRtic {}
663impl MssRtic {
664 #[doc = r"Pointer to the register block"]
665 pub const PTR: *const mss_rtic::RegisterBlock = 0x02f7_a200 as *const _;
666 #[doc = r"Return the pointer to the register block"]
667 #[inline(always)]
668 pub const fn ptr() -> *const mss_rtic::RegisterBlock {
669 Self::PTR
670 }
671 #[doc = r" Steal an instance of this peripheral"]
672 #[doc = r""]
673 #[doc = r" # Safety"]
674 #[doc = r""]
675 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
676 #[doc = r" that may race with any existing instances, for example by only"]
677 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
678 #[doc = r" original peripheral and using critical sections to coordinate"]
679 #[doc = r" access between multiple new instances."]
680 #[doc = r""]
681 #[doc = r" Additionally, other software such as HALs may rely on only one"]
682 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
683 #[doc = r" no stolen instances are passed to such software."]
684 pub unsafe fn steal() -> Self {
685 Self {
686 _marker: PhantomData,
687 }
688 }
689}
690impl Deref for MssRtic {
691 type Target = mss_rtic::RegisterBlock;
692 #[inline(always)]
693 fn deref(&self) -> &Self::Target {
694 unsafe { &*Self::PTR }
695 }
696}
697impl core::fmt::Debug for MssRtic {
698 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
699 f.debug_struct("MssRtic").finish()
700 }
701}
702#[doc = "MSS_RTI"]
703pub mod mss_rtic;
704#[doc = "MSS_RTI"]
705pub struct MssWdt {
706 _marker: PhantomData<*const ()>,
707}
708unsafe impl Send for MssWdt {}
709impl MssWdt {
710 #[doc = r"Pointer to the register block"]
711 pub const PTR: *const mss_wdt::RegisterBlock = 0x02f7_a300 as *const _;
712 #[doc = r"Return the pointer to the register block"]
713 #[inline(always)]
714 pub const fn ptr() -> *const mss_wdt::RegisterBlock {
715 Self::PTR
716 }
717 #[doc = r" Steal an instance of this peripheral"]
718 #[doc = r""]
719 #[doc = r" # Safety"]
720 #[doc = r""]
721 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
722 #[doc = r" that may race with any existing instances, for example by only"]
723 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
724 #[doc = r" original peripheral and using critical sections to coordinate"]
725 #[doc = r" access between multiple new instances."]
726 #[doc = r""]
727 #[doc = r" Additionally, other software such as HALs may rely on only one"]
728 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
729 #[doc = r" no stolen instances are passed to such software."]
730 pub unsafe fn steal() -> Self {
731 Self {
732 _marker: PhantomData,
733 }
734 }
735}
736impl Deref for MssWdt {
737 type Target = mss_wdt::RegisterBlock;
738 #[inline(always)]
739 fn deref(&self) -> &Self::Target {
740 unsafe { &*Self::PTR }
741 }
742}
743impl core::fmt::Debug for MssWdt {
744 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
745 f.debug_struct("MssWdt").finish()
746 }
747}
748#[doc = "MSS_RTI"]
749pub mod mss_wdt;
750#[doc = "MSS_ESM"]
751pub struct MssEsm {
752 _marker: PhantomData<*const ()>,
753}
754unsafe impl Send for MssEsm {}
755impl MssEsm {
756 #[doc = r"Pointer to the register block"]
757 pub const PTR: *const mss_esm::RegisterBlock = 0x02f7_a400 as *const _;
758 #[doc = r"Return the pointer to the register block"]
759 #[inline(always)]
760 pub const fn ptr() -> *const mss_esm::RegisterBlock {
761 Self::PTR
762 }
763 #[doc = r" Steal an instance of this peripheral"]
764 #[doc = r""]
765 #[doc = r" # Safety"]
766 #[doc = r""]
767 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
768 #[doc = r" that may race with any existing instances, for example by only"]
769 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
770 #[doc = r" original peripheral and using critical sections to coordinate"]
771 #[doc = r" access between multiple new instances."]
772 #[doc = r""]
773 #[doc = r" Additionally, other software such as HALs may rely on only one"]
774 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
775 #[doc = r" no stolen instances are passed to such software."]
776 pub unsafe fn steal() -> Self {
777 Self {
778 _marker: PhantomData,
779 }
780 }
781}
782impl Deref for MssEsm {
783 type Target = mss_esm::RegisterBlock;
784 #[inline(always)]
785 fn deref(&self) -> &Self::Target {
786 unsafe { &*Self::PTR }
787 }
788}
789impl core::fmt::Debug for MssEsm {
790 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
791 f.debug_struct("MssEsm").finish()
792 }
793}
794#[doc = "MSS_ESM"]
795pub mod mss_esm;
796#[doc = "MSS_CCMR"]
797pub struct MssCcmr {
798 _marker: PhantomData<*const ()>,
799}
800unsafe impl Send for MssCcmr {}
801impl MssCcmr {
802 #[doc = r"Pointer to the register block"]
803 pub const PTR: *const mss_ccmr::RegisterBlock = 0x02f7_ac00 as *const _;
804 #[doc = r"Return the pointer to the register block"]
805 #[inline(always)]
806 pub const fn ptr() -> *const mss_ccmr::RegisterBlock {
807 Self::PTR
808 }
809 #[doc = r" Steal an instance of this peripheral"]
810 #[doc = r""]
811 #[doc = r" # Safety"]
812 #[doc = r""]
813 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
814 #[doc = r" that may race with any existing instances, for example by only"]
815 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
816 #[doc = r" original peripheral and using critical sections to coordinate"]
817 #[doc = r" access between multiple new instances."]
818 #[doc = r""]
819 #[doc = r" Additionally, other software such as HALs may rely on only one"]
820 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
821 #[doc = r" no stolen instances are passed to such software."]
822 pub unsafe fn steal() -> Self {
823 Self {
824 _marker: PhantomData,
825 }
826 }
827}
828impl Deref for MssCcmr {
829 type Target = mss_ccmr::RegisterBlock;
830 #[inline(always)]
831 fn deref(&self) -> &Self::Target {
832 unsafe { &*Self::PTR }
833 }
834}
835impl core::fmt::Debug for MssCcmr {
836 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
837 f.debug_struct("MssCcmr").finish()
838 }
839}
840#[doc = "MSS_CCMR"]
841pub mod mss_ccmr;
842#[doc = "MSS_I2C"]
843pub struct MssI2c {
844 _marker: PhantomData<*const ()>,
845}
846unsafe impl Send for MssI2c {}
847impl MssI2c {
848 #[doc = r"Pointer to the register block"]
849 pub const PTR: *const mss_i2c::RegisterBlock = 0x02f7_b000 as *const _;
850 #[doc = r"Return the pointer to the register block"]
851 #[inline(always)]
852 pub const fn ptr() -> *const mss_i2c::RegisterBlock {
853 Self::PTR
854 }
855 #[doc = r" Steal an instance of this peripheral"]
856 #[doc = r""]
857 #[doc = r" # Safety"]
858 #[doc = r""]
859 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
860 #[doc = r" that may race with any existing instances, for example by only"]
861 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
862 #[doc = r" original peripheral and using critical sections to coordinate"]
863 #[doc = r" access between multiple new instances."]
864 #[doc = r""]
865 #[doc = r" Additionally, other software such as HALs may rely on only one"]
866 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
867 #[doc = r" no stolen instances are passed to such software."]
868 pub unsafe fn steal() -> Self {
869 Self {
870 _marker: PhantomData,
871 }
872 }
873}
874impl Deref for MssI2c {
875 type Target = mss_i2c::RegisterBlock;
876 #[inline(always)]
877 fn deref(&self) -> &Self::Target {
878 unsafe { &*Self::PTR }
879 }
880}
881impl core::fmt::Debug for MssI2c {
882 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
883 f.debug_struct("MssI2c").finish()
884 }
885}
886#[doc = "MSS_I2C"]
887pub mod mss_i2c;
888#[doc = "MSS_GIO"]
889pub struct MssGio {
890 _marker: PhantomData<*const ()>,
891}
892unsafe impl Send for MssGio {}
893impl MssGio {
894 #[doc = r"Pointer to the register block"]
895 pub const PTR: *const mss_gio::RegisterBlock = 0x02f7_b400 as *const _;
896 #[doc = r"Return the pointer to the register block"]
897 #[inline(always)]
898 pub const fn ptr() -> *const mss_gio::RegisterBlock {
899 Self::PTR
900 }
901 #[doc = r" Steal an instance of this peripheral"]
902 #[doc = r""]
903 #[doc = r" # Safety"]
904 #[doc = r""]
905 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
906 #[doc = r" that may race with any existing instances, for example by only"]
907 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
908 #[doc = r" original peripheral and using critical sections to coordinate"]
909 #[doc = r" access between multiple new instances."]
910 #[doc = r""]
911 #[doc = r" Additionally, other software such as HALs may rely on only one"]
912 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
913 #[doc = r" no stolen instances are passed to such software."]
914 pub unsafe fn steal() -> Self {
915 Self {
916 _marker: PhantomData,
917 }
918 }
919}
920impl Deref for MssGio {
921 type Target = mss_gio::RegisterBlock;
922 #[inline(always)]
923 fn deref(&self) -> &Self::Target {
924 unsafe { &*Self::PTR }
925 }
926}
927impl core::fmt::Debug for MssGio {
928 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
929 f.debug_struct("MssGio").finish()
930 }
931}
932#[doc = "MSS_GIO"]
933pub mod mss_gio;
934#[doc = "MSS_ECC_AGG_R5A"]
935pub struct MssEccAggR5a {
936 _marker: PhantomData<*const ()>,
937}
938unsafe impl Send for MssEccAggR5a {}
939impl MssEccAggR5a {
940 #[doc = r"Pointer to the register block"]
941 pub const PTR: *const mss_ecc_agg_r5a::RegisterBlock = 0x02f7_b800 as *const _;
942 #[doc = r"Return the pointer to the register block"]
943 #[inline(always)]
944 pub const fn ptr() -> *const mss_ecc_agg_r5a::RegisterBlock {
945 Self::PTR
946 }
947 #[doc = r" Steal an instance of this peripheral"]
948 #[doc = r""]
949 #[doc = r" # Safety"]
950 #[doc = r""]
951 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
952 #[doc = r" that may race with any existing instances, for example by only"]
953 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
954 #[doc = r" original peripheral and using critical sections to coordinate"]
955 #[doc = r" access between multiple new instances."]
956 #[doc = r""]
957 #[doc = r" Additionally, other software such as HALs may rely on only one"]
958 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
959 #[doc = r" no stolen instances are passed to such software."]
960 pub unsafe fn steal() -> Self {
961 Self {
962 _marker: PhantomData,
963 }
964 }
965}
966impl Deref for MssEccAggR5a {
967 type Target = mss_ecc_agg_r5a::RegisterBlock;
968 #[inline(always)]
969 fn deref(&self) -> &Self::Target {
970 unsafe { &*Self::PTR }
971 }
972}
973impl core::fmt::Debug for MssEccAggR5a {
974 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
975 f.debug_struct("MssEccAggR5a").finish()
976 }
977}
978#[doc = "MSS_ECC_AGG_R5A"]
979pub mod mss_ecc_agg_r5a;
980#[doc = "MSS_ECC_AGG_MSS"]
981pub struct MssEccAggMss {
982 _marker: PhantomData<*const ()>,
983}
984unsafe impl Send for MssEccAggMss {}
985impl MssEccAggMss {
986 #[doc = r"Pointer to the register block"]
987 pub const PTR: *const mss_ecc_agg_mss::RegisterBlock = 0x02f7_c000 as *const _;
988 #[doc = r"Return the pointer to the register block"]
989 #[inline(always)]
990 pub const fn ptr() -> *const mss_ecc_agg_mss::RegisterBlock {
991 Self::PTR
992 }
993 #[doc = r" Steal an instance of this peripheral"]
994 #[doc = r""]
995 #[doc = r" # Safety"]
996 #[doc = r""]
997 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
998 #[doc = r" that may race with any existing instances, for example by only"]
999 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1000 #[doc = r" original peripheral and using critical sections to coordinate"]
1001 #[doc = r" access between multiple new instances."]
1002 #[doc = r""]
1003 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1004 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1005 #[doc = r" no stolen instances are passed to such software."]
1006 pub unsafe fn steal() -> Self {
1007 Self {
1008 _marker: PhantomData,
1009 }
1010 }
1011}
1012impl Deref for MssEccAggMss {
1013 type Target = mss_ecc_agg_mss::RegisterBlock;
1014 #[inline(always)]
1015 fn deref(&self) -> &Self::Target {
1016 unsafe { &*Self::PTR }
1017 }
1018}
1019impl core::fmt::Debug for MssEccAggMss {
1020 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1021 f.debug_struct("MssEccAggMss").finish()
1022 }
1023}
1024#[doc = "MSS_ECC_AGG_MSS"]
1025pub mod mss_ecc_agg_mss;
1026#[doc = "MSS_SPI"]
1027pub struct MssSpib {
1028 _marker: PhantomData<*const ()>,
1029}
1030unsafe impl Send for MssSpib {}
1031impl MssSpib {
1032 #[doc = r"Pointer to the register block"]
1033 pub const PTR: *const mss_spib::RegisterBlock = 0x02f7_ea00 as *const _;
1034 #[doc = r"Return the pointer to the register block"]
1035 #[inline(always)]
1036 pub const fn ptr() -> *const mss_spib::RegisterBlock {
1037 Self::PTR
1038 }
1039 #[doc = r" Steal an instance of this peripheral"]
1040 #[doc = r""]
1041 #[doc = r" # Safety"]
1042 #[doc = r""]
1043 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1044 #[doc = r" that may race with any existing instances, for example by only"]
1045 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1046 #[doc = r" original peripheral and using critical sections to coordinate"]
1047 #[doc = r" access between multiple new instances."]
1048 #[doc = r""]
1049 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1050 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1051 #[doc = r" no stolen instances are passed to such software."]
1052 pub unsafe fn steal() -> Self {
1053 Self {
1054 _marker: PhantomData,
1055 }
1056 }
1057}
1058impl Deref for MssSpib {
1059 type Target = mss_spib::RegisterBlock;
1060 #[inline(always)]
1061 fn deref(&self) -> &Self::Target {
1062 unsafe { &*Self::PTR }
1063 }
1064}
1065impl core::fmt::Debug for MssSpib {
1066 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1067 f.debug_struct("MssSpib").finish()
1068 }
1069}
1070#[doc = "MSS_SPI"]
1071pub mod mss_spib;
1072#[doc = "MSS_SCI"]
1073pub struct MssScia {
1074 _marker: PhantomData<*const ()>,
1075}
1076unsafe impl Send for MssScia {}
1077impl MssScia {
1078 #[doc = r"Pointer to the register block"]
1079 pub const PTR: *const mss_scia::RegisterBlock = 0x02f7_ec00 as *const _;
1080 #[doc = r"Return the pointer to the register block"]
1081 #[inline(always)]
1082 pub const fn ptr() -> *const mss_scia::RegisterBlock {
1083 Self::PTR
1084 }
1085 #[doc = r" Steal an instance of this peripheral"]
1086 #[doc = r""]
1087 #[doc = r" # Safety"]
1088 #[doc = r""]
1089 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1090 #[doc = r" that may race with any existing instances, for example by only"]
1091 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1092 #[doc = r" original peripheral and using critical sections to coordinate"]
1093 #[doc = r" access between multiple new instances."]
1094 #[doc = r""]
1095 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1096 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1097 #[doc = r" no stolen instances are passed to such software."]
1098 pub unsafe fn steal() -> Self {
1099 Self {
1100 _marker: PhantomData,
1101 }
1102 }
1103}
1104impl Deref for MssScia {
1105 type Target = mss_scia::RegisterBlock;
1106 #[inline(always)]
1107 fn deref(&self) -> &Self::Target {
1108 unsafe { &*Self::PTR }
1109 }
1110}
1111impl core::fmt::Debug for MssScia {
1112 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1113 f.debug_struct("MssScia").finish()
1114 }
1115}
1116#[doc = "MSS_SCI"]
1117pub mod mss_scia;
1118#[doc = "MSS_SCI"]
1119pub struct MssScib {
1120 _marker: PhantomData<*const ()>,
1121}
1122unsafe impl Send for MssScib {}
1123impl MssScib {
1124 #[doc = r"Pointer to the register block"]
1125 pub const PTR: *const mss_scib::RegisterBlock = 0x02f7_ed00 as *const _;
1126 #[doc = r"Return the pointer to the register block"]
1127 #[inline(always)]
1128 pub const fn ptr() -> *const mss_scib::RegisterBlock {
1129 Self::PTR
1130 }
1131 #[doc = r" Steal an instance of this peripheral"]
1132 #[doc = r""]
1133 #[doc = r" # Safety"]
1134 #[doc = r""]
1135 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1136 #[doc = r" that may race with any existing instances, for example by only"]
1137 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1138 #[doc = r" original peripheral and using critical sections to coordinate"]
1139 #[doc = r" access between multiple new instances."]
1140 #[doc = r""]
1141 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1142 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1143 #[doc = r" no stolen instances are passed to such software."]
1144 pub unsafe fn steal() -> Self {
1145 Self {
1146 _marker: PhantomData,
1147 }
1148 }
1149}
1150impl Deref for MssScib {
1151 type Target = mss_scib::RegisterBlock;
1152 #[inline(always)]
1153 fn deref(&self) -> &Self::Target {
1154 unsafe { &*Self::PTR }
1155 }
1156}
1157impl core::fmt::Debug for MssScib {
1158 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1159 f.debug_struct("MssScib").finish()
1160 }
1161}
1162#[doc = "MSS_SCI"]
1163pub mod mss_scib;
1164#[doc = "MSS_GPADC_PKT_RAM"]
1165pub struct MssGpadcPktRam {
1166 _marker: PhantomData<*const ()>,
1167}
1168unsafe impl Send for MssGpadcPktRam {}
1169impl MssGpadcPktRam {
1170 #[doc = r"Pointer to the register block"]
1171 pub const PTR: *const mss_gpadc_pkt_ram::RegisterBlock = 0x030c_0000 as *const _;
1172 #[doc = r"Return the pointer to the register block"]
1173 #[inline(always)]
1174 pub const fn ptr() -> *const mss_gpadc_pkt_ram::RegisterBlock {
1175 Self::PTR
1176 }
1177 #[doc = r" Steal an instance of this peripheral"]
1178 #[doc = r""]
1179 #[doc = r" # Safety"]
1180 #[doc = r""]
1181 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1182 #[doc = r" that may race with any existing instances, for example by only"]
1183 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1184 #[doc = r" original peripheral and using critical sections to coordinate"]
1185 #[doc = r" access between multiple new instances."]
1186 #[doc = r""]
1187 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1188 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1189 #[doc = r" no stolen instances are passed to such software."]
1190 pub unsafe fn steal() -> Self {
1191 Self {
1192 _marker: PhantomData,
1193 }
1194 }
1195}
1196impl Deref for MssGpadcPktRam {
1197 type Target = mss_gpadc_pkt_ram::RegisterBlock;
1198 #[inline(always)]
1199 fn deref(&self) -> &Self::Target {
1200 unsafe { &*Self::PTR }
1201 }
1202}
1203impl core::fmt::Debug for MssGpadcPktRam {
1204 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1205 f.debug_struct("MssGpadcPktRam").finish()
1206 }
1207}
1208#[doc = "MSS_GPADC_PKT_RAM"]
1209pub mod mss_gpadc_pkt_ram;
1210#[doc = "TOP_CTRL"]
1211pub struct TopCtrl {
1212 _marker: PhantomData<*const ()>,
1213}
1214unsafe impl Send for TopCtrl {}
1215impl TopCtrl {
1216 #[doc = r"Pointer to the register block"]
1217 pub const PTR: *const top_ctrl::RegisterBlock = 0x030e_0000 as *const _;
1218 #[doc = r"Return the pointer to the register block"]
1219 #[inline(always)]
1220 pub const fn ptr() -> *const top_ctrl::RegisterBlock {
1221 Self::PTR
1222 }
1223 #[doc = r" Steal an instance of this peripheral"]
1224 #[doc = r""]
1225 #[doc = r" # Safety"]
1226 #[doc = r""]
1227 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1228 #[doc = r" that may race with any existing instances, for example by only"]
1229 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1230 #[doc = r" original peripheral and using critical sections to coordinate"]
1231 #[doc = r" access between multiple new instances."]
1232 #[doc = r""]
1233 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1234 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1235 #[doc = r" no stolen instances are passed to such software."]
1236 pub unsafe fn steal() -> Self {
1237 Self {
1238 _marker: PhantomData,
1239 }
1240 }
1241}
1242impl Deref for TopCtrl {
1243 type Target = top_ctrl::RegisterBlock;
1244 #[inline(always)]
1245 fn deref(&self) -> &Self::Target {
1246 unsafe { &*Self::PTR }
1247 }
1248}
1249impl core::fmt::Debug for TopCtrl {
1250 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1251 f.debug_struct("TopCtrl").finish()
1252 }
1253}
1254#[doc = "TOP_CTRL"]
1255pub mod top_ctrl;
1256#[doc = "TPCC"]
1257pub struct MssTpccA {
1258 _marker: PhantomData<*const ()>,
1259}
1260unsafe impl Send for MssTpccA {}
1261impl MssTpccA {
1262 #[doc = r"Pointer to the register block"]
1263 pub const PTR: *const mss_tpcc_a::RegisterBlock = 0x0310_0000 as *const _;
1264 #[doc = r"Return the pointer to the register block"]
1265 #[inline(always)]
1266 pub const fn ptr() -> *const mss_tpcc_a::RegisterBlock {
1267 Self::PTR
1268 }
1269 #[doc = r" Steal an instance of this peripheral"]
1270 #[doc = r""]
1271 #[doc = r" # Safety"]
1272 #[doc = r""]
1273 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1274 #[doc = r" that may race with any existing instances, for example by only"]
1275 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1276 #[doc = r" original peripheral and using critical sections to coordinate"]
1277 #[doc = r" access between multiple new instances."]
1278 #[doc = r""]
1279 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1280 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1281 #[doc = r" no stolen instances are passed to such software."]
1282 pub unsafe fn steal() -> Self {
1283 Self {
1284 _marker: PhantomData,
1285 }
1286 }
1287}
1288impl Deref for MssTpccA {
1289 type Target = mss_tpcc_a::RegisterBlock;
1290 #[inline(always)]
1291 fn deref(&self) -> &Self::Target {
1292 unsafe { &*Self::PTR }
1293 }
1294}
1295impl core::fmt::Debug for MssTpccA {
1296 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1297 f.debug_struct("MssTpccA").finish()
1298 }
1299}
1300#[doc = "TPCC"]
1301pub mod mss_tpcc_a;
1302#[doc = "Register test environment"]
1303pub struct MssTptcA0 {
1304 _marker: PhantomData<*const ()>,
1305}
1306unsafe impl Send for MssTptcA0 {}
1307impl MssTptcA0 {
1308 #[doc = r"Pointer to the register block"]
1309 pub const PTR: *const mss_tptc_a0::RegisterBlock = 0x0314_0000 as *const _;
1310 #[doc = r"Return the pointer to the register block"]
1311 #[inline(always)]
1312 pub const fn ptr() -> *const mss_tptc_a0::RegisterBlock {
1313 Self::PTR
1314 }
1315 #[doc = r" Steal an instance of this peripheral"]
1316 #[doc = r""]
1317 #[doc = r" # Safety"]
1318 #[doc = r""]
1319 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1320 #[doc = r" that may race with any existing instances, for example by only"]
1321 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1322 #[doc = r" original peripheral and using critical sections to coordinate"]
1323 #[doc = r" access between multiple new instances."]
1324 #[doc = r""]
1325 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1326 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1327 #[doc = r" no stolen instances are passed to such software."]
1328 pub unsafe fn steal() -> Self {
1329 Self {
1330 _marker: PhantomData,
1331 }
1332 }
1333}
1334impl Deref for MssTptcA0 {
1335 type Target = mss_tptc_a0::RegisterBlock;
1336 #[inline(always)]
1337 fn deref(&self) -> &Self::Target {
1338 unsafe { &*Self::PTR }
1339 }
1340}
1341impl core::fmt::Debug for MssTptcA0 {
1342 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1343 f.debug_struct("MssTptcA0").finish()
1344 }
1345}
1346#[doc = "Register test environment"]
1347pub mod mss_tptc_a0;
1348#[doc = "Register test environment"]
1349pub struct MssTptcA1 {
1350 _marker: PhantomData<*const ()>,
1351}
1352unsafe impl Send for MssTptcA1 {}
1353impl MssTptcA1 {
1354 #[doc = r"Pointer to the register block"]
1355 pub const PTR: *const mss_tptc_a1::RegisterBlock = 0x0316_0000 as *const _;
1356 #[doc = r"Return the pointer to the register block"]
1357 #[inline(always)]
1358 pub const fn ptr() -> *const mss_tptc_a1::RegisterBlock {
1359 Self::PTR
1360 }
1361 #[doc = r" Steal an instance of this peripheral"]
1362 #[doc = r""]
1363 #[doc = r" # Safety"]
1364 #[doc = r""]
1365 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1366 #[doc = r" that may race with any existing instances, for example by only"]
1367 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1368 #[doc = r" original peripheral and using critical sections to coordinate"]
1369 #[doc = r" access between multiple new instances."]
1370 #[doc = r""]
1371 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1372 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1373 #[doc = r" no stolen instances are passed to such software."]
1374 pub unsafe fn steal() -> Self {
1375 Self {
1376 _marker: PhantomData,
1377 }
1378 }
1379}
1380impl Deref for MssTptcA1 {
1381 type Target = mss_tptc_a1::RegisterBlock;
1382 #[inline(always)]
1383 fn deref(&self) -> &Self::Target {
1384 unsafe { &*Self::PTR }
1385 }
1386}
1387impl core::fmt::Debug for MssTptcA1 {
1388 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1389 f.debug_struct("MssTptcA1").finish()
1390 }
1391}
1392#[doc = "Register test environment"]
1393pub mod mss_tptc_a1;
1394#[doc = "MSS_PCR2"]
1395pub struct MssPcr2 {
1396 _marker: PhantomData<*const ()>,
1397}
1398unsafe impl Send for MssPcr2 {}
1399impl MssPcr2 {
1400 #[doc = r"Pointer to the register block"]
1401 pub const PTR: *const mss_pcr2::RegisterBlock = 0x03f7_8000 as *const _;
1402 #[doc = r"Return the pointer to the register block"]
1403 #[inline(always)]
1404 pub const fn ptr() -> *const mss_pcr2::RegisterBlock {
1405 Self::PTR
1406 }
1407 #[doc = r" Steal an instance of this peripheral"]
1408 #[doc = r""]
1409 #[doc = r" # Safety"]
1410 #[doc = r""]
1411 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1412 #[doc = r" that may race with any existing instances, for example by only"]
1413 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1414 #[doc = r" original peripheral and using critical sections to coordinate"]
1415 #[doc = r" access between multiple new instances."]
1416 #[doc = r""]
1417 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1418 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1419 #[doc = r" no stolen instances are passed to such software."]
1420 pub unsafe fn steal() -> Self {
1421 Self {
1422 _marker: PhantomData,
1423 }
1424 }
1425}
1426impl Deref for MssPcr2 {
1427 type Target = mss_pcr2::RegisterBlock;
1428 #[inline(always)]
1429 fn deref(&self) -> &Self::Target {
1430 unsafe { &*Self::PTR }
1431 }
1432}
1433impl core::fmt::Debug for MssPcr2 {
1434 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1435 f.debug_struct("MssPcr2").finish()
1436 }
1437}
1438#[doc = "MSS_PCR2"]
1439pub mod mss_pcr2;
1440#[doc = "MSS_ETPWM"]
1441pub struct MssEtpwma {
1442 _marker: PhantomData<*const ()>,
1443}
1444unsafe impl Send for MssEtpwma {}
1445impl MssEtpwma {
1446 #[doc = r"Pointer to the register block"]
1447 pub const PTR: *const mss_etpwma::RegisterBlock = 0x03f7_8c00 as *const _;
1448 #[doc = r"Return the pointer to the register block"]
1449 #[inline(always)]
1450 pub const fn ptr() -> *const mss_etpwma::RegisterBlock {
1451 Self::PTR
1452 }
1453 #[doc = r" Steal an instance of this peripheral"]
1454 #[doc = r""]
1455 #[doc = r" # Safety"]
1456 #[doc = r""]
1457 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1458 #[doc = r" that may race with any existing instances, for example by only"]
1459 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1460 #[doc = r" original peripheral and using critical sections to coordinate"]
1461 #[doc = r" access between multiple new instances."]
1462 #[doc = r""]
1463 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1464 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1465 #[doc = r" no stolen instances are passed to such software."]
1466 pub unsafe fn steal() -> Self {
1467 Self {
1468 _marker: PhantomData,
1469 }
1470 }
1471}
1472impl Deref for MssEtpwma {
1473 type Target = mss_etpwma::RegisterBlock;
1474 #[inline(always)]
1475 fn deref(&self) -> &Self::Target {
1476 unsafe { &*Self::PTR }
1477 }
1478}
1479impl core::fmt::Debug for MssEtpwma {
1480 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1481 f.debug_struct("MssEtpwma").finish()
1482 }
1483}
1484#[doc = "MSS_ETPWM"]
1485pub mod mss_etpwma;
1486#[doc = "MSS_ETPWM"]
1487pub struct MssEtpwmb {
1488 _marker: PhantomData<*const ()>,
1489}
1490unsafe impl Send for MssEtpwmb {}
1491impl MssEtpwmb {
1492 #[doc = r"Pointer to the register block"]
1493 pub const PTR: *const mss_etpwmb::RegisterBlock = 0x03f7_8d00 as *const _;
1494 #[doc = r"Return the pointer to the register block"]
1495 #[inline(always)]
1496 pub const fn ptr() -> *const mss_etpwmb::RegisterBlock {
1497 Self::PTR
1498 }
1499 #[doc = r" Steal an instance of this peripheral"]
1500 #[doc = r""]
1501 #[doc = r" # Safety"]
1502 #[doc = r""]
1503 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1504 #[doc = r" that may race with any existing instances, for example by only"]
1505 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1506 #[doc = r" original peripheral and using critical sections to coordinate"]
1507 #[doc = r" access between multiple new instances."]
1508 #[doc = r""]
1509 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1510 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1511 #[doc = r" no stolen instances are passed to such software."]
1512 pub unsafe fn steal() -> Self {
1513 Self {
1514 _marker: PhantomData,
1515 }
1516 }
1517}
1518impl Deref for MssEtpwmb {
1519 type Target = mss_etpwmb::RegisterBlock;
1520 #[inline(always)]
1521 fn deref(&self) -> &Self::Target {
1522 unsafe { &*Self::PTR }
1523 }
1524}
1525impl core::fmt::Debug for MssEtpwmb {
1526 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1527 f.debug_struct("MssEtpwmb").finish()
1528 }
1529}
1530#[doc = "MSS_ETPWM"]
1531pub mod mss_etpwmb;
1532#[doc = "MSS_ETPWM"]
1533pub struct MssEtpwmc {
1534 _marker: PhantomData<*const ()>,
1535}
1536unsafe impl Send for MssEtpwmc {}
1537impl MssEtpwmc {
1538 #[doc = r"Pointer to the register block"]
1539 pub const PTR: *const mss_etpwmc::RegisterBlock = 0x03f7_8e00 as *const _;
1540 #[doc = r"Return the pointer to the register block"]
1541 #[inline(always)]
1542 pub const fn ptr() -> *const mss_etpwmc::RegisterBlock {
1543 Self::PTR
1544 }
1545 #[doc = r" Steal an instance of this peripheral"]
1546 #[doc = r""]
1547 #[doc = r" # Safety"]
1548 #[doc = r""]
1549 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1550 #[doc = r" that may race with any existing instances, for example by only"]
1551 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1552 #[doc = r" original peripheral and using critical sections to coordinate"]
1553 #[doc = r" access between multiple new instances."]
1554 #[doc = r""]
1555 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1556 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1557 #[doc = r" no stolen instances are passed to such software."]
1558 pub unsafe fn steal() -> Self {
1559 Self {
1560 _marker: PhantomData,
1561 }
1562 }
1563}
1564impl Deref for MssEtpwmc {
1565 type Target = mss_etpwmc::RegisterBlock;
1566 #[inline(always)]
1567 fn deref(&self) -> &Self::Target {
1568 unsafe { &*Self::PTR }
1569 }
1570}
1571impl core::fmt::Debug for MssEtpwmc {
1572 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1573 f.debug_struct("MssEtpwmc").finish()
1574 }
1575}
1576#[doc = "MSS_ETPWM"]
1577pub mod mss_etpwmc;
1578#[doc = "RSS_RCM"]
1579pub struct RssRcm {
1580 _marker: PhantomData<*const ()>,
1581}
1582unsafe impl Send for RssRcm {}
1583impl RssRcm {
1584 #[doc = r"Pointer to the register block"]
1585 pub const PTR: *const rss_rcm::RegisterBlock = 0x0500_0000 as *const _;
1586 #[doc = r"Return the pointer to the register block"]
1587 #[inline(always)]
1588 pub const fn ptr() -> *const rss_rcm::RegisterBlock {
1589 Self::PTR
1590 }
1591 #[doc = r" Steal an instance of this peripheral"]
1592 #[doc = r""]
1593 #[doc = r" # Safety"]
1594 #[doc = r""]
1595 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1596 #[doc = r" that may race with any existing instances, for example by only"]
1597 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1598 #[doc = r" original peripheral and using critical sections to coordinate"]
1599 #[doc = r" access between multiple new instances."]
1600 #[doc = r""]
1601 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1602 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1603 #[doc = r" no stolen instances are passed to such software."]
1604 pub unsafe fn steal() -> Self {
1605 Self {
1606 _marker: PhantomData,
1607 }
1608 }
1609}
1610impl Deref for RssRcm {
1611 type Target = rss_rcm::RegisterBlock;
1612 #[inline(always)]
1613 fn deref(&self) -> &Self::Target {
1614 unsafe { &*Self::PTR }
1615 }
1616}
1617impl core::fmt::Debug for RssRcm {
1618 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1619 f.debug_struct("RssRcm").finish()
1620 }
1621}
1622#[doc = "RSS_RCM"]
1623pub mod rss_rcm;
1624#[doc = "RSS_CTRL"]
1625pub struct RssCtrl {
1626 _marker: PhantomData<*const ()>,
1627}
1628unsafe impl Send for RssCtrl {}
1629impl RssCtrl {
1630 #[doc = r"Pointer to the register block"]
1631 pub const PTR: *const rss_ctrl::RegisterBlock = 0x0502_0000 as *const _;
1632 #[doc = r"Return the pointer to the register block"]
1633 #[inline(always)]
1634 pub const fn ptr() -> *const rss_ctrl::RegisterBlock {
1635 Self::PTR
1636 }
1637 #[doc = r" Steal an instance of this peripheral"]
1638 #[doc = r""]
1639 #[doc = r" # Safety"]
1640 #[doc = r""]
1641 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1642 #[doc = r" that may race with any existing instances, for example by only"]
1643 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1644 #[doc = r" original peripheral and using critical sections to coordinate"]
1645 #[doc = r" access between multiple new instances."]
1646 #[doc = r""]
1647 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1648 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1649 #[doc = r" no stolen instances are passed to such software."]
1650 pub unsafe fn steal() -> Self {
1651 Self {
1652 _marker: PhantomData,
1653 }
1654 }
1655}
1656impl Deref for RssCtrl {
1657 type Target = rss_ctrl::RegisterBlock;
1658 #[inline(always)]
1659 fn deref(&self) -> &Self::Target {
1660 unsafe { &*Self::PTR }
1661 }
1662}
1663impl core::fmt::Debug for RssCtrl {
1664 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1665 f.debug_struct("RssCtrl").finish()
1666 }
1667}
1668#[doc = "RSS_CTRL"]
1669pub mod rss_ctrl;
1670#[doc = "TPCC"]
1671pub struct RssTpccA {
1672 _marker: PhantomData<*const ()>,
1673}
1674unsafe impl Send for RssTpccA {}
1675impl RssTpccA {
1676 #[doc = r"Pointer to the register block"]
1677 pub const PTR: *const rss_tpcc_a::RegisterBlock = 0x0510_0000 as *const _;
1678 #[doc = r"Return the pointer to the register block"]
1679 #[inline(always)]
1680 pub const fn ptr() -> *const rss_tpcc_a::RegisterBlock {
1681 Self::PTR
1682 }
1683 #[doc = r" Steal an instance of this peripheral"]
1684 #[doc = r""]
1685 #[doc = r" # Safety"]
1686 #[doc = r""]
1687 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1688 #[doc = r" that may race with any existing instances, for example by only"]
1689 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1690 #[doc = r" original peripheral and using critical sections to coordinate"]
1691 #[doc = r" access between multiple new instances."]
1692 #[doc = r""]
1693 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1694 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1695 #[doc = r" no stolen instances are passed to such software."]
1696 pub unsafe fn steal() -> Self {
1697 Self {
1698 _marker: PhantomData,
1699 }
1700 }
1701}
1702impl Deref for RssTpccA {
1703 type Target = rss_tpcc_a::RegisterBlock;
1704 #[inline(always)]
1705 fn deref(&self) -> &Self::Target {
1706 unsafe { &*Self::PTR }
1707 }
1708}
1709impl core::fmt::Debug for RssTpccA {
1710 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1711 f.debug_struct("RssTpccA").finish()
1712 }
1713}
1714#[doc = "TPCC"]
1715pub mod rss_tpcc_a;
1716#[doc = "Register test environment"]
1717pub struct RssTptcA0 {
1718 _marker: PhantomData<*const ()>,
1719}
1720unsafe impl Send for RssTptcA0 {}
1721impl RssTptcA0 {
1722 #[doc = r"Pointer to the register block"]
1723 pub const PTR: *const rss_tptc_a0::RegisterBlock = 0x0516_0000 as *const _;
1724 #[doc = r"Return the pointer to the register block"]
1725 #[inline(always)]
1726 pub const fn ptr() -> *const rss_tptc_a0::RegisterBlock {
1727 Self::PTR
1728 }
1729 #[doc = r" Steal an instance of this peripheral"]
1730 #[doc = r""]
1731 #[doc = r" # Safety"]
1732 #[doc = r""]
1733 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1734 #[doc = r" that may race with any existing instances, for example by only"]
1735 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1736 #[doc = r" original peripheral and using critical sections to coordinate"]
1737 #[doc = r" access between multiple new instances."]
1738 #[doc = r""]
1739 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1740 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1741 #[doc = r" no stolen instances are passed to such software."]
1742 pub unsafe fn steal() -> Self {
1743 Self {
1744 _marker: PhantomData,
1745 }
1746 }
1747}
1748impl Deref for RssTptcA0 {
1749 type Target = rss_tptc_a0::RegisterBlock;
1750 #[inline(always)]
1751 fn deref(&self) -> &Self::Target {
1752 unsafe { &*Self::PTR }
1753 }
1754}
1755impl core::fmt::Debug for RssTptcA0 {
1756 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1757 f.debug_struct("RssTptcA0").finish()
1758 }
1759}
1760#[doc = "Register test environment"]
1761pub mod rss_tptc_a0;
1762#[doc = "DSS_RCM"]
1763pub struct DssRcm {
1764 _marker: PhantomData<*const ()>,
1765}
1766unsafe impl Send for DssRcm {}
1767impl DssRcm {
1768 #[doc = r"Pointer to the register block"]
1769 pub const PTR: *const dss_rcm::RegisterBlock = 0x0600_0000 as *const _;
1770 #[doc = r"Return the pointer to the register block"]
1771 #[inline(always)]
1772 pub const fn ptr() -> *const dss_rcm::RegisterBlock {
1773 Self::PTR
1774 }
1775 #[doc = r" Steal an instance of this peripheral"]
1776 #[doc = r""]
1777 #[doc = r" # Safety"]
1778 #[doc = r""]
1779 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1780 #[doc = r" that may race with any existing instances, for example by only"]
1781 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1782 #[doc = r" original peripheral and using critical sections to coordinate"]
1783 #[doc = r" access between multiple new instances."]
1784 #[doc = r""]
1785 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1786 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1787 #[doc = r" no stolen instances are passed to such software."]
1788 pub unsafe fn steal() -> Self {
1789 Self {
1790 _marker: PhantomData,
1791 }
1792 }
1793}
1794impl Deref for DssRcm {
1795 type Target = dss_rcm::RegisterBlock;
1796 #[inline(always)]
1797 fn deref(&self) -> &Self::Target {
1798 unsafe { &*Self::PTR }
1799 }
1800}
1801impl core::fmt::Debug for DssRcm {
1802 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1803 f.debug_struct("DssRcm").finish()
1804 }
1805}
1806#[doc = "DSS_RCM"]
1807pub mod dss_rcm;
1808#[doc = "DSS_CTRL"]
1809pub struct DssCtrl {
1810 _marker: PhantomData<*const ()>,
1811}
1812unsafe impl Send for DssCtrl {}
1813impl DssCtrl {
1814 #[doc = r"Pointer to the register block"]
1815 pub const PTR: *const dss_ctrl::RegisterBlock = 0x0602_0000 as *const _;
1816 #[doc = r"Return the pointer to the register block"]
1817 #[inline(always)]
1818 pub const fn ptr() -> *const dss_ctrl::RegisterBlock {
1819 Self::PTR
1820 }
1821 #[doc = r" Steal an instance of this peripheral"]
1822 #[doc = r""]
1823 #[doc = r" # Safety"]
1824 #[doc = r""]
1825 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1826 #[doc = r" that may race with any existing instances, for example by only"]
1827 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1828 #[doc = r" original peripheral and using critical sections to coordinate"]
1829 #[doc = r" access between multiple new instances."]
1830 #[doc = r""]
1831 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1832 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1833 #[doc = r" no stolen instances are passed to such software."]
1834 pub unsafe fn steal() -> Self {
1835 Self {
1836 _marker: PhantomData,
1837 }
1838 }
1839}
1840impl Deref for DssCtrl {
1841 type Target = dss_ctrl::RegisterBlock;
1842 #[inline(always)]
1843 fn deref(&self) -> &Self::Target {
1844 unsafe { &*Self::PTR }
1845 }
1846}
1847impl core::fmt::Debug for DssCtrl {
1848 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1849 f.debug_struct("DssCtrl").finish()
1850 }
1851}
1852#[doc = "DSS_CTRL"]
1853pub mod dss_ctrl;
1854#[doc = "DSS_CBUFF"]
1855pub struct DssCbuff {
1856 _marker: PhantomData<*const ()>,
1857}
1858unsafe impl Send for DssCbuff {}
1859impl DssCbuff {
1860 #[doc = r"Pointer to the register block"]
1861 pub const PTR: *const dss_cbuff::RegisterBlock = 0x0604_0000 as *const _;
1862 #[doc = r"Return the pointer to the register block"]
1863 #[inline(always)]
1864 pub const fn ptr() -> *const dss_cbuff::RegisterBlock {
1865 Self::PTR
1866 }
1867 #[doc = r" Steal an instance of this peripheral"]
1868 #[doc = r""]
1869 #[doc = r" # Safety"]
1870 #[doc = r""]
1871 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1872 #[doc = r" that may race with any existing instances, for example by only"]
1873 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1874 #[doc = r" original peripheral and using critical sections to coordinate"]
1875 #[doc = r" access between multiple new instances."]
1876 #[doc = r""]
1877 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1878 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1879 #[doc = r" no stolen instances are passed to such software."]
1880 pub unsafe fn steal() -> Self {
1881 Self {
1882 _marker: PhantomData,
1883 }
1884 }
1885}
1886impl Deref for DssCbuff {
1887 type Target = dss_cbuff::RegisterBlock;
1888 #[inline(always)]
1889 fn deref(&self) -> &Self::Target {
1890 unsafe { &*Self::PTR }
1891 }
1892}
1893impl core::fmt::Debug for DssCbuff {
1894 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1895 f.debug_struct("DssCbuff").finish()
1896 }
1897}
1898#[doc = "DSS_CBUFF"]
1899pub mod dss_cbuff;
1900#[doc = "DSS_HWA_CFG"]
1901pub struct DssHwaCfg {
1902 _marker: PhantomData<*const ()>,
1903}
1904unsafe impl Send for DssHwaCfg {}
1905impl DssHwaCfg {
1906 #[doc = r"Pointer to the register block"]
1907 pub const PTR: *const dss_hwa_cfg::RegisterBlock = 0x0606_2000 as *const _;
1908 #[doc = r"Return the pointer to the register block"]
1909 #[inline(always)]
1910 pub const fn ptr() -> *const dss_hwa_cfg::RegisterBlock {
1911 Self::PTR
1912 }
1913 #[doc = r" Steal an instance of this peripheral"]
1914 #[doc = r""]
1915 #[doc = r" # Safety"]
1916 #[doc = r""]
1917 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1918 #[doc = r" that may race with any existing instances, for example by only"]
1919 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1920 #[doc = r" original peripheral and using critical sections to coordinate"]
1921 #[doc = r" access between multiple new instances."]
1922 #[doc = r""]
1923 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1924 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1925 #[doc = r" no stolen instances are passed to such software."]
1926 pub unsafe fn steal() -> Self {
1927 Self {
1928 _marker: PhantomData,
1929 }
1930 }
1931}
1932impl Deref for DssHwaCfg {
1933 type Target = dss_hwa_cfg::RegisterBlock;
1934 #[inline(always)]
1935 fn deref(&self) -> &Self::Target {
1936 unsafe { &*Self::PTR }
1937 }
1938}
1939impl core::fmt::Debug for DssHwaCfg {
1940 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1941 f.debug_struct("DssHwaCfg").finish()
1942 }
1943}
1944#[doc = "DSS_HWA_CFG"]
1945pub mod dss_hwa_cfg;
1946#[doc = "DSS_ECC_AGG"]
1947pub struct DssEccAgg {
1948 _marker: PhantomData<*const ()>,
1949}
1950unsafe impl Send for DssEccAgg {}
1951impl DssEccAgg {
1952 #[doc = r"Pointer to the register block"]
1953 pub const PTR: *const dss_ecc_agg::RegisterBlock = 0x060a_0000 as *const _;
1954 #[doc = r"Return the pointer to the register block"]
1955 #[inline(always)]
1956 pub const fn ptr() -> *const dss_ecc_agg::RegisterBlock {
1957 Self::PTR
1958 }
1959 #[doc = r" Steal an instance of this peripheral"]
1960 #[doc = r""]
1961 #[doc = r" # Safety"]
1962 #[doc = r""]
1963 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1964 #[doc = r" that may race with any existing instances, for example by only"]
1965 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1966 #[doc = r" original peripheral and using critical sections to coordinate"]
1967 #[doc = r" access between multiple new instances."]
1968 #[doc = r""]
1969 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1970 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1971 #[doc = r" no stolen instances are passed to such software."]
1972 pub unsafe fn steal() -> Self {
1973 Self {
1974 _marker: PhantomData,
1975 }
1976 }
1977}
1978impl Deref for DssEccAgg {
1979 type Target = dss_ecc_agg::RegisterBlock;
1980 #[inline(always)]
1981 fn deref(&self) -> &Self::Target {
1982 unsafe { &*Self::PTR }
1983 }
1984}
1985impl core::fmt::Debug for DssEccAgg {
1986 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1987 f.debug_struct("DssEccAgg").finish()
1988 }
1989}
1990#[doc = "DSS_ECC_AGG"]
1991pub mod dss_ecc_agg;
1992#[doc = "TPCC"]
1993pub struct DssTpccA {
1994 _marker: PhantomData<*const ()>,
1995}
1996unsafe impl Send for DssTpccA {}
1997impl DssTpccA {
1998 #[doc = r"Pointer to the register block"]
1999 pub const PTR: *const dss_tpcc_a::RegisterBlock = 0x0610_0000 as *const _;
2000 #[doc = r"Return the pointer to the register block"]
2001 #[inline(always)]
2002 pub const fn ptr() -> *const dss_tpcc_a::RegisterBlock {
2003 Self::PTR
2004 }
2005 #[doc = r" Steal an instance of this peripheral"]
2006 #[doc = r""]
2007 #[doc = r" # Safety"]
2008 #[doc = r""]
2009 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2010 #[doc = r" that may race with any existing instances, for example by only"]
2011 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2012 #[doc = r" original peripheral and using critical sections to coordinate"]
2013 #[doc = r" access between multiple new instances."]
2014 #[doc = r""]
2015 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2016 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2017 #[doc = r" no stolen instances are passed to such software."]
2018 pub unsafe fn steal() -> Self {
2019 Self {
2020 _marker: PhantomData,
2021 }
2022 }
2023}
2024impl Deref for DssTpccA {
2025 type Target = dss_tpcc_a::RegisterBlock;
2026 #[inline(always)]
2027 fn deref(&self) -> &Self::Target {
2028 unsafe { &*Self::PTR }
2029 }
2030}
2031impl core::fmt::Debug for DssTpccA {
2032 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2033 f.debug_struct("DssTpccA").finish()
2034 }
2035}
2036#[doc = "TPCC"]
2037pub mod dss_tpcc_a;
2038#[doc = "Register test environment"]
2039pub struct DssTptcA0 {
2040 _marker: PhantomData<*const ()>,
2041}
2042unsafe impl Send for DssTptcA0 {}
2043impl DssTptcA0 {
2044 #[doc = r"Pointer to the register block"]
2045 pub const PTR: *const dss_tptc_a0::RegisterBlock = 0x0616_0000 as *const _;
2046 #[doc = r"Return the pointer to the register block"]
2047 #[inline(always)]
2048 pub const fn ptr() -> *const dss_tptc_a0::RegisterBlock {
2049 Self::PTR
2050 }
2051 #[doc = r" Steal an instance of this peripheral"]
2052 #[doc = r""]
2053 #[doc = r" # Safety"]
2054 #[doc = r""]
2055 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2056 #[doc = r" that may race with any existing instances, for example by only"]
2057 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2058 #[doc = r" original peripheral and using critical sections to coordinate"]
2059 #[doc = r" access between multiple new instances."]
2060 #[doc = r""]
2061 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2062 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2063 #[doc = r" no stolen instances are passed to such software."]
2064 pub unsafe fn steal() -> Self {
2065 Self {
2066 _marker: PhantomData,
2067 }
2068 }
2069}
2070impl Deref for DssTptcA0 {
2071 type Target = dss_tptc_a0::RegisterBlock;
2072 #[inline(always)]
2073 fn deref(&self) -> &Self::Target {
2074 unsafe { &*Self::PTR }
2075 }
2076}
2077impl core::fmt::Debug for DssTptcA0 {
2078 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2079 f.debug_struct("DssTptcA0").finish()
2080 }
2081}
2082#[doc = "Register test environment"]
2083pub mod dss_tptc_a0;
2084#[doc = "Register test environment"]
2085pub struct DssTptcA1 {
2086 _marker: PhantomData<*const ()>,
2087}
2088unsafe impl Send for DssTptcA1 {}
2089impl DssTptcA1 {
2090 #[doc = r"Pointer to the register block"]
2091 pub const PTR: *const dss_tptc_a1::RegisterBlock = 0x0618_0000 as *const _;
2092 #[doc = r"Return the pointer to the register block"]
2093 #[inline(always)]
2094 pub const fn ptr() -> *const dss_tptc_a1::RegisterBlock {
2095 Self::PTR
2096 }
2097 #[doc = r" Steal an instance of this peripheral"]
2098 #[doc = r""]
2099 #[doc = r" # Safety"]
2100 #[doc = r""]
2101 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2102 #[doc = r" that may race with any existing instances, for example by only"]
2103 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2104 #[doc = r" original peripheral and using critical sections to coordinate"]
2105 #[doc = r" access between multiple new instances."]
2106 #[doc = r""]
2107 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2108 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2109 #[doc = r" no stolen instances are passed to such software."]
2110 pub unsafe fn steal() -> Self {
2111 Self {
2112 _marker: PhantomData,
2113 }
2114 }
2115}
2116impl Deref for DssTptcA1 {
2117 type Target = dss_tptc_a1::RegisterBlock;
2118 #[inline(always)]
2119 fn deref(&self) -> &Self::Target {
2120 unsafe { &*Self::PTR }
2121 }
2122}
2123impl core::fmt::Debug for DssTptcA1 {
2124 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2125 f.debug_struct("DssTptcA1").finish()
2126 }
2127}
2128#[doc = "Register test environment"]
2129pub mod dss_tptc_a1;
2130#[doc = "CSI2 protocol engine (MIPI Display Serial Interface Protocole)"]
2131pub struct DssCsi2ProtocolEngine {
2132 _marker: PhantomData<*const ()>,
2133}
2134unsafe impl Send for DssCsi2ProtocolEngine {}
2135impl DssCsi2ProtocolEngine {
2136 #[doc = r"Pointer to the register block"]
2137 pub const PTR: *const dss_csi2_protocol_engine::RegisterBlock = 0x0630_0000 as *const _;
2138 #[doc = r"Return the pointer to the register block"]
2139 #[inline(always)]
2140 pub const fn ptr() -> *const dss_csi2_protocol_engine::RegisterBlock {
2141 Self::PTR
2142 }
2143 #[doc = r" Steal an instance of this peripheral"]
2144 #[doc = r""]
2145 #[doc = r" # Safety"]
2146 #[doc = r""]
2147 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2148 #[doc = r" that may race with any existing instances, for example by only"]
2149 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2150 #[doc = r" original peripheral and using critical sections to coordinate"]
2151 #[doc = r" access between multiple new instances."]
2152 #[doc = r""]
2153 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2154 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2155 #[doc = r" no stolen instances are passed to such software."]
2156 pub unsafe fn steal() -> Self {
2157 Self {
2158 _marker: PhantomData,
2159 }
2160 }
2161}
2162impl Deref for DssCsi2ProtocolEngine {
2163 type Target = dss_csi2_protocol_engine::RegisterBlock;
2164 #[inline(always)]
2165 fn deref(&self) -> &Self::Target {
2166 unsafe { &*Self::PTR }
2167 }
2168}
2169impl core::fmt::Debug for DssCsi2ProtocolEngine {
2170 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2171 f.debug_struct("DssCsi2ProtocolEngine").finish()
2172 }
2173}
2174#[doc = "CSI2 protocol engine (MIPI Display Serial Interface Protocole)"]
2175pub mod dss_csi2_protocol_engine;
2176#[doc = "CSI2_PHY"]
2177pub struct DssCsi2Phy {
2178 _marker: PhantomData<*const ()>,
2179}
2180unsafe impl Send for DssCsi2Phy {}
2181impl DssCsi2Phy {
2182 #[doc = r"Pointer to the register block"]
2183 pub const PTR: *const dss_csi2_phy::RegisterBlock = 0x0630_0200 as *const _;
2184 #[doc = r"Return the pointer to the register block"]
2185 #[inline(always)]
2186 pub const fn ptr() -> *const dss_csi2_phy::RegisterBlock {
2187 Self::PTR
2188 }
2189 #[doc = r" Steal an instance of this peripheral"]
2190 #[doc = r""]
2191 #[doc = r" # Safety"]
2192 #[doc = r""]
2193 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2194 #[doc = r" that may race with any existing instances, for example by only"]
2195 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2196 #[doc = r" original peripheral and using critical sections to coordinate"]
2197 #[doc = r" access between multiple new instances."]
2198 #[doc = r""]
2199 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2200 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2201 #[doc = r" no stolen instances are passed to such software."]
2202 pub unsafe fn steal() -> Self {
2203 Self {
2204 _marker: PhantomData,
2205 }
2206 }
2207}
2208impl Deref for DssCsi2Phy {
2209 type Target = dss_csi2_phy::RegisterBlock;
2210 #[inline(always)]
2211 fn deref(&self) -> &Self::Target {
2212 unsafe { &*Self::PTR }
2213 }
2214}
2215impl core::fmt::Debug for DssCsi2Phy {
2216 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2217 f.debug_struct("DssCsi2Phy").finish()
2218 }
2219}
2220#[doc = "CSI2_PHY"]
2221pub mod dss_csi2_phy;
2222#[doc = "DSS_PCR"]
2223pub struct DssPcr {
2224 _marker: PhantomData<*const ()>,
2225}
2226unsafe impl Send for DssPcr {}
2227impl DssPcr {
2228 #[doc = r"Pointer to the register block"]
2229 pub const PTR: *const dss_pcr::RegisterBlock = 0x06f7_8000 as *const _;
2230 #[doc = r"Return the pointer to the register block"]
2231 #[inline(always)]
2232 pub const fn ptr() -> *const dss_pcr::RegisterBlock {
2233 Self::PTR
2234 }
2235 #[doc = r" Steal an instance of this peripheral"]
2236 #[doc = r""]
2237 #[doc = r" # Safety"]
2238 #[doc = r""]
2239 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2240 #[doc = r" that may race with any existing instances, for example by only"]
2241 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2242 #[doc = r" original peripheral and using critical sections to coordinate"]
2243 #[doc = r" access between multiple new instances."]
2244 #[doc = r""]
2245 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2246 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2247 #[doc = r" no stolen instances are passed to such software."]
2248 pub unsafe fn steal() -> Self {
2249 Self {
2250 _marker: PhantomData,
2251 }
2252 }
2253}
2254impl Deref for DssPcr {
2255 type Target = dss_pcr::RegisterBlock;
2256 #[inline(always)]
2257 fn deref(&self) -> &Self::Target {
2258 unsafe { &*Self::PTR }
2259 }
2260}
2261impl core::fmt::Debug for DssPcr {
2262 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2263 f.debug_struct("DssPcr").finish()
2264 }
2265}
2266#[doc = "DSS_PCR"]
2267pub mod dss_pcr;
2268#[doc = "PBIST"]
2269pub struct DssDspPbist {
2270 _marker: PhantomData<*const ()>,
2271}
2272unsafe impl Send for DssDspPbist {}
2273impl DssDspPbist {
2274 #[doc = r"Pointer to the register block"]
2275 pub const PTR: *const dss_dsp_pbist::RegisterBlock = 0x06f7_9000 as *const _;
2276 #[doc = r"Return the pointer to the register block"]
2277 #[inline(always)]
2278 pub const fn ptr() -> *const dss_dsp_pbist::RegisterBlock {
2279 Self::PTR
2280 }
2281 #[doc = r" Steal an instance of this peripheral"]
2282 #[doc = r""]
2283 #[doc = r" # Safety"]
2284 #[doc = r""]
2285 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2286 #[doc = r" that may race with any existing instances, for example by only"]
2287 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2288 #[doc = r" original peripheral and using critical sections to coordinate"]
2289 #[doc = r" access between multiple new instances."]
2290 #[doc = r""]
2291 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2292 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2293 #[doc = r" no stolen instances are passed to such software."]
2294 pub unsafe fn steal() -> Self {
2295 Self {
2296 _marker: PhantomData,
2297 }
2298 }
2299}
2300impl Deref for DssDspPbist {
2301 type Target = dss_dsp_pbist::RegisterBlock;
2302 #[inline(always)]
2303 fn deref(&self) -> &Self::Target {
2304 unsafe { &*Self::PTR }
2305 }
2306}
2307impl core::fmt::Debug for DssDspPbist {
2308 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2309 f.debug_struct("DssDspPbist").finish()
2310 }
2311}
2312#[doc = "PBIST"]
2313pub mod dss_dsp_pbist;
2314#[doc = "MSS_ESM"]
2315pub struct DssEsm {
2316 _marker: PhantomData<*const ()>,
2317}
2318unsafe impl Send for DssEsm {}
2319impl DssEsm {
2320 #[doc = r"Pointer to the register block"]
2321 pub const PTR: *const dss_esm::RegisterBlock = 0x06f7_d000 as *const _;
2322 #[doc = r"Return the pointer to the register block"]
2323 #[inline(always)]
2324 pub const fn ptr() -> *const dss_esm::RegisterBlock {
2325 Self::PTR
2326 }
2327 #[doc = r" Steal an instance of this peripheral"]
2328 #[doc = r""]
2329 #[doc = r" # Safety"]
2330 #[doc = r""]
2331 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2332 #[doc = r" that may race with any existing instances, for example by only"]
2333 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2334 #[doc = r" original peripheral and using critical sections to coordinate"]
2335 #[doc = r" access between multiple new instances."]
2336 #[doc = r""]
2337 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2338 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2339 #[doc = r" no stolen instances are passed to such software."]
2340 pub unsafe fn steal() -> Self {
2341 Self {
2342 _marker: PhantomData,
2343 }
2344 }
2345}
2346impl Deref for DssEsm {
2347 type Target = dss_esm::RegisterBlock;
2348 #[inline(always)]
2349 fn deref(&self) -> &Self::Target {
2350 unsafe { &*Self::PTR }
2351 }
2352}
2353impl core::fmt::Debug for DssEsm {
2354 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2355 f.debug_struct("DssEsm").finish()
2356 }
2357}
2358#[doc = "MSS_ESM"]
2359pub mod dss_esm;
2360#[doc = "MSS_CPSW"]
2361pub struct MssCpsw {
2362 _marker: PhantomData<*const ()>,
2363}
2364unsafe impl Send for MssCpsw {}
2365impl MssCpsw {
2366 #[doc = r"Pointer to the register block"]
2367 pub const PTR: *const mss_cpsw::RegisterBlock = 0x0700_0000 as *const _;
2368 #[doc = r"Return the pointer to the register block"]
2369 #[inline(always)]
2370 pub const fn ptr() -> *const mss_cpsw::RegisterBlock {
2371 Self::PTR
2372 }
2373 #[doc = r" Steal an instance of this peripheral"]
2374 #[doc = r""]
2375 #[doc = r" # Safety"]
2376 #[doc = r""]
2377 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2378 #[doc = r" that may race with any existing instances, for example by only"]
2379 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2380 #[doc = r" original peripheral and using critical sections to coordinate"]
2381 #[doc = r" access between multiple new instances."]
2382 #[doc = r""]
2383 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2384 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2385 #[doc = r" no stolen instances are passed to such software."]
2386 pub unsafe fn steal() -> Self {
2387 Self {
2388 _marker: PhantomData,
2389 }
2390 }
2391}
2392impl Deref for MssCpsw {
2393 type Target = mss_cpsw::RegisterBlock;
2394 #[inline(always)]
2395 fn deref(&self) -> &Self::Target {
2396 unsafe { &*Self::PTR }
2397 }
2398}
2399impl core::fmt::Debug for MssCpsw {
2400 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2401 f.debug_struct("MssCpsw").finish()
2402 }
2403}
2404#[doc = "MSS_CPSW"]
2405pub mod mss_cpsw;
2406#[doc = "MPU"]
2407pub struct MpuMssL2Banka {
2408 _marker: PhantomData<*const ()>,
2409}
2410unsafe impl Send for MpuMssL2Banka {}
2411impl MpuMssL2Banka {
2412 #[doc = r"Pointer to the register block"]
2413 pub const PTR: *const mpu_mss_l2_banka::RegisterBlock = 0x4002_0000 as *const _;
2414 #[doc = r"Return the pointer to the register block"]
2415 #[inline(always)]
2416 pub const fn ptr() -> *const mpu_mss_l2_banka::RegisterBlock {
2417 Self::PTR
2418 }
2419 #[doc = r" Steal an instance of this peripheral"]
2420 #[doc = r""]
2421 #[doc = r" # Safety"]
2422 #[doc = r""]
2423 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2424 #[doc = r" that may race with any existing instances, for example by only"]
2425 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2426 #[doc = r" original peripheral and using critical sections to coordinate"]
2427 #[doc = r" access between multiple new instances."]
2428 #[doc = r""]
2429 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2430 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2431 #[doc = r" no stolen instances are passed to such software."]
2432 pub unsafe fn steal() -> Self {
2433 Self {
2434 _marker: PhantomData,
2435 }
2436 }
2437}
2438impl Deref for MpuMssL2Banka {
2439 type Target = mpu_mss_l2_banka::RegisterBlock;
2440 #[inline(always)]
2441 fn deref(&self) -> &Self::Target {
2442 unsafe { &*Self::PTR }
2443 }
2444}
2445impl core::fmt::Debug for MpuMssL2Banka {
2446 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2447 f.debug_struct("MpuMssL2Banka").finish()
2448 }
2449}
2450#[doc = "MPU"]
2451pub mod mpu_mss_l2_banka;
2452#[doc = "MPU"]
2453pub struct MpuMssL2Bankb {
2454 _marker: PhantomData<*const ()>,
2455}
2456unsafe impl Send for MpuMssL2Bankb {}
2457impl MpuMssL2Bankb {
2458 #[doc = r"Pointer to the register block"]
2459 pub const PTR: *const mpu_mss_l2_bankb::RegisterBlock = 0x4004_0000 as *const _;
2460 #[doc = r"Return the pointer to the register block"]
2461 #[inline(always)]
2462 pub const fn ptr() -> *const mpu_mss_l2_bankb::RegisterBlock {
2463 Self::PTR
2464 }
2465 #[doc = r" Steal an instance of this peripheral"]
2466 #[doc = r""]
2467 #[doc = r" # Safety"]
2468 #[doc = r""]
2469 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2470 #[doc = r" that may race with any existing instances, for example by only"]
2471 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2472 #[doc = r" original peripheral and using critical sections to coordinate"]
2473 #[doc = r" access between multiple new instances."]
2474 #[doc = r""]
2475 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2476 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2477 #[doc = r" no stolen instances are passed to such software."]
2478 pub unsafe fn steal() -> Self {
2479 Self {
2480 _marker: PhantomData,
2481 }
2482 }
2483}
2484impl Deref for MpuMssL2Bankb {
2485 type Target = mpu_mss_l2_bankb::RegisterBlock;
2486 #[inline(always)]
2487 fn deref(&self) -> &Self::Target {
2488 unsafe { &*Self::PTR }
2489 }
2490}
2491impl core::fmt::Debug for MpuMssL2Bankb {
2492 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2493 f.debug_struct("MpuMssL2Bankb").finish()
2494 }
2495}
2496#[doc = "MPU"]
2497pub mod mpu_mss_l2_bankb;
2498#[doc = "MPU"]
2499pub struct MpuMssMbox {
2500 _marker: PhantomData<*const ()>,
2501}
2502unsafe impl Send for MpuMssMbox {}
2503impl MpuMssMbox {
2504 #[doc = r"Pointer to the register block"]
2505 pub const PTR: *const mpu_mss_mbox::RegisterBlock = 0x4008_0000 as *const _;
2506 #[doc = r"Return the pointer to the register block"]
2507 #[inline(always)]
2508 pub const fn ptr() -> *const mpu_mss_mbox::RegisterBlock {
2509 Self::PTR
2510 }
2511 #[doc = r" Steal an instance of this peripheral"]
2512 #[doc = r""]
2513 #[doc = r" # Safety"]
2514 #[doc = r""]
2515 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2516 #[doc = r" that may race with any existing instances, for example by only"]
2517 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2518 #[doc = r" original peripheral and using critical sections to coordinate"]
2519 #[doc = r" access between multiple new instances."]
2520 #[doc = r""]
2521 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2522 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2523 #[doc = r" no stolen instances are passed to such software."]
2524 pub unsafe fn steal() -> Self {
2525 Self {
2526 _marker: PhantomData,
2527 }
2528 }
2529}
2530impl Deref for MpuMssMbox {
2531 type Target = mpu_mss_mbox::RegisterBlock;
2532 #[inline(always)]
2533 fn deref(&self) -> &Self::Target {
2534 unsafe { &*Self::PTR }
2535 }
2536}
2537impl core::fmt::Debug for MpuMssMbox {
2538 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2539 f.debug_struct("MpuMssMbox").finish()
2540 }
2541}
2542#[doc = "MPU"]
2543pub mod mpu_mss_mbox;
2544#[doc = "MPU"]
2545pub struct MpuMssPcra {
2546 _marker: PhantomData<*const ()>,
2547}
2548unsafe impl Send for MpuMssPcra {}
2549impl MpuMssPcra {
2550 #[doc = r"Pointer to the register block"]
2551 pub const PTR: *const mpu_mss_pcra::RegisterBlock = 0x400a_0000 as *const _;
2552 #[doc = r"Return the pointer to the register block"]
2553 #[inline(always)]
2554 pub const fn ptr() -> *const mpu_mss_pcra::RegisterBlock {
2555 Self::PTR
2556 }
2557 #[doc = r" Steal an instance of this peripheral"]
2558 #[doc = r""]
2559 #[doc = r" # Safety"]
2560 #[doc = r""]
2561 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2562 #[doc = r" that may race with any existing instances, for example by only"]
2563 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2564 #[doc = r" original peripheral and using critical sections to coordinate"]
2565 #[doc = r" access between multiple new instances."]
2566 #[doc = r""]
2567 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2568 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2569 #[doc = r" no stolen instances are passed to such software."]
2570 pub unsafe fn steal() -> Self {
2571 Self {
2572 _marker: PhantomData,
2573 }
2574 }
2575}
2576impl Deref for MpuMssPcra {
2577 type Target = mpu_mss_pcra::RegisterBlock;
2578 #[inline(always)]
2579 fn deref(&self) -> &Self::Target {
2580 unsafe { &*Self::PTR }
2581 }
2582}
2583impl core::fmt::Debug for MpuMssPcra {
2584 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2585 f.debug_struct("MpuMssPcra").finish()
2586 }
2587}
2588#[doc = "MPU"]
2589pub mod mpu_mss_pcra;
2590#[doc = "MPU"]
2591pub struct MpuMssQspi {
2592 _marker: PhantomData<*const ()>,
2593}
2594unsafe impl Send for MpuMssQspi {}
2595impl MpuMssQspi {
2596 #[doc = r"Pointer to the register block"]
2597 pub const PTR: *const mpu_mss_qspi::RegisterBlock = 0x400c_0000 as *const _;
2598 #[doc = r"Return the pointer to the register block"]
2599 #[inline(always)]
2600 pub const fn ptr() -> *const mpu_mss_qspi::RegisterBlock {
2601 Self::PTR
2602 }
2603 #[doc = r" Steal an instance of this peripheral"]
2604 #[doc = r""]
2605 #[doc = r" # Safety"]
2606 #[doc = r""]
2607 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2608 #[doc = r" that may race with any existing instances, for example by only"]
2609 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2610 #[doc = r" original peripheral and using critical sections to coordinate"]
2611 #[doc = r" access between multiple new instances."]
2612 #[doc = r""]
2613 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2614 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2615 #[doc = r" no stolen instances are passed to such software."]
2616 pub unsafe fn steal() -> Self {
2617 Self {
2618 _marker: PhantomData,
2619 }
2620 }
2621}
2622impl Deref for MpuMssQspi {
2623 type Target = mpu_mss_qspi::RegisterBlock;
2624 #[inline(always)]
2625 fn deref(&self) -> &Self::Target {
2626 unsafe { &*Self::PTR }
2627 }
2628}
2629impl core::fmt::Debug for MpuMssQspi {
2630 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2631 f.debug_struct("MpuMssQspi").finish()
2632 }
2633}
2634#[doc = "MPU"]
2635pub mod mpu_mss_qspi;
2636#[doc = "MPU"]
2637pub struct MpuMssCr5aAxis {
2638 _marker: PhantomData<*const ()>,
2639}
2640unsafe impl Send for MpuMssCr5aAxis {}
2641impl MpuMssCr5aAxis {
2642 #[doc = r"Pointer to the register block"]
2643 pub const PTR: *const mpu_mss_cr5a_axis::RegisterBlock = 0x400e_0000 as *const _;
2644 #[doc = r"Return the pointer to the register block"]
2645 #[inline(always)]
2646 pub const fn ptr() -> *const mpu_mss_cr5a_axis::RegisterBlock {
2647 Self::PTR
2648 }
2649 #[doc = r" Steal an instance of this peripheral"]
2650 #[doc = r""]
2651 #[doc = r" # Safety"]
2652 #[doc = r""]
2653 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2654 #[doc = r" that may race with any existing instances, for example by only"]
2655 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2656 #[doc = r" original peripheral and using critical sections to coordinate"]
2657 #[doc = r" access between multiple new instances."]
2658 #[doc = r""]
2659 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2660 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2661 #[doc = r" no stolen instances are passed to such software."]
2662 pub unsafe fn steal() -> Self {
2663 Self {
2664 _marker: PhantomData,
2665 }
2666 }
2667}
2668impl Deref for MpuMssCr5aAxis {
2669 type Target = mpu_mss_cr5a_axis::RegisterBlock;
2670 #[inline(always)]
2671 fn deref(&self) -> &Self::Target {
2672 unsafe { &*Self::PTR }
2673 }
2674}
2675impl core::fmt::Debug for MpuMssCr5aAxis {
2676 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2677 f.debug_struct("MpuMssCr5aAxis").finish()
2678 }
2679}
2680#[doc = "MPU"]
2681pub mod mpu_mss_cr5a_axis;
2682#[doc = "MPU"]
2683pub struct MpuDssL2Bankc {
2684 _marker: PhantomData<*const ()>,
2685}
2686unsafe impl Send for MpuDssL2Bankc {}
2687impl MpuDssL2Bankc {
2688 #[doc = r"Pointer to the register block"]
2689 pub const PTR: *const mpu_dss_l2_bankc::RegisterBlock = 0x4010_0000 as *const _;
2690 #[doc = r"Return the pointer to the register block"]
2691 #[inline(always)]
2692 pub const fn ptr() -> *const mpu_dss_l2_bankc::RegisterBlock {
2693 Self::PTR
2694 }
2695 #[doc = r" Steal an instance of this peripheral"]
2696 #[doc = r""]
2697 #[doc = r" # Safety"]
2698 #[doc = r""]
2699 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2700 #[doc = r" that may race with any existing instances, for example by only"]
2701 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2702 #[doc = r" original peripheral and using critical sections to coordinate"]
2703 #[doc = r" access between multiple new instances."]
2704 #[doc = r""]
2705 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2706 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2707 #[doc = r" no stolen instances are passed to such software."]
2708 pub unsafe fn steal() -> Self {
2709 Self {
2710 _marker: PhantomData,
2711 }
2712 }
2713}
2714impl Deref for MpuDssL2Bankc {
2715 type Target = mpu_dss_l2_bankc::RegisterBlock;
2716 #[inline(always)]
2717 fn deref(&self) -> &Self::Target {
2718 unsafe { &*Self::PTR }
2719 }
2720}
2721impl core::fmt::Debug for MpuDssL2Bankc {
2722 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2723 f.debug_struct("MpuDssL2Bankc").finish()
2724 }
2725}
2726#[doc = "MPU"]
2727pub mod mpu_dss_l2_bankc;
2728#[doc = "MPU"]
2729pub struct MpuDssL3Banka {
2730 _marker: PhantomData<*const ()>,
2731}
2732unsafe impl Send for MpuDssL3Banka {}
2733impl MpuDssL3Banka {
2734 #[doc = r"Pointer to the register block"]
2735 pub const PTR: *const mpu_dss_l3_banka::RegisterBlock = 0x4012_0000 as *const _;
2736 #[doc = r"Return the pointer to the register block"]
2737 #[inline(always)]
2738 pub const fn ptr() -> *const mpu_dss_l3_banka::RegisterBlock {
2739 Self::PTR
2740 }
2741 #[doc = r" Steal an instance of this peripheral"]
2742 #[doc = r""]
2743 #[doc = r" # Safety"]
2744 #[doc = r""]
2745 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2746 #[doc = r" that may race with any existing instances, for example by only"]
2747 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2748 #[doc = r" original peripheral and using critical sections to coordinate"]
2749 #[doc = r" access between multiple new instances."]
2750 #[doc = r""]
2751 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2752 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2753 #[doc = r" no stolen instances are passed to such software."]
2754 pub unsafe fn steal() -> Self {
2755 Self {
2756 _marker: PhantomData,
2757 }
2758 }
2759}
2760impl Deref for MpuDssL3Banka {
2761 type Target = mpu_dss_l3_banka::RegisterBlock;
2762 #[inline(always)]
2763 fn deref(&self) -> &Self::Target {
2764 unsafe { &*Self::PTR }
2765 }
2766}
2767impl core::fmt::Debug for MpuDssL3Banka {
2768 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2769 f.debug_struct("MpuDssL3Banka").finish()
2770 }
2771}
2772#[doc = "MPU"]
2773pub mod mpu_dss_l3_banka;
2774#[doc = "MPU"]
2775pub struct MpuDssL3Bankb {
2776 _marker: PhantomData<*const ()>,
2777}
2778unsafe impl Send for MpuDssL3Bankb {}
2779impl MpuDssL3Bankb {
2780 #[doc = r"Pointer to the register block"]
2781 pub const PTR: *const mpu_dss_l3_bankb::RegisterBlock = 0x4014_0000 as *const _;
2782 #[doc = r"Return the pointer to the register block"]
2783 #[inline(always)]
2784 pub const fn ptr() -> *const mpu_dss_l3_bankb::RegisterBlock {
2785 Self::PTR
2786 }
2787 #[doc = r" Steal an instance of this peripheral"]
2788 #[doc = r""]
2789 #[doc = r" # Safety"]
2790 #[doc = r""]
2791 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2792 #[doc = r" that may race with any existing instances, for example by only"]
2793 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2794 #[doc = r" original peripheral and using critical sections to coordinate"]
2795 #[doc = r" access between multiple new instances."]
2796 #[doc = r""]
2797 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2798 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2799 #[doc = r" no stolen instances are passed to such software."]
2800 pub unsafe fn steal() -> Self {
2801 Self {
2802 _marker: PhantomData,
2803 }
2804 }
2805}
2806impl Deref for MpuDssL3Bankb {
2807 type Target = mpu_dss_l3_bankb::RegisterBlock;
2808 #[inline(always)]
2809 fn deref(&self) -> &Self::Target {
2810 unsafe { &*Self::PTR }
2811 }
2812}
2813impl core::fmt::Debug for MpuDssL3Bankb {
2814 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2815 f.debug_struct("MpuDssL3Bankb").finish()
2816 }
2817}
2818#[doc = "MPU"]
2819pub mod mpu_dss_l3_bankb;
2820#[doc = "MSS_MCRC"]
2821pub struct DssMcrc {
2822 _marker: PhantomData<*const ()>,
2823}
2824unsafe impl Send for DssMcrc {}
2825impl DssMcrc {
2826 #[doc = r"Pointer to the register block"]
2827 pub const PTR: *const dss_mcrc::RegisterBlock = 0x8330_0000 as *const _;
2828 #[doc = r"Return the pointer to the register block"]
2829 #[inline(always)]
2830 pub const fn ptr() -> *const dss_mcrc::RegisterBlock {
2831 Self::PTR
2832 }
2833 #[doc = r" Steal an instance of this peripheral"]
2834 #[doc = r""]
2835 #[doc = r" # Safety"]
2836 #[doc = r""]
2837 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2838 #[doc = r" that may race with any existing instances, for example by only"]
2839 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2840 #[doc = r" original peripheral and using critical sections to coordinate"]
2841 #[doc = r" access between multiple new instances."]
2842 #[doc = r""]
2843 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2844 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2845 #[doc = r" no stolen instances are passed to such software."]
2846 pub unsafe fn steal() -> Self {
2847 Self {
2848 _marker: PhantomData,
2849 }
2850 }
2851}
2852impl Deref for DssMcrc {
2853 type Target = dss_mcrc::RegisterBlock;
2854 #[inline(always)]
2855 fn deref(&self) -> &Self::Target {
2856 unsafe { &*Self::PTR }
2857 }
2858}
2859impl core::fmt::Debug for DssMcrc {
2860 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2861 f.debug_struct("DssMcrc").finish()
2862 }
2863}
2864#[doc = "MSS_MCRC"]
2865pub mod dss_mcrc;
2866#[doc = "MSS_MCRC"]
2867pub struct MssMcrc {
2868 _marker: PhantomData<*const ()>,
2869}
2870unsafe impl Send for MssMcrc {}
2871impl MssMcrc {
2872 #[doc = r"Pointer to the register block"]
2873 pub const PTR: *const mss_mcrc::RegisterBlock = 0xc502_0000 as *const _;
2874 #[doc = r"Return the pointer to the register block"]
2875 #[inline(always)]
2876 pub const fn ptr() -> *const mss_mcrc::RegisterBlock {
2877 Self::PTR
2878 }
2879 #[doc = r" Steal an instance of this peripheral"]
2880 #[doc = r""]
2881 #[doc = r" # Safety"]
2882 #[doc = r""]
2883 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2884 #[doc = r" that may race with any existing instances, for example by only"]
2885 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2886 #[doc = r" original peripheral and using critical sections to coordinate"]
2887 #[doc = r" access between multiple new instances."]
2888 #[doc = r""]
2889 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2890 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2891 #[doc = r" no stolen instances are passed to such software."]
2892 pub unsafe fn steal() -> Self {
2893 Self {
2894 _marker: PhantomData,
2895 }
2896 }
2897}
2898impl Deref for MssMcrc {
2899 type Target = mss_mcrc::RegisterBlock;
2900 #[inline(always)]
2901 fn deref(&self) -> &Self::Target {
2902 unsafe { &*Self::PTR }
2903 }
2904}
2905impl core::fmt::Debug for MssMcrc {
2906 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2907 f.debug_struct("MssMcrc").finish()
2908 }
2909}
2910#[doc = "MSS_MCRC"]
2911pub mod mss_mcrc;
2912#[doc = "MSS_GPADC_DATA_RAM"]
2913pub struct MssGpadcDataRam {
2914 _marker: PhantomData<*const ()>,
2915}
2916unsafe impl Send for MssGpadcDataRam {}
2917impl MssGpadcDataRam {
2918 #[doc = r"Pointer to the register block"]
2919 pub const PTR: *const mss_gpadc_data_ram::RegisterBlock = 0xc503_0000 as *const _;
2920 #[doc = r"Return the pointer to the register block"]
2921 #[inline(always)]
2922 pub const fn ptr() -> *const mss_gpadc_data_ram::RegisterBlock {
2923 Self::PTR
2924 }
2925 #[doc = r" Steal an instance of this peripheral"]
2926 #[doc = r""]
2927 #[doc = r" # Safety"]
2928 #[doc = r""]
2929 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2930 #[doc = r" that may race with any existing instances, for example by only"]
2931 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2932 #[doc = r" original peripheral and using critical sections to coordinate"]
2933 #[doc = r" access between multiple new instances."]
2934 #[doc = r""]
2935 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2936 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2937 #[doc = r" no stolen instances are passed to such software."]
2938 pub unsafe fn steal() -> Self {
2939 Self {
2940 _marker: PhantomData,
2941 }
2942 }
2943}
2944impl Deref for MssGpadcDataRam {
2945 type Target = mss_gpadc_data_ram::RegisterBlock;
2946 #[inline(always)]
2947 fn deref(&self) -> &Self::Target {
2948 unsafe { &*Self::PTR }
2949 }
2950}
2951impl core::fmt::Debug for MssGpadcDataRam {
2952 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2953 f.debug_struct("MssGpadcDataRam").finish()
2954 }
2955}
2956#[doc = "MSS_GPADC_DATA_RAM"]
2957pub mod mss_gpadc_data_ram;
2958#[doc = "MSS_QSPI"]
2959pub struct MssQspi {
2960 _marker: PhantomData<*const ()>,
2961}
2962unsafe impl Send for MssQspi {}
2963impl MssQspi {
2964 #[doc = r"Pointer to the register block"]
2965 pub const PTR: *const mss_qspi::RegisterBlock = 0xc800_0000 as *const _;
2966 #[doc = r"Return the pointer to the register block"]
2967 #[inline(always)]
2968 pub const fn ptr() -> *const mss_qspi::RegisterBlock {
2969 Self::PTR
2970 }
2971 #[doc = r" Steal an instance of this peripheral"]
2972 #[doc = r""]
2973 #[doc = r" # Safety"]
2974 #[doc = r""]
2975 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2976 #[doc = r" that may race with any existing instances, for example by only"]
2977 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2978 #[doc = r" original peripheral and using critical sections to coordinate"]
2979 #[doc = r" access between multiple new instances."]
2980 #[doc = r""]
2981 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2982 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2983 #[doc = r" no stolen instances are passed to such software."]
2984 pub unsafe fn steal() -> Self {
2985 Self {
2986 _marker: PhantomData,
2987 }
2988 }
2989}
2990impl Deref for MssQspi {
2991 type Target = mss_qspi::RegisterBlock;
2992 #[inline(always)]
2993 fn deref(&self) -> &Self::Target {
2994 unsafe { &*Self::PTR }
2995 }
2996}
2997impl core::fmt::Debug for MssQspi {
2998 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2999 f.debug_struct("MssQspi").finish()
3000 }
3001}
3002#[doc = "MSS_QSPI"]
3003pub mod mss_qspi;
3004#[no_mangle]
3005static mut DEVICE_PERIPHERALS: bool = false;
3006#[doc = r" All the peripherals."]
3007#[allow(non_snake_case)]
3008pub struct Peripherals {
3009 #[doc = "MSS_VIM_R5A"]
3010 pub mss_vim_r5a: MssVimR5a,
3011 #[doc = "MSS_IOMUX"]
3012 pub mss_iomux: MssIomux,
3013 #[doc = "MSS_RCM"]
3014 pub mss_rcm: MssRcm,
3015 #[doc = "MSS_CTRL"]
3016 pub mss_ctrl: MssCtrl,
3017 #[doc = "MSS_TOPRCM"]
3018 pub mss_toprcm: MssToprcm,
3019 #[doc = "MSS_PCR1"]
3020 pub mss_pcr1: MssPcr1,
3021 #[doc = "TOP_PBIST"]
3022 pub top_pbist: TopPbist,
3023 #[doc = "MSS_R5SS_STC"]
3024 pub mss_r5ss_stc: MssR5ssStc,
3025 #[doc = "MSS_DCCA"]
3026 pub mss_dcca: MssDcca,
3027 #[doc = "MSS_DCCB"]
3028 pub mss_dccb: MssDccb,
3029 #[doc = "MSS_DCCC"]
3030 pub mss_dccc: MssDccc,
3031 #[doc = "MSS_DCCD"]
3032 pub mss_dccd: MssDccd,
3033 #[doc = "MSS_RTIA"]
3034 pub mss_rtia: MssRtia,
3035 #[doc = "MSS_RTIB"]
3036 pub mss_rtib: MssRtib,
3037 #[doc = "MSS_RTIC"]
3038 pub mss_rtic: MssRtic,
3039 #[doc = "MSS_WDT"]
3040 pub mss_wdt: MssWdt,
3041 #[doc = "MSS_ESM"]
3042 pub mss_esm: MssEsm,
3043 #[doc = "MSS_CCMR"]
3044 pub mss_ccmr: MssCcmr,
3045 #[doc = "MSS_I2C"]
3046 pub mss_i2c: MssI2c,
3047 #[doc = "MSS_GIO"]
3048 pub mss_gio: MssGio,
3049 #[doc = "MSS_ECC_AGG_R5A"]
3050 pub mss_ecc_agg_r5a: MssEccAggR5a,
3051 #[doc = "MSS_ECC_AGG_MSS"]
3052 pub mss_ecc_agg_mss: MssEccAggMss,
3053 #[doc = "MSS_SPIB"]
3054 pub mss_spib: MssSpib,
3055 #[doc = "MSS_SCIA"]
3056 pub mss_scia: MssScia,
3057 #[doc = "MSS_SCIB"]
3058 pub mss_scib: MssScib,
3059 #[doc = "MSS_GPADC_PKT_RAM"]
3060 pub mss_gpadc_pkt_ram: MssGpadcPktRam,
3061 #[doc = "TOP_CTRL"]
3062 pub top_ctrl: TopCtrl,
3063 #[doc = "MSS_TPCC_A"]
3064 pub mss_tpcc_a: MssTpccA,
3065 #[doc = "MSS_TPTC_A0"]
3066 pub mss_tptc_a0: MssTptcA0,
3067 #[doc = "MSS_TPTC_A1"]
3068 pub mss_tptc_a1: MssTptcA1,
3069 #[doc = "MSS_PCR2"]
3070 pub mss_pcr2: MssPcr2,
3071 #[doc = "MSS_ETPWMA"]
3072 pub mss_etpwma: MssEtpwma,
3073 #[doc = "MSS_ETPWMB"]
3074 pub mss_etpwmb: MssEtpwmb,
3075 #[doc = "MSS_ETPWMC"]
3076 pub mss_etpwmc: MssEtpwmc,
3077 #[doc = "RSS_RCM"]
3078 pub rss_rcm: RssRcm,
3079 #[doc = "RSS_CTRL"]
3080 pub rss_ctrl: RssCtrl,
3081 #[doc = "RSS_TPCC_A"]
3082 pub rss_tpcc_a: RssTpccA,
3083 #[doc = "RSS_TPTC_A0"]
3084 pub rss_tptc_a0: RssTptcA0,
3085 #[doc = "DSS_RCM"]
3086 pub dss_rcm: DssRcm,
3087 #[doc = "DSS_CTRL"]
3088 pub dss_ctrl: DssCtrl,
3089 #[doc = "DSS_CBUFF"]
3090 pub dss_cbuff: DssCbuff,
3091 #[doc = "DSS_HWA_CFG"]
3092 pub dss_hwa_cfg: DssHwaCfg,
3093 #[doc = "DSS_ECC_AGG"]
3094 pub dss_ecc_agg: DssEccAgg,
3095 #[doc = "DSS_TPCC_A"]
3096 pub dss_tpcc_a: DssTpccA,
3097 #[doc = "DSS_TPTC_A0"]
3098 pub dss_tptc_a0: DssTptcA0,
3099 #[doc = "DSS_TPTC_A1"]
3100 pub dss_tptc_a1: DssTptcA1,
3101 #[doc = "DSS_CSI2_PROTOCOL_ENGINE"]
3102 pub dss_csi2_protocol_engine: DssCsi2ProtocolEngine,
3103 #[doc = "DSS_CSI2_PHY"]
3104 pub dss_csi2_phy: DssCsi2Phy,
3105 #[doc = "DSS_PCR"]
3106 pub dss_pcr: DssPcr,
3107 #[doc = "DSS_DSP_PBIST"]
3108 pub dss_dsp_pbist: DssDspPbist,
3109 #[doc = "DSS_ESM"]
3110 pub dss_esm: DssEsm,
3111 #[doc = "MSS_CPSW"]
3112 pub mss_cpsw: MssCpsw,
3113 #[doc = "MPU_MSS_L2_BANKA"]
3114 pub mpu_mss_l2_banka: MpuMssL2Banka,
3115 #[doc = "MPU_MSS_L2_BANKB"]
3116 pub mpu_mss_l2_bankb: MpuMssL2Bankb,
3117 #[doc = "MPU_MSS_MBOX"]
3118 pub mpu_mss_mbox: MpuMssMbox,
3119 #[doc = "MPU_MSS_PCRA"]
3120 pub mpu_mss_pcra: MpuMssPcra,
3121 #[doc = "MPU_MSS_QSPI"]
3122 pub mpu_mss_qspi: MpuMssQspi,
3123 #[doc = "MPU_MSS_CR5A_AXIS"]
3124 pub mpu_mss_cr5a_axis: MpuMssCr5aAxis,
3125 #[doc = "MPU_DSS_L2_BANKC"]
3126 pub mpu_dss_l2_bankc: MpuDssL2Bankc,
3127 #[doc = "MPU_DSS_L3_BANKA"]
3128 pub mpu_dss_l3_banka: MpuDssL3Banka,
3129 #[doc = "MPU_DSS_L3_BANKB"]
3130 pub mpu_dss_l3_bankb: MpuDssL3Bankb,
3131 #[doc = "DSS_MCRC"]
3132 pub dss_mcrc: DssMcrc,
3133 #[doc = "MSS_MCRC"]
3134 pub mss_mcrc: MssMcrc,
3135 #[doc = "MSS_GPADC_DATA_RAM"]
3136 pub mss_gpadc_data_ram: MssGpadcDataRam,
3137 #[doc = "MSS_QSPI"]
3138 pub mss_qspi: MssQspi,
3139}
3140impl Peripherals {
3141 #[doc = r" Returns all the peripherals *once*."]
3142 #[cfg(feature = "critical-section")]
3143 #[inline]
3144 pub fn take() -> Option<Self> {
3145 critical_section::with(|_| {
3146 if unsafe { DEVICE_PERIPHERALS } {
3147 return None;
3148 }
3149 Some(unsafe { Peripherals::steal() })
3150 })
3151 }
3152 #[doc = r" Unchecked version of `Peripherals::take`."]
3153 #[doc = r""]
3154 #[doc = r" # Safety"]
3155 #[doc = r""]
3156 #[doc = r" Each of the returned peripherals must be used at most once."]
3157 #[inline]
3158 pub unsafe fn steal() -> Self {
3159 DEVICE_PERIPHERALS = true;
3160 Peripherals {
3161 mss_vim_r5a: MssVimR5a::steal(),
3162 mss_iomux: MssIomux::steal(),
3163 mss_rcm: MssRcm::steal(),
3164 mss_ctrl: MssCtrl::steal(),
3165 mss_toprcm: MssToprcm::steal(),
3166 mss_pcr1: MssPcr1::steal(),
3167 top_pbist: TopPbist::steal(),
3168 mss_r5ss_stc: MssR5ssStc::steal(),
3169 mss_dcca: MssDcca::steal(),
3170 mss_dccb: MssDccb::steal(),
3171 mss_dccc: MssDccc::steal(),
3172 mss_dccd: MssDccd::steal(),
3173 mss_rtia: MssRtia::steal(),
3174 mss_rtib: MssRtib::steal(),
3175 mss_rtic: MssRtic::steal(),
3176 mss_wdt: MssWdt::steal(),
3177 mss_esm: MssEsm::steal(),
3178 mss_ccmr: MssCcmr::steal(),
3179 mss_i2c: MssI2c::steal(),
3180 mss_gio: MssGio::steal(),
3181 mss_ecc_agg_r5a: MssEccAggR5a::steal(),
3182 mss_ecc_agg_mss: MssEccAggMss::steal(),
3183 mss_spib: MssSpib::steal(),
3184 mss_scia: MssScia::steal(),
3185 mss_scib: MssScib::steal(),
3186 mss_gpadc_pkt_ram: MssGpadcPktRam::steal(),
3187 top_ctrl: TopCtrl::steal(),
3188 mss_tpcc_a: MssTpccA::steal(),
3189 mss_tptc_a0: MssTptcA0::steal(),
3190 mss_tptc_a1: MssTptcA1::steal(),
3191 mss_pcr2: MssPcr2::steal(),
3192 mss_etpwma: MssEtpwma::steal(),
3193 mss_etpwmb: MssEtpwmb::steal(),
3194 mss_etpwmc: MssEtpwmc::steal(),
3195 rss_rcm: RssRcm::steal(),
3196 rss_ctrl: RssCtrl::steal(),
3197 rss_tpcc_a: RssTpccA::steal(),
3198 rss_tptc_a0: RssTptcA0::steal(),
3199 dss_rcm: DssRcm::steal(),
3200 dss_ctrl: DssCtrl::steal(),
3201 dss_cbuff: DssCbuff::steal(),
3202 dss_hwa_cfg: DssHwaCfg::steal(),
3203 dss_ecc_agg: DssEccAgg::steal(),
3204 dss_tpcc_a: DssTpccA::steal(),
3205 dss_tptc_a0: DssTptcA0::steal(),
3206 dss_tptc_a1: DssTptcA1::steal(),
3207 dss_csi2_protocol_engine: DssCsi2ProtocolEngine::steal(),
3208 dss_csi2_phy: DssCsi2Phy::steal(),
3209 dss_pcr: DssPcr::steal(),
3210 dss_dsp_pbist: DssDspPbist::steal(),
3211 dss_esm: DssEsm::steal(),
3212 mss_cpsw: MssCpsw::steal(),
3213 mpu_mss_l2_banka: MpuMssL2Banka::steal(),
3214 mpu_mss_l2_bankb: MpuMssL2Bankb::steal(),
3215 mpu_mss_mbox: MpuMssMbox::steal(),
3216 mpu_mss_pcra: MpuMssPcra::steal(),
3217 mpu_mss_qspi: MpuMssQspi::steal(),
3218 mpu_mss_cr5a_axis: MpuMssCr5aAxis::steal(),
3219 mpu_dss_l2_bankc: MpuDssL2Bankc::steal(),
3220 mpu_dss_l3_banka: MpuDssL3Banka::steal(),
3221 mpu_dss_l3_bankb: MpuDssL3Bankb::steal(),
3222 dss_mcrc: DssMcrc::steal(),
3223 mss_mcrc: MssMcrc::steal(),
3224 mss_gpadc_data_ram: MssGpadcDataRam::steal(),
3225 mss_qspi: MssQspi::steal(),
3226 }
3227 }
3228}