1#![doc = "Peripheral access API for RK3399 microcontrollers (generated using svd2rust v0.32.0 ( ))\n\nYou can find an overview of the generated API [here].\n\nAPI features to be included in the [next]
2svd2rust release can be generated by cloning the svd2rust [repository], checking out the above commit, and running `cargo doc --open`.\n\n[here]: https://docs.rs/svd2rust/0.32.0/svd2rust/#peripheral-api\n[next]: https://github.com/rust-embedded/svd2rust/blob/master/CHANGELOG.md#unreleased\n[repository]: https://github.com/rust-embedded/svd2rust"]
3#![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 = 4;
10#[allow(unused_imports)]
11use generic::*;
12#[doc = r"Common register and bit access and modify traits"]
13pub mod generic;
14#[doc(hidden)]
15pub mod interrupt;
16pub use self::interrupt::Interrupt;
17#[doc = "Cache Coherent Interconnect 500 (CCI500) Registers"]
18pub struct Cci500 {
19 _marker: PhantomData<*const ()>,
20}
21unsafe impl Send for Cci500 {}
22impl Cci500 {
23 #[doc = r"Pointer to the register block"]
24 pub const PTR: *const cci500::RegisterBlock = 0xffb0_0000 as *const _;
25 #[doc = r"Return the pointer to the register block"]
26 #[inline(always)]
27 pub const fn ptr() -> *const cci500::RegisterBlock {
28 Self::PTR
29 }
30 #[doc = r" Steal an instance of this peripheral"]
31 #[doc = r""]
32 #[doc = r" # Safety"]
33 #[doc = r""]
34 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
35 #[doc = r" that may race with any existing instances, for example by only"]
36 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
37 #[doc = r" original peripheral and using critical sections to coordinate"]
38 #[doc = r" access between multiple new instances."]
39 #[doc = r""]
40 #[doc = r" Additionally, other software such as HALs may rely on only one"]
41 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
42 #[doc = r" no stolen instances are passed to such software."]
43 pub unsafe fn steal() -> Self {
44 Self {
45 _marker: PhantomData,
46 }
47 }
48}
49impl Deref for Cci500 {
50 type Target = cci500::RegisterBlock;
51 #[inline(always)]
52 fn deref(&self) -> &Self::Target {
53 unsafe { &*Self::PTR }
54 }
55}
56impl core::fmt::Debug for Cci500 {
57 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
58 f.debug_struct("Cci500").finish()
59 }
60}
61#[doc = "Cache Coherent Interconnect 500 (CCI500) Registers"]
62pub mod cci500;
63#[doc = "Clock and Reset Unit (CRU) Registers"]
64pub struct Cru {
65 _marker: PhantomData<*const ()>,
66}
67unsafe impl Send for Cru {}
68impl Cru {
69 #[doc = r"Pointer to the register block"]
70 pub const PTR: *const cru::RegisterBlock = 0xff76_0000 as *const _;
71 #[doc = r"Return the pointer to the register block"]
72 #[inline(always)]
73 pub const fn ptr() -> *const cru::RegisterBlock {
74 Self::PTR
75 }
76 #[doc = r" Steal an instance of this peripheral"]
77 #[doc = r""]
78 #[doc = r" # Safety"]
79 #[doc = r""]
80 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
81 #[doc = r" that may race with any existing instances, for example by only"]
82 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
83 #[doc = r" original peripheral and using critical sections to coordinate"]
84 #[doc = r" access between multiple new instances."]
85 #[doc = r""]
86 #[doc = r" Additionally, other software such as HALs may rely on only one"]
87 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
88 #[doc = r" no stolen instances are passed to such software."]
89 pub unsafe fn steal() -> Self {
90 Self {
91 _marker: PhantomData,
92 }
93 }
94}
95impl Deref for Cru {
96 type Target = cru::RegisterBlock;
97 #[inline(always)]
98 fn deref(&self) -> &Self::Target {
99 unsafe { &*Self::PTR }
100 }
101}
102impl core::fmt::Debug for Cru {
103 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
104 f.debug_struct("Cru").finish()
105 }
106}
107#[doc = "Clock and Reset Unit (CRU) Registers"]
108pub mod cru;
109#[doc = "Crypto Registers"]
110pub struct Crypto {
111 _marker: PhantomData<*const ()>,
112}
113unsafe impl Send for Crypto {}
114impl Crypto {
115 #[doc = r"Pointer to the register block"]
116 pub const PTR: *const crypto::RegisterBlock = 0xff8b_0000 as *const _;
117 #[doc = r"Return the pointer to the register block"]
118 #[inline(always)]
119 pub const fn ptr() -> *const crypto::RegisterBlock {
120 Self::PTR
121 }
122 #[doc = r" Steal an instance of this peripheral"]
123 #[doc = r""]
124 #[doc = r" # Safety"]
125 #[doc = r""]
126 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
127 #[doc = r" that may race with any existing instances, for example by only"]
128 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
129 #[doc = r" original peripheral and using critical sections to coordinate"]
130 #[doc = r" access between multiple new instances."]
131 #[doc = r""]
132 #[doc = r" Additionally, other software such as HALs may rely on only one"]
133 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
134 #[doc = r" no stolen instances are passed to such software."]
135 pub unsafe fn steal() -> Self {
136 Self {
137 _marker: PhantomData,
138 }
139 }
140}
141impl Deref for Crypto {
142 type Target = crypto::RegisterBlock;
143 #[inline(always)]
144 fn deref(&self) -> &Self::Target {
145 unsafe { &*Self::PTR }
146 }
147}
148impl core::fmt::Debug for Crypto {
149 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
150 f.debug_struct("Crypto").finish()
151 }
152}
153#[doc = "Crypto Registers"]
154pub mod crypto;
155#[doc = "Crypto 0 Registers"]
156pub struct Crypto0 {
157 _marker: PhantomData<*const ()>,
158}
159unsafe impl Send for Crypto0 {}
160impl Crypto0 {
161 #[doc = r"Pointer to the register block"]
162 pub const PTR: *const crypto::RegisterBlock = 0xff8b_0000 as *const _;
163 #[doc = r"Return the pointer to the register block"]
164 #[inline(always)]
165 pub const fn ptr() -> *const crypto::RegisterBlock {
166 Self::PTR
167 }
168 #[doc = r" Steal an instance of this peripheral"]
169 #[doc = r""]
170 #[doc = r" # Safety"]
171 #[doc = r""]
172 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
173 #[doc = r" that may race with any existing instances, for example by only"]
174 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
175 #[doc = r" original peripheral and using critical sections to coordinate"]
176 #[doc = r" access between multiple new instances."]
177 #[doc = r""]
178 #[doc = r" Additionally, other software such as HALs may rely on only one"]
179 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
180 #[doc = r" no stolen instances are passed to such software."]
181 pub unsafe fn steal() -> Self {
182 Self {
183 _marker: PhantomData,
184 }
185 }
186}
187impl Deref for Crypto0 {
188 type Target = crypto::RegisterBlock;
189 #[inline(always)]
190 fn deref(&self) -> &Self::Target {
191 unsafe { &*Self::PTR }
192 }
193}
194impl core::fmt::Debug for Crypto0 {
195 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
196 f.debug_struct("Crypto0").finish()
197 }
198}
199#[doc = "Crypto 0 Registers"]
200pub use self::crypto as crypto0;
201#[doc = "Crypto 1 Registers"]
202pub struct Crypto1 {
203 _marker: PhantomData<*const ()>,
204}
205unsafe impl Send for Crypto1 {}
206impl Crypto1 {
207 #[doc = r"Pointer to the register block"]
208 pub const PTR: *const crypto::RegisterBlock = 0xff8b_8000 as *const _;
209 #[doc = r"Return the pointer to the register block"]
210 #[inline(always)]
211 pub const fn ptr() -> *const crypto::RegisterBlock {
212 Self::PTR
213 }
214 #[doc = r" Steal an instance of this peripheral"]
215 #[doc = r""]
216 #[doc = r" # Safety"]
217 #[doc = r""]
218 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
219 #[doc = r" that may race with any existing instances, for example by only"]
220 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
221 #[doc = r" original peripheral and using critical sections to coordinate"]
222 #[doc = r" access between multiple new instances."]
223 #[doc = r""]
224 #[doc = r" Additionally, other software such as HALs may rely on only one"]
225 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
226 #[doc = r" no stolen instances are passed to such software."]
227 pub unsafe fn steal() -> Self {
228 Self {
229 _marker: PhantomData,
230 }
231 }
232}
233impl Deref for Crypto1 {
234 type Target = crypto::RegisterBlock;
235 #[inline(always)]
236 fn deref(&self) -> &Self::Target {
237 unsafe { &*Self::PTR }
238 }
239}
240impl core::fmt::Debug for Crypto1 {
241 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
242 f.debug_struct("Crypto1").finish()
243 }
244}
245#[doc = "Crypto 1 Registers"]
246pub use self::crypto as crypto1;
247#[doc = "DDR Converser of Frequency (DCF) Registers"]
248pub struct Dcf {
249 _marker: PhantomData<*const ()>,
250}
251unsafe impl Send for Dcf {}
252impl Dcf {
253 #[doc = r"Pointer to the register block"]
254 pub const PTR: *const dcf::RegisterBlock = 0xff6a_0000 as *const _;
255 #[doc = r"Return the pointer to the register block"]
256 #[inline(always)]
257 pub const fn ptr() -> *const dcf::RegisterBlock {
258 Self::PTR
259 }
260 #[doc = r" Steal an instance of this peripheral"]
261 #[doc = r""]
262 #[doc = r" # Safety"]
263 #[doc = r""]
264 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
265 #[doc = r" that may race with any existing instances, for example by only"]
266 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
267 #[doc = r" original peripheral and using critical sections to coordinate"]
268 #[doc = r" access between multiple new instances."]
269 #[doc = r""]
270 #[doc = r" Additionally, other software such as HALs may rely on only one"]
271 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
272 #[doc = r" no stolen instances are passed to such software."]
273 pub unsafe fn steal() -> Self {
274 Self {
275 _marker: PhantomData,
276 }
277 }
278}
279impl Deref for Dcf {
280 type Target = dcf::RegisterBlock;
281 #[inline(always)]
282 fn deref(&self) -> &Self::Target {
283 unsafe { &*Self::PTR }
284 }
285}
286impl core::fmt::Debug for Dcf {
287 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
288 f.debug_struct("Dcf").finish()
289 }
290}
291#[doc = "DDR Converser of Frequency (DCF) Registers"]
292pub mod dcf;
293#[doc = "DDR Controller (DDRC) Registers"]
294pub struct Ddrc {
295 _marker: PhantomData<*const ()>,
296}
297unsafe impl Send for Ddrc {}
298impl Ddrc {
299 #[doc = r"Pointer to the register block"]
300 pub const PTR: *const ddrc::RegisterBlock = 0xffa8_0000 as *const _;
301 #[doc = r"Return the pointer to the register block"]
302 #[inline(always)]
303 pub const fn ptr() -> *const ddrc::RegisterBlock {
304 Self::PTR
305 }
306 #[doc = r" Steal an instance of this peripheral"]
307 #[doc = r""]
308 #[doc = r" # Safety"]
309 #[doc = r""]
310 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
311 #[doc = r" that may race with any existing instances, for example by only"]
312 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
313 #[doc = r" original peripheral and using critical sections to coordinate"]
314 #[doc = r" access between multiple new instances."]
315 #[doc = r""]
316 #[doc = r" Additionally, other software such as HALs may rely on only one"]
317 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
318 #[doc = r" no stolen instances are passed to such software."]
319 pub unsafe fn steal() -> Self {
320 Self {
321 _marker: PhantomData,
322 }
323 }
324}
325impl Deref for Ddrc {
326 type Target = ddrc::RegisterBlock;
327 #[inline(always)]
328 fn deref(&self) -> &Self::Target {
329 unsafe { &*Self::PTR }
330 }
331}
332impl core::fmt::Debug for Ddrc {
333 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
334 f.debug_struct("Ddrc").finish()
335 }
336}
337#[doc = "DDR Controller (DDRC) Registers"]
338pub mod ddrc;
339#[doc = "DDR Controller 0 (DDRC0) Registers"]
340pub struct Ddrc0 {
341 _marker: PhantomData<*const ()>,
342}
343unsafe impl Send for Ddrc0 {}
344impl Ddrc0 {
345 #[doc = r"Pointer to the register block"]
346 pub const PTR: *const ddrc::RegisterBlock = 0xffa8_0000 as *const _;
347 #[doc = r"Return the pointer to the register block"]
348 #[inline(always)]
349 pub const fn ptr() -> *const ddrc::RegisterBlock {
350 Self::PTR
351 }
352 #[doc = r" Steal an instance of this peripheral"]
353 #[doc = r""]
354 #[doc = r" # Safety"]
355 #[doc = r""]
356 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
357 #[doc = r" that may race with any existing instances, for example by only"]
358 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
359 #[doc = r" original peripheral and using critical sections to coordinate"]
360 #[doc = r" access between multiple new instances."]
361 #[doc = r""]
362 #[doc = r" Additionally, other software such as HALs may rely on only one"]
363 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
364 #[doc = r" no stolen instances are passed to such software."]
365 pub unsafe fn steal() -> Self {
366 Self {
367 _marker: PhantomData,
368 }
369 }
370}
371impl Deref for Ddrc0 {
372 type Target = ddrc::RegisterBlock;
373 #[inline(always)]
374 fn deref(&self) -> &Self::Target {
375 unsafe { &*Self::PTR }
376 }
377}
378impl core::fmt::Debug for Ddrc0 {
379 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
380 f.debug_struct("Ddrc0").finish()
381 }
382}
383#[doc = "DDR Controller 0 (DDRC0) Registers"]
384pub use self::ddrc as ddrc0;
385#[doc = "DDR Controller 1 (DDRC1) Registers"]
386pub struct Ddrc1 {
387 _marker: PhantomData<*const ()>,
388}
389unsafe impl Send for Ddrc1 {}
390impl Ddrc1 {
391 #[doc = r"Pointer to the register block"]
392 pub const PTR: *const ddrc::RegisterBlock = 0xffa8_8000 as *const _;
393 #[doc = r"Return the pointer to the register block"]
394 #[inline(always)]
395 pub const fn ptr() -> *const ddrc::RegisterBlock {
396 Self::PTR
397 }
398 #[doc = r" Steal an instance of this peripheral"]
399 #[doc = r""]
400 #[doc = r" # Safety"]
401 #[doc = r""]
402 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
403 #[doc = r" that may race with any existing instances, for example by only"]
404 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
405 #[doc = r" original peripheral and using critical sections to coordinate"]
406 #[doc = r" access between multiple new instances."]
407 #[doc = r""]
408 #[doc = r" Additionally, other software such as HALs may rely on only one"]
409 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
410 #[doc = r" no stolen instances are passed to such software."]
411 pub unsafe fn steal() -> Self {
412 Self {
413 _marker: PhantomData,
414 }
415 }
416}
417impl Deref for Ddrc1 {
418 type Target = ddrc::RegisterBlock;
419 #[inline(always)]
420 fn deref(&self) -> &Self::Target {
421 unsafe { &*Self::PTR }
422 }
423}
424impl core::fmt::Debug for Ddrc1 {
425 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
426 f.debug_struct("Ddrc1").finish()
427 }
428}
429#[doc = "DDR Controller 1 (DDRC1) Registers"]
430pub use self::ddrc as ddrc1;
431#[doc = "DDR Controller Interface Control Registers (DDR_CIC) Registers"]
432pub struct DdrCic {
433 _marker: PhantomData<*const ()>,
434}
435unsafe impl Send for DdrCic {}
436impl DdrCic {
437 #[doc = r"Pointer to the register block"]
438 pub const PTR: *const ddr_cic::RegisterBlock = 0xff62_0000 as *const _;
439 #[doc = r"Return the pointer to the register block"]
440 #[inline(always)]
441 pub const fn ptr() -> *const ddr_cic::RegisterBlock {
442 Self::PTR
443 }
444 #[doc = r" Steal an instance of this peripheral"]
445 #[doc = r""]
446 #[doc = r" # Safety"]
447 #[doc = r""]
448 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
449 #[doc = r" that may race with any existing instances, for example by only"]
450 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
451 #[doc = r" original peripheral and using critical sections to coordinate"]
452 #[doc = r" access between multiple new instances."]
453 #[doc = r""]
454 #[doc = r" Additionally, other software such as HALs may rely on only one"]
455 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
456 #[doc = r" no stolen instances are passed to such software."]
457 pub unsafe fn steal() -> Self {
458 Self {
459 _marker: PhantomData,
460 }
461 }
462}
463impl Deref for DdrCic {
464 type Target = ddr_cic::RegisterBlock;
465 #[inline(always)]
466 fn deref(&self) -> &Self::Target {
467 unsafe { &*Self::PTR }
468 }
469}
470impl core::fmt::Debug for DdrCic {
471 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
472 f.debug_struct("DdrCic").finish()
473 }
474}
475#[doc = "DDR Controller Interface Control Registers (DDR_CIC) Registers"]
476pub mod ddr_cic;
477#[doc = "DDR Monitor (DDR_MON) Registers"]
478pub struct DdrMon {
479 _marker: PhantomData<*const ()>,
480}
481unsafe impl Send for DdrMon {}
482impl DdrMon {
483 #[doc = r"Pointer to the register block"]
484 pub const PTR: *const ddr_mon::RegisterBlock = 0xff63_0000 as *const _;
485 #[doc = r"Return the pointer to the register block"]
486 #[inline(always)]
487 pub const fn ptr() -> *const ddr_mon::RegisterBlock {
488 Self::PTR
489 }
490 #[doc = r" Steal an instance of this peripheral"]
491 #[doc = r""]
492 #[doc = r" # Safety"]
493 #[doc = r""]
494 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
495 #[doc = r" that may race with any existing instances, for example by only"]
496 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
497 #[doc = r" original peripheral and using critical sections to coordinate"]
498 #[doc = r" access between multiple new instances."]
499 #[doc = r""]
500 #[doc = r" Additionally, other software such as HALs may rely on only one"]
501 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
502 #[doc = r" no stolen instances are passed to such software."]
503 pub unsafe fn steal() -> Self {
504 Self {
505 _marker: PhantomData,
506 }
507 }
508}
509impl Deref for DdrMon {
510 type Target = ddr_mon::RegisterBlock;
511 #[inline(always)]
512 fn deref(&self) -> &Self::Target {
513 unsafe { &*Self::PTR }
514 }
515}
516impl core::fmt::Debug for DdrMon {
517 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
518 f.debug_struct("DdrMon").finish()
519 }
520}
521#[doc = "DDR Monitor (DDR_MON) Registers"]
522pub mod ddr_mon;
523#[doc = "DMA Controller (DMAC) Registers"]
524pub struct Dmac {
525 _marker: PhantomData<*const ()>,
526}
527unsafe impl Send for Dmac {}
528impl Dmac {
529 #[doc = r"Pointer to the register block"]
530 pub const PTR: *const dmac::RegisterBlock = 0xff6d_0000 as *const _;
531 #[doc = r"Return the pointer to the register block"]
532 #[inline(always)]
533 pub const fn ptr() -> *const dmac::RegisterBlock {
534 Self::PTR
535 }
536 #[doc = r" Steal an instance of this peripheral"]
537 #[doc = r""]
538 #[doc = r" # Safety"]
539 #[doc = r""]
540 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
541 #[doc = r" that may race with any existing instances, for example by only"]
542 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
543 #[doc = r" original peripheral and using critical sections to coordinate"]
544 #[doc = r" access between multiple new instances."]
545 #[doc = r""]
546 #[doc = r" Additionally, other software such as HALs may rely on only one"]
547 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
548 #[doc = r" no stolen instances are passed to such software."]
549 pub unsafe fn steal() -> Self {
550 Self {
551 _marker: PhantomData,
552 }
553 }
554}
555impl Deref for Dmac {
556 type Target = dmac::RegisterBlock;
557 #[inline(always)]
558 fn deref(&self) -> &Self::Target {
559 unsafe { &*Self::PTR }
560 }
561}
562impl core::fmt::Debug for Dmac {
563 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
564 f.debug_struct("Dmac").finish()
565 }
566}
567#[doc = "DMA Controller (DMAC) Registers"]
568pub mod dmac;
569#[doc = "DMA Controller 0 Registers"]
570pub struct Dmac0 {
571 _marker: PhantomData<*const ()>,
572}
573unsafe impl Send for Dmac0 {}
574impl Dmac0 {
575 #[doc = r"Pointer to the register block"]
576 pub const PTR: *const dmac::RegisterBlock = 0xff6d_0000 as *const _;
577 #[doc = r"Return the pointer to the register block"]
578 #[inline(always)]
579 pub const fn ptr() -> *const dmac::RegisterBlock {
580 Self::PTR
581 }
582 #[doc = r" Steal an instance of this peripheral"]
583 #[doc = r""]
584 #[doc = r" # Safety"]
585 #[doc = r""]
586 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
587 #[doc = r" that may race with any existing instances, for example by only"]
588 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
589 #[doc = r" original peripheral and using critical sections to coordinate"]
590 #[doc = r" access between multiple new instances."]
591 #[doc = r""]
592 #[doc = r" Additionally, other software such as HALs may rely on only one"]
593 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
594 #[doc = r" no stolen instances are passed to such software."]
595 pub unsafe fn steal() -> Self {
596 Self {
597 _marker: PhantomData,
598 }
599 }
600}
601impl Deref for Dmac0 {
602 type Target = dmac::RegisterBlock;
603 #[inline(always)]
604 fn deref(&self) -> &Self::Target {
605 unsafe { &*Self::PTR }
606 }
607}
608impl core::fmt::Debug for Dmac0 {
609 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
610 f.debug_struct("Dmac0").finish()
611 }
612}
613#[doc = "DMA Controller 0 Registers"]
614pub use self::dmac as dmac0;
615#[doc = "DMA Controller 1 Registers"]
616pub struct Dmac1 {
617 _marker: PhantomData<*const ()>,
618}
619unsafe impl Send for Dmac1 {}
620impl Dmac1 {
621 #[doc = r"Pointer to the register block"]
622 pub const PTR: *const dmac::RegisterBlock = 0xff6e_0000 as *const _;
623 #[doc = r"Return the pointer to the register block"]
624 #[inline(always)]
625 pub const fn ptr() -> *const dmac::RegisterBlock {
626 Self::PTR
627 }
628 #[doc = r" Steal an instance of this peripheral"]
629 #[doc = r""]
630 #[doc = r" # Safety"]
631 #[doc = r""]
632 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
633 #[doc = r" that may race with any existing instances, for example by only"]
634 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
635 #[doc = r" original peripheral and using critical sections to coordinate"]
636 #[doc = r" access between multiple new instances."]
637 #[doc = r""]
638 #[doc = r" Additionally, other software such as HALs may rely on only one"]
639 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
640 #[doc = r" no stolen instances are passed to such software."]
641 pub unsafe fn steal() -> Self {
642 Self {
643 _marker: PhantomData,
644 }
645 }
646}
647impl Deref for Dmac1 {
648 type Target = dmac::RegisterBlock;
649 #[inline(always)]
650 fn deref(&self) -> &Self::Target {
651 unsafe { &*Self::PTR }
652 }
653}
654impl core::fmt::Debug for Dmac1 {
655 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
656 f.debug_struct("Dmac1").finish()
657 }
658}
659#[doc = "DMA Controller 1 Registers"]
660pub use self::dmac as dmac1;
661#[doc = "DisplayPort Registers"]
662pub struct Dp {
663 _marker: PhantomData<*const ()>,
664}
665unsafe impl Send for Dp {}
666impl Dp {
667 #[doc = r"Pointer to the register block"]
668 pub const PTR: *const dp::RegisterBlock = 0xfec0_0000 as *const _;
669 #[doc = r"Return the pointer to the register block"]
670 #[inline(always)]
671 pub const fn ptr() -> *const dp::RegisterBlock {
672 Self::PTR
673 }
674 #[doc = r" Steal an instance of this peripheral"]
675 #[doc = r""]
676 #[doc = r" # Safety"]
677 #[doc = r""]
678 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
679 #[doc = r" that may race with any existing instances, for example by only"]
680 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
681 #[doc = r" original peripheral and using critical sections to coordinate"]
682 #[doc = r" access between multiple new instances."]
683 #[doc = r""]
684 #[doc = r" Additionally, other software such as HALs may rely on only one"]
685 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
686 #[doc = r" no stolen instances are passed to such software."]
687 pub unsafe fn steal() -> Self {
688 Self {
689 _marker: PhantomData,
690 }
691 }
692}
693impl Deref for Dp {
694 type Target = dp::RegisterBlock;
695 #[inline(always)]
696 fn deref(&self) -> &Self::Target {
697 unsafe { &*Self::PTR }
698 }
699}
700impl core::fmt::Debug for Dp {
701 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
702 f.debug_struct("Dp").finish()
703 }
704}
705#[doc = "DisplayPort Registers"]
706pub mod dp;
707#[doc = "eFuse Registers"]
708pub struct Efuse {
709 _marker: PhantomData<*const ()>,
710}
711unsafe impl Send for Efuse {}
712impl Efuse {
713 #[doc = r"Pointer to the register block"]
714 pub const PTR: *const efuse::RegisterBlock = 0xff69_0000 as *const _;
715 #[doc = r"Return the pointer to the register block"]
716 #[inline(always)]
717 pub const fn ptr() -> *const efuse::RegisterBlock {
718 Self::PTR
719 }
720 #[doc = r" Steal an instance of this peripheral"]
721 #[doc = r""]
722 #[doc = r" # Safety"]
723 #[doc = r""]
724 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
725 #[doc = r" that may race with any existing instances, for example by only"]
726 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
727 #[doc = r" original peripheral and using critical sections to coordinate"]
728 #[doc = r" access between multiple new instances."]
729 #[doc = r""]
730 #[doc = r" Additionally, other software such as HALs may rely on only one"]
731 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
732 #[doc = r" no stolen instances are passed to such software."]
733 pub unsafe fn steal() -> Self {
734 Self {
735 _marker: PhantomData,
736 }
737 }
738}
739impl Deref for Efuse {
740 type Target = efuse::RegisterBlock;
741 #[inline(always)]
742 fn deref(&self) -> &Self::Target {
743 unsafe { &*Self::PTR }
744 }
745}
746impl core::fmt::Debug for Efuse {
747 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
748 f.debug_struct("Efuse").finish()
749 }
750}
751#[doc = "eFuse Registers"]
752pub mod efuse;
753#[doc = "eFuse 0 Registers"]
754pub struct Efuse0 {
755 _marker: PhantomData<*const ()>,
756}
757unsafe impl Send for Efuse0 {}
758impl Efuse0 {
759 #[doc = r"Pointer to the register block"]
760 pub const PTR: *const efuse::RegisterBlock = 0xff69_0000 as *const _;
761 #[doc = r"Return the pointer to the register block"]
762 #[inline(always)]
763 pub const fn ptr() -> *const efuse::RegisterBlock {
764 Self::PTR
765 }
766 #[doc = r" Steal an instance of this peripheral"]
767 #[doc = r""]
768 #[doc = r" # Safety"]
769 #[doc = r""]
770 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
771 #[doc = r" that may race with any existing instances, for example by only"]
772 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
773 #[doc = r" original peripheral and using critical sections to coordinate"]
774 #[doc = r" access between multiple new instances."]
775 #[doc = r""]
776 #[doc = r" Additionally, other software such as HALs may rely on only one"]
777 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
778 #[doc = r" no stolen instances are passed to such software."]
779 pub unsafe fn steal() -> Self {
780 Self {
781 _marker: PhantomData,
782 }
783 }
784}
785impl Deref for Efuse0 {
786 type Target = efuse::RegisterBlock;
787 #[inline(always)]
788 fn deref(&self) -> &Self::Target {
789 unsafe { &*Self::PTR }
790 }
791}
792impl core::fmt::Debug for Efuse0 {
793 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
794 f.debug_struct("Efuse0").finish()
795 }
796}
797#[doc = "eFuse 0 Registers"]
798pub use self::efuse as efuse0;
799#[doc = "eFuse 1 Registers"]
800pub struct Efuse1 {
801 _marker: PhantomData<*const ()>,
802}
803unsafe impl Send for Efuse1 {}
804impl Efuse1 {
805 #[doc = r"Pointer to the register block"]
806 pub const PTR: *const efuse::RegisterBlock = 0xfffa_0000 as *const _;
807 #[doc = r"Return the pointer to the register block"]
808 #[inline(always)]
809 pub const fn ptr() -> *const efuse::RegisterBlock {
810 Self::PTR
811 }
812 #[doc = r" Steal an instance of this peripheral"]
813 #[doc = r""]
814 #[doc = r" # Safety"]
815 #[doc = r""]
816 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
817 #[doc = r" that may race with any existing instances, for example by only"]
818 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
819 #[doc = r" original peripheral and using critical sections to coordinate"]
820 #[doc = r" access between multiple new instances."]
821 #[doc = r""]
822 #[doc = r" Additionally, other software such as HALs may rely on only one"]
823 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
824 #[doc = r" no stolen instances are passed to such software."]
825 pub unsafe fn steal() -> Self {
826 Self {
827 _marker: PhantomData,
828 }
829 }
830}
831impl Deref for Efuse1 {
832 type Target = efuse::RegisterBlock;
833 #[inline(always)]
834 fn deref(&self) -> &Self::Target {
835 unsafe { &*Self::PTR }
836 }
837}
838impl core::fmt::Debug for Efuse1 {
839 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
840 f.debug_struct("Efuse1").finish()
841 }
842}
843#[doc = "eFuse 1 Registers"]
844pub use self::efuse as efuse1;
845#[doc = "eMMC Controller (EMMCCORE) Registers"]
846pub struct Emmccore {
847 _marker: PhantomData<*const ()>,
848}
849unsafe impl Send for Emmccore {}
850impl Emmccore {
851 #[doc = r"Pointer to the register block"]
852 pub const PTR: *const emmccore::RegisterBlock = 0xfe33_0000 as *const _;
853 #[doc = r"Return the pointer to the register block"]
854 #[inline(always)]
855 pub const fn ptr() -> *const emmccore::RegisterBlock {
856 Self::PTR
857 }
858 #[doc = r" Steal an instance of this peripheral"]
859 #[doc = r""]
860 #[doc = r" # Safety"]
861 #[doc = r""]
862 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
863 #[doc = r" that may race with any existing instances, for example by only"]
864 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
865 #[doc = r" original peripheral and using critical sections to coordinate"]
866 #[doc = r" access between multiple new instances."]
867 #[doc = r""]
868 #[doc = r" Additionally, other software such as HALs may rely on only one"]
869 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
870 #[doc = r" no stolen instances are passed to such software."]
871 pub unsafe fn steal() -> Self {
872 Self {
873 _marker: PhantomData,
874 }
875 }
876}
877impl Deref for Emmccore {
878 type Target = emmccore::RegisterBlock;
879 #[inline(always)]
880 fn deref(&self) -> &Self::Target {
881 unsafe { &*Self::PTR }
882 }
883}
884impl core::fmt::Debug for Emmccore {
885 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
886 f.debug_struct("Emmccore").finish()
887 }
888}
889#[doc = "eMMC Controller (EMMCCORE) Registers"]
890pub mod emmccore;
891#[doc = "Error Logger (ERR_LOGGER) Registers for the paths from all masters to the memory schedule"]
892pub struct ErrLoggerMsch {
893 _marker: PhantomData<*const ()>,
894}
895unsafe impl Send for ErrLoggerMsch {}
896impl ErrLoggerMsch {
897 #[doc = r"Pointer to the register block"]
898 pub const PTR: *const err_logger_msch::RegisterBlock = 0xffa8_7c80 as *const _;
899 #[doc = r"Return the pointer to the register block"]
900 #[inline(always)]
901 pub const fn ptr() -> *const err_logger_msch::RegisterBlock {
902 Self::PTR
903 }
904 #[doc = r" Steal an instance of this peripheral"]
905 #[doc = r""]
906 #[doc = r" # Safety"]
907 #[doc = r""]
908 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
909 #[doc = r" that may race with any existing instances, for example by only"]
910 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
911 #[doc = r" original peripheral and using critical sections to coordinate"]
912 #[doc = r" access between multiple new instances."]
913 #[doc = r""]
914 #[doc = r" Additionally, other software such as HALs may rely on only one"]
915 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
916 #[doc = r" no stolen instances are passed to such software."]
917 pub unsafe fn steal() -> Self {
918 Self {
919 _marker: PhantomData,
920 }
921 }
922}
923impl Deref for ErrLoggerMsch {
924 type Target = err_logger_msch::RegisterBlock;
925 #[inline(always)]
926 fn deref(&self) -> &Self::Target {
927 unsafe { &*Self::PTR }
928 }
929}
930impl core::fmt::Debug for ErrLoggerMsch {
931 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
932 f.debug_struct("ErrLoggerMsch").finish()
933 }
934}
935#[doc = "Error Logger (ERR_LOGGER) Registers for the paths from all masters to the memory schedule"]
936pub mod err_logger_msch;
937#[doc = "Error Logger (ERR_LOGGER) Registers for the paths from all masters to the memory schedule 0"]
938pub struct ErrLoggerMsch0 {
939 _marker: PhantomData<*const ()>,
940}
941unsafe impl Send for ErrLoggerMsch0 {}
942impl ErrLoggerMsch0 {
943 #[doc = r"Pointer to the register block"]
944 pub const PTR: *const err_logger_msch::RegisterBlock = 0xffa8_7c80 as *const _;
945 #[doc = r"Return the pointer to the register block"]
946 #[inline(always)]
947 pub const fn ptr() -> *const err_logger_msch::RegisterBlock {
948 Self::PTR
949 }
950 #[doc = r" Steal an instance of this peripheral"]
951 #[doc = r""]
952 #[doc = r" # Safety"]
953 #[doc = r""]
954 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
955 #[doc = r" that may race with any existing instances, for example by only"]
956 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
957 #[doc = r" original peripheral and using critical sections to coordinate"]
958 #[doc = r" access between multiple new instances."]
959 #[doc = r""]
960 #[doc = r" Additionally, other software such as HALs may rely on only one"]
961 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
962 #[doc = r" no stolen instances are passed to such software."]
963 pub unsafe fn steal() -> Self {
964 Self {
965 _marker: PhantomData,
966 }
967 }
968}
969impl Deref for ErrLoggerMsch0 {
970 type Target = err_logger_msch::RegisterBlock;
971 #[inline(always)]
972 fn deref(&self) -> &Self::Target {
973 unsafe { &*Self::PTR }
974 }
975}
976impl core::fmt::Debug for ErrLoggerMsch0 {
977 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
978 f.debug_struct("ErrLoggerMsch0").finish()
979 }
980}
981#[doc = "Error Logger (ERR_LOGGER) Registers for the paths from all masters to the memory schedule 0"]
982pub use self::err_logger_msch as err_logger_msch0;
983#[doc = "Error Logger (ERR_LOGGER) Registers for the paths from all masters to the memory schedule 1"]
984pub struct ErrLoggerMsch1 {
985 _marker: PhantomData<*const ()>,
986}
987unsafe impl Send for ErrLoggerMsch1 {}
988impl ErrLoggerMsch1 {
989 #[doc = r"Pointer to the register block"]
990 pub const PTR: *const err_logger_msch::RegisterBlock = 0xffa8_fc80 as *const _;
991 #[doc = r"Return the pointer to the register block"]
992 #[inline(always)]
993 pub const fn ptr() -> *const err_logger_msch::RegisterBlock {
994 Self::PTR
995 }
996 #[doc = r" Steal an instance of this peripheral"]
997 #[doc = r""]
998 #[doc = r" # Safety"]
999 #[doc = r""]
1000 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1001 #[doc = r" that may race with any existing instances, for example by only"]
1002 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1003 #[doc = r" original peripheral and using critical sections to coordinate"]
1004 #[doc = r" access between multiple new instances."]
1005 #[doc = r""]
1006 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1007 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1008 #[doc = r" no stolen instances are passed to such software."]
1009 pub unsafe fn steal() -> Self {
1010 Self {
1011 _marker: PhantomData,
1012 }
1013 }
1014}
1015impl Deref for ErrLoggerMsch1 {
1016 type Target = err_logger_msch::RegisterBlock;
1017 #[inline(always)]
1018 fn deref(&self) -> &Self::Target {
1019 unsafe { &*Self::PTR }
1020 }
1021}
1022impl core::fmt::Debug for ErrLoggerMsch1 {
1023 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1024 f.debug_struct("ErrLoggerMsch1").finish()
1025 }
1026}
1027#[doc = "Error Logger (ERR_LOGGER) Registers for the paths from all masters to the memory schedule 1"]
1028pub use self::err_logger_msch as err_logger_msch1;
1029#[doc = "Error Logger (ERR_LOGGER) Registers for the paths from all masters except the PMU of the Cortex-M0 to all slaves outside the PMU power domain"]
1030pub struct ErrLoggerSlv {
1031 _marker: PhantomData<*const ()>,
1032}
1033unsafe impl Send for ErrLoggerSlv {}
1034impl ErrLoggerSlv {
1035 #[doc = r"Pointer to the register block"]
1036 pub const PTR: *const err_logger_slv::RegisterBlock = 0xffa6_4000 as *const _;
1037 #[doc = r"Return the pointer to the register block"]
1038 #[inline(always)]
1039 pub const fn ptr() -> *const err_logger_slv::RegisterBlock {
1040 Self::PTR
1041 }
1042 #[doc = r" Steal an instance of this peripheral"]
1043 #[doc = r""]
1044 #[doc = r" # Safety"]
1045 #[doc = r""]
1046 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1047 #[doc = r" that may race with any existing instances, for example by only"]
1048 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1049 #[doc = r" original peripheral and using critical sections to coordinate"]
1050 #[doc = r" access between multiple new instances."]
1051 #[doc = r""]
1052 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1053 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1054 #[doc = r" no stolen instances are passed to such software."]
1055 pub unsafe fn steal() -> Self {
1056 Self {
1057 _marker: PhantomData,
1058 }
1059 }
1060}
1061impl Deref for ErrLoggerSlv {
1062 type Target = err_logger_slv::RegisterBlock;
1063 #[inline(always)]
1064 fn deref(&self) -> &Self::Target {
1065 unsafe { &*Self::PTR }
1066 }
1067}
1068impl core::fmt::Debug for ErrLoggerSlv {
1069 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1070 f.debug_struct("ErrLoggerSlv").finish()
1071 }
1072}
1073#[doc = "Error Logger (ERR_LOGGER) Registers for the paths from all masters except the PMU of the Cortex-M0 to all slaves outside the PMU power domain"]
1074pub mod err_logger_slv;
1075#[doc = "Error Logger (ERR_LOGGER) Registers for the paths from all masters except the PMU of the Cortex-M0 to all slaves outside the PMU power domain"]
1076pub struct ErrLoggerSlv0 {
1077 _marker: PhantomData<*const ()>,
1078}
1079unsafe impl Send for ErrLoggerSlv0 {}
1080impl ErrLoggerSlv0 {
1081 #[doc = r"Pointer to the register block"]
1082 pub const PTR: *const err_logger_slv::RegisterBlock = 0xffa6_4000 as *const _;
1083 #[doc = r"Return the pointer to the register block"]
1084 #[inline(always)]
1085 pub const fn ptr() -> *const err_logger_slv::RegisterBlock {
1086 Self::PTR
1087 }
1088 #[doc = r" Steal an instance of this peripheral"]
1089 #[doc = r""]
1090 #[doc = r" # Safety"]
1091 #[doc = r""]
1092 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1093 #[doc = r" that may race with any existing instances, for example by only"]
1094 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1095 #[doc = r" original peripheral and using critical sections to coordinate"]
1096 #[doc = r" access between multiple new instances."]
1097 #[doc = r""]
1098 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1099 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1100 #[doc = r" no stolen instances are passed to such software."]
1101 pub unsafe fn steal() -> Self {
1102 Self {
1103 _marker: PhantomData,
1104 }
1105 }
1106}
1107impl Deref for ErrLoggerSlv0 {
1108 type Target = err_logger_slv::RegisterBlock;
1109 #[inline(always)]
1110 fn deref(&self) -> &Self::Target {
1111 unsafe { &*Self::PTR }
1112 }
1113}
1114impl core::fmt::Debug for ErrLoggerSlv0 {
1115 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1116 f.debug_struct("ErrLoggerSlv0").finish()
1117 }
1118}
1119#[doc = "Error Logger (ERR_LOGGER) Registers for the paths from all masters except the PMU of the Cortex-M0 to all slaves outside the PMU power domain"]
1120pub use self::err_logger_slv as err_logger_slv0;
1121#[doc = "Error Logger (ERR_LOGGER) Registers for the paths from the PMU of the Cortex-M0 to all slaves inside the PMU power domain"]
1122pub struct ErrLoggerSlv1 {
1123 _marker: PhantomData<*const ()>,
1124}
1125unsafe impl Send for ErrLoggerSlv1 {}
1126impl ErrLoggerSlv1 {
1127 #[doc = r"Pointer to the register block"]
1128 pub const PTR: *const err_logger_slv::RegisterBlock = 0xffa6_8080 as *const _;
1129 #[doc = r"Return the pointer to the register block"]
1130 #[inline(always)]
1131 pub const fn ptr() -> *const err_logger_slv::RegisterBlock {
1132 Self::PTR
1133 }
1134 #[doc = r" Steal an instance of this peripheral"]
1135 #[doc = r""]
1136 #[doc = r" # Safety"]
1137 #[doc = r""]
1138 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1139 #[doc = r" that may race with any existing instances, for example by only"]
1140 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1141 #[doc = r" original peripheral and using critical sections to coordinate"]
1142 #[doc = r" access between multiple new instances."]
1143 #[doc = r""]
1144 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1145 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1146 #[doc = r" no stolen instances are passed to such software."]
1147 pub unsafe fn steal() -> Self {
1148 Self {
1149 _marker: PhantomData,
1150 }
1151 }
1152}
1153impl Deref for ErrLoggerSlv1 {
1154 type Target = err_logger_slv::RegisterBlock;
1155 #[inline(always)]
1156 fn deref(&self) -> &Self::Target {
1157 unsafe { &*Self::PTR }
1158 }
1159}
1160impl core::fmt::Debug for ErrLoggerSlv1 {
1161 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1162 f.debug_struct("ErrLoggerSlv1").finish()
1163 }
1164}
1165#[doc = "Error Logger (ERR_LOGGER) Registers for the paths from the PMU of the Cortex-M0 to all slaves inside the PMU power domain"]
1166pub use self::err_logger_slv as err_logger_slv1;
1167#[doc = "Gigabit Media Access Controller (GMAC) Registers"]
1168pub struct Gmac {
1169 _marker: PhantomData<*const ()>,
1170}
1171unsafe impl Send for Gmac {}
1172impl Gmac {
1173 #[doc = r"Pointer to the register block"]
1174 pub const PTR: *const gmac::RegisterBlock = 0xfe30_0000 as *const _;
1175 #[doc = r"Return the pointer to the register block"]
1176 #[inline(always)]
1177 pub const fn ptr() -> *const gmac::RegisterBlock {
1178 Self::PTR
1179 }
1180 #[doc = r" Steal an instance of this peripheral"]
1181 #[doc = r""]
1182 #[doc = r" # Safety"]
1183 #[doc = r""]
1184 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1185 #[doc = r" that may race with any existing instances, for example by only"]
1186 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1187 #[doc = r" original peripheral and using critical sections to coordinate"]
1188 #[doc = r" access between multiple new instances."]
1189 #[doc = r""]
1190 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1191 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1192 #[doc = r" no stolen instances are passed to such software."]
1193 pub unsafe fn steal() -> Self {
1194 Self {
1195 _marker: PhantomData,
1196 }
1197 }
1198}
1199impl Deref for Gmac {
1200 type Target = gmac::RegisterBlock;
1201 #[inline(always)]
1202 fn deref(&self) -> &Self::Target {
1203 unsafe { &*Self::PTR }
1204 }
1205}
1206impl core::fmt::Debug for Gmac {
1207 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1208 f.debug_struct("Gmac").finish()
1209 }
1210}
1211#[doc = "Gigabit Media Access Controller (GMAC) Registers"]
1212pub mod gmac;
1213#[doc = "General Purpose Input/Output (GPIO) Registers"]
1214pub struct Gpio {
1215 _marker: PhantomData<*const ()>,
1216}
1217unsafe impl Send for Gpio {}
1218impl Gpio {
1219 #[doc = r"Pointer to the register block"]
1220 pub const PTR: *const gpio::RegisterBlock = 0xff72_0000 as *const _;
1221 #[doc = r"Return the pointer to the register block"]
1222 #[inline(always)]
1223 pub const fn ptr() -> *const gpio::RegisterBlock {
1224 Self::PTR
1225 }
1226 #[doc = r" Steal an instance of this peripheral"]
1227 #[doc = r""]
1228 #[doc = r" # Safety"]
1229 #[doc = r""]
1230 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1231 #[doc = r" that may race with any existing instances, for example by only"]
1232 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1233 #[doc = r" original peripheral and using critical sections to coordinate"]
1234 #[doc = r" access between multiple new instances."]
1235 #[doc = r""]
1236 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1237 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1238 #[doc = r" no stolen instances are passed to such software."]
1239 pub unsafe fn steal() -> Self {
1240 Self {
1241 _marker: PhantomData,
1242 }
1243 }
1244}
1245impl Deref for Gpio {
1246 type Target = gpio::RegisterBlock;
1247 #[inline(always)]
1248 fn deref(&self) -> &Self::Target {
1249 unsafe { &*Self::PTR }
1250 }
1251}
1252impl core::fmt::Debug for Gpio {
1253 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1254 f.debug_struct("Gpio").finish()
1255 }
1256}
1257#[doc = "General Purpose Input/Output (GPIO) Registers"]
1258pub mod gpio;
1259#[doc = "General Purpose Input/Output (GPIO) 0 Registers"]
1260pub struct Gpio0 {
1261 _marker: PhantomData<*const ()>,
1262}
1263unsafe impl Send for Gpio0 {}
1264impl Gpio0 {
1265 #[doc = r"Pointer to the register block"]
1266 pub const PTR: *const gpio::RegisterBlock = 0xff72_0000 as *const _;
1267 #[doc = r"Return the pointer to the register block"]
1268 #[inline(always)]
1269 pub const fn ptr() -> *const gpio::RegisterBlock {
1270 Self::PTR
1271 }
1272 #[doc = r" Steal an instance of this peripheral"]
1273 #[doc = r""]
1274 #[doc = r" # Safety"]
1275 #[doc = r""]
1276 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1277 #[doc = r" that may race with any existing instances, for example by only"]
1278 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1279 #[doc = r" original peripheral and using critical sections to coordinate"]
1280 #[doc = r" access between multiple new instances."]
1281 #[doc = r""]
1282 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1283 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1284 #[doc = r" no stolen instances are passed to such software."]
1285 pub unsafe fn steal() -> Self {
1286 Self {
1287 _marker: PhantomData,
1288 }
1289 }
1290}
1291impl Deref for Gpio0 {
1292 type Target = gpio::RegisterBlock;
1293 #[inline(always)]
1294 fn deref(&self) -> &Self::Target {
1295 unsafe { &*Self::PTR }
1296 }
1297}
1298impl core::fmt::Debug for Gpio0 {
1299 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1300 f.debug_struct("Gpio0").finish()
1301 }
1302}
1303#[doc = "General Purpose Input/Output (GPIO) 0 Registers"]
1304pub use self::gpio as gpio0;
1305#[doc = "General Purpose Input/Output (GPIO) 1 Registers"]
1306pub struct Gpio1 {
1307 _marker: PhantomData<*const ()>,
1308}
1309unsafe impl Send for Gpio1 {}
1310impl Gpio1 {
1311 #[doc = r"Pointer to the register block"]
1312 pub const PTR: *const gpio::RegisterBlock = 0xff73_0000 as *const _;
1313 #[doc = r"Return the pointer to the register block"]
1314 #[inline(always)]
1315 pub const fn ptr() -> *const gpio::RegisterBlock {
1316 Self::PTR
1317 }
1318 #[doc = r" Steal an instance of this peripheral"]
1319 #[doc = r""]
1320 #[doc = r" # Safety"]
1321 #[doc = r""]
1322 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1323 #[doc = r" that may race with any existing instances, for example by only"]
1324 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1325 #[doc = r" original peripheral and using critical sections to coordinate"]
1326 #[doc = r" access between multiple new instances."]
1327 #[doc = r""]
1328 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1329 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1330 #[doc = r" no stolen instances are passed to such software."]
1331 pub unsafe fn steal() -> Self {
1332 Self {
1333 _marker: PhantomData,
1334 }
1335 }
1336}
1337impl Deref for Gpio1 {
1338 type Target = gpio::RegisterBlock;
1339 #[inline(always)]
1340 fn deref(&self) -> &Self::Target {
1341 unsafe { &*Self::PTR }
1342 }
1343}
1344impl core::fmt::Debug for Gpio1 {
1345 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1346 f.debug_struct("Gpio1").finish()
1347 }
1348}
1349#[doc = "General Purpose Input/Output (GPIO) 1 Registers"]
1350pub use self::gpio as gpio1;
1351#[doc = "General Purpose Input/Output (GPIO) 2 Registers"]
1352pub struct Gpio2 {
1353 _marker: PhantomData<*const ()>,
1354}
1355unsafe impl Send for Gpio2 {}
1356impl Gpio2 {
1357 #[doc = r"Pointer to the register block"]
1358 pub const PTR: *const gpio::RegisterBlock = 0xff78_0000 as *const _;
1359 #[doc = r"Return the pointer to the register block"]
1360 #[inline(always)]
1361 pub const fn ptr() -> *const gpio::RegisterBlock {
1362 Self::PTR
1363 }
1364 #[doc = r" Steal an instance of this peripheral"]
1365 #[doc = r""]
1366 #[doc = r" # Safety"]
1367 #[doc = r""]
1368 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1369 #[doc = r" that may race with any existing instances, for example by only"]
1370 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1371 #[doc = r" original peripheral and using critical sections to coordinate"]
1372 #[doc = r" access between multiple new instances."]
1373 #[doc = r""]
1374 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1375 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1376 #[doc = r" no stolen instances are passed to such software."]
1377 pub unsafe fn steal() -> Self {
1378 Self {
1379 _marker: PhantomData,
1380 }
1381 }
1382}
1383impl Deref for Gpio2 {
1384 type Target = gpio::RegisterBlock;
1385 #[inline(always)]
1386 fn deref(&self) -> &Self::Target {
1387 unsafe { &*Self::PTR }
1388 }
1389}
1390impl core::fmt::Debug for Gpio2 {
1391 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1392 f.debug_struct("Gpio2").finish()
1393 }
1394}
1395#[doc = "General Purpose Input/Output (GPIO) 2 Registers"]
1396pub use self::gpio as gpio2;
1397#[doc = "General Purpose Input/Output (GPIO) 3 Registers"]
1398pub struct Gpio3 {
1399 _marker: PhantomData<*const ()>,
1400}
1401unsafe impl Send for Gpio3 {}
1402impl Gpio3 {
1403 #[doc = r"Pointer to the register block"]
1404 pub const PTR: *const gpio::RegisterBlock = 0xff78_8000 as *const _;
1405 #[doc = r"Return the pointer to the register block"]
1406 #[inline(always)]
1407 pub const fn ptr() -> *const gpio::RegisterBlock {
1408 Self::PTR
1409 }
1410 #[doc = r" Steal an instance of this peripheral"]
1411 #[doc = r""]
1412 #[doc = r" # Safety"]
1413 #[doc = r""]
1414 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1415 #[doc = r" that may race with any existing instances, for example by only"]
1416 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1417 #[doc = r" original peripheral and using critical sections to coordinate"]
1418 #[doc = r" access between multiple new instances."]
1419 #[doc = r""]
1420 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1421 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1422 #[doc = r" no stolen instances are passed to such software."]
1423 pub unsafe fn steal() -> Self {
1424 Self {
1425 _marker: PhantomData,
1426 }
1427 }
1428}
1429impl Deref for Gpio3 {
1430 type Target = gpio::RegisterBlock;
1431 #[inline(always)]
1432 fn deref(&self) -> &Self::Target {
1433 unsafe { &*Self::PTR }
1434 }
1435}
1436impl core::fmt::Debug for Gpio3 {
1437 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1438 f.debug_struct("Gpio3").finish()
1439 }
1440}
1441#[doc = "General Purpose Input/Output (GPIO) 3 Registers"]
1442pub use self::gpio as gpio3;
1443#[doc = "General Purpose Input/Output (GPIO) 4 Registers"]
1444pub struct Gpio4 {
1445 _marker: PhantomData<*const ()>,
1446}
1447unsafe impl Send for Gpio4 {}
1448impl Gpio4 {
1449 #[doc = r"Pointer to the register block"]
1450 pub const PTR: *const gpio::RegisterBlock = 0xff79_0000 as *const _;
1451 #[doc = r"Return the pointer to the register block"]
1452 #[inline(always)]
1453 pub const fn ptr() -> *const gpio::RegisterBlock {
1454 Self::PTR
1455 }
1456 #[doc = r" Steal an instance of this peripheral"]
1457 #[doc = r""]
1458 #[doc = r" # Safety"]
1459 #[doc = r""]
1460 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1461 #[doc = r" that may race with any existing instances, for example by only"]
1462 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1463 #[doc = r" original peripheral and using critical sections to coordinate"]
1464 #[doc = r" access between multiple new instances."]
1465 #[doc = r""]
1466 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1467 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1468 #[doc = r" no stolen instances are passed to such software."]
1469 pub unsafe fn steal() -> Self {
1470 Self {
1471 _marker: PhantomData,
1472 }
1473 }
1474}
1475impl Deref for Gpio4 {
1476 type Target = gpio::RegisterBlock;
1477 #[inline(always)]
1478 fn deref(&self) -> &Self::Target {
1479 unsafe { &*Self::PTR }
1480 }
1481}
1482impl core::fmt::Debug for Gpio4 {
1483 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1484 f.debug_struct("Gpio4").finish()
1485 }
1486}
1487#[doc = "General Purpose Input/Output (GPIO) 4 Registers"]
1488pub use self::gpio as gpio4;
1489#[doc = "General Register File (GRF) Registers"]
1490pub struct Grf {
1491 _marker: PhantomData<*const ()>,
1492}
1493unsafe impl Send for Grf {}
1494impl Grf {
1495 #[doc = r"Pointer to the register block"]
1496 pub const PTR: *const grf::RegisterBlock = 0xff77_0000 as *const _;
1497 #[doc = r"Return the pointer to the register block"]
1498 #[inline(always)]
1499 pub const fn ptr() -> *const grf::RegisterBlock {
1500 Self::PTR
1501 }
1502 #[doc = r" Steal an instance of this peripheral"]
1503 #[doc = r""]
1504 #[doc = r" # Safety"]
1505 #[doc = r""]
1506 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1507 #[doc = r" that may race with any existing instances, for example by only"]
1508 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1509 #[doc = r" original peripheral and using critical sections to coordinate"]
1510 #[doc = r" access between multiple new instances."]
1511 #[doc = r""]
1512 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1513 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1514 #[doc = r" no stolen instances are passed to such software."]
1515 pub unsafe fn steal() -> Self {
1516 Self {
1517 _marker: PhantomData,
1518 }
1519 }
1520}
1521impl Deref for Grf {
1522 type Target = grf::RegisterBlock;
1523 #[inline(always)]
1524 fn deref(&self) -> &Self::Target {
1525 unsafe { &*Self::PTR }
1526 }
1527}
1528impl core::fmt::Debug for Grf {
1529 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1530 f.debug_struct("Grf").finish()
1531 }
1532}
1533#[doc = "General Register File (GRF) Registers"]
1534pub mod grf;
1535#[doc = "HDMI Registers"]
1536pub struct Hdmi {
1537 _marker: PhantomData<*const ()>,
1538}
1539unsafe impl Send for Hdmi {}
1540impl Hdmi {
1541 #[doc = r"Pointer to the register block"]
1542 pub const PTR: *const hdmi::RegisterBlock = 0xff94_0000 as *const _;
1543 #[doc = r"Return the pointer to the register block"]
1544 #[inline(always)]
1545 pub const fn ptr() -> *const hdmi::RegisterBlock {
1546 Self::PTR
1547 }
1548 #[doc = r" Steal an instance of this peripheral"]
1549 #[doc = r""]
1550 #[doc = r" # Safety"]
1551 #[doc = r""]
1552 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1553 #[doc = r" that may race with any existing instances, for example by only"]
1554 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1555 #[doc = r" original peripheral and using critical sections to coordinate"]
1556 #[doc = r" access between multiple new instances."]
1557 #[doc = r""]
1558 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1559 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1560 #[doc = r" no stolen instances are passed to such software."]
1561 pub unsafe fn steal() -> Self {
1562 Self {
1563 _marker: PhantomData,
1564 }
1565 }
1566}
1567impl Deref for Hdmi {
1568 type Target = hdmi::RegisterBlock;
1569 #[inline(always)]
1570 fn deref(&self) -> &Self::Target {
1571 unsafe { &*Self::PTR }
1572 }
1573}
1574impl core::fmt::Debug for Hdmi {
1575 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1576 f.debug_struct("Hdmi").finish()
1577 }
1578}
1579#[doc = "HDMI Registers"]
1580pub mod hdmi;
1581#[doc = "Inter-IC Sound (I2S) Registers"]
1582pub struct I2s {
1583 _marker: PhantomData<*const ()>,
1584}
1585unsafe impl Send for I2s {}
1586impl I2s {
1587 #[doc = r"Pointer to the register block"]
1588 pub const PTR: *const i2s::RegisterBlock = 0xff88_0000 as *const _;
1589 #[doc = r"Return the pointer to the register block"]
1590 #[inline(always)]
1591 pub const fn ptr() -> *const i2s::RegisterBlock {
1592 Self::PTR
1593 }
1594 #[doc = r" Steal an instance of this peripheral"]
1595 #[doc = r""]
1596 #[doc = r" # Safety"]
1597 #[doc = r""]
1598 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1599 #[doc = r" that may race with any existing instances, for example by only"]
1600 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1601 #[doc = r" original peripheral and using critical sections to coordinate"]
1602 #[doc = r" access between multiple new instances."]
1603 #[doc = r""]
1604 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1605 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1606 #[doc = r" no stolen instances are passed to such software."]
1607 pub unsafe fn steal() -> Self {
1608 Self {
1609 _marker: PhantomData,
1610 }
1611 }
1612}
1613impl Deref for I2s {
1614 type Target = i2s::RegisterBlock;
1615 #[inline(always)]
1616 fn deref(&self) -> &Self::Target {
1617 unsafe { &*Self::PTR }
1618 }
1619}
1620impl core::fmt::Debug for I2s {
1621 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1622 f.debug_struct("I2s").finish()
1623 }
1624}
1625#[doc = "Inter-IC Sound (I2S) Registers"]
1626pub mod i2s;
1627#[doc = "Inter-IC Sound (I2S) 0 Registers"]
1628pub struct I2s0 {
1629 _marker: PhantomData<*const ()>,
1630}
1631unsafe impl Send for I2s0 {}
1632impl I2s0 {
1633 #[doc = r"Pointer to the register block"]
1634 pub const PTR: *const i2s::RegisterBlock = 0xff88_0000 as *const _;
1635 #[doc = r"Return the pointer to the register block"]
1636 #[inline(always)]
1637 pub const fn ptr() -> *const i2s::RegisterBlock {
1638 Self::PTR
1639 }
1640 #[doc = r" Steal an instance of this peripheral"]
1641 #[doc = r""]
1642 #[doc = r" # Safety"]
1643 #[doc = r""]
1644 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1645 #[doc = r" that may race with any existing instances, for example by only"]
1646 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1647 #[doc = r" original peripheral and using critical sections to coordinate"]
1648 #[doc = r" access between multiple new instances."]
1649 #[doc = r""]
1650 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1651 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1652 #[doc = r" no stolen instances are passed to such software."]
1653 pub unsafe fn steal() -> Self {
1654 Self {
1655 _marker: PhantomData,
1656 }
1657 }
1658}
1659impl Deref for I2s0 {
1660 type Target = i2s::RegisterBlock;
1661 #[inline(always)]
1662 fn deref(&self) -> &Self::Target {
1663 unsafe { &*Self::PTR }
1664 }
1665}
1666impl core::fmt::Debug for I2s0 {
1667 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1668 f.debug_struct("I2s0").finish()
1669 }
1670}
1671#[doc = "Inter-IC Sound (I2S) 0 Registers"]
1672pub use self::i2s as i2s0;
1673#[doc = "Inter-IC Sound (I2S) 1 Registers"]
1674pub struct I2s1 {
1675 _marker: PhantomData<*const ()>,
1676}
1677unsafe impl Send for I2s1 {}
1678impl I2s1 {
1679 #[doc = r"Pointer to the register block"]
1680 pub const PTR: *const i2s::RegisterBlock = 0xff89_0000 as *const _;
1681 #[doc = r"Return the pointer to the register block"]
1682 #[inline(always)]
1683 pub const fn ptr() -> *const i2s::RegisterBlock {
1684 Self::PTR
1685 }
1686 #[doc = r" Steal an instance of this peripheral"]
1687 #[doc = r""]
1688 #[doc = r" # Safety"]
1689 #[doc = r""]
1690 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1691 #[doc = r" that may race with any existing instances, for example by only"]
1692 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1693 #[doc = r" original peripheral and using critical sections to coordinate"]
1694 #[doc = r" access between multiple new instances."]
1695 #[doc = r""]
1696 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1697 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1698 #[doc = r" no stolen instances are passed to such software."]
1699 pub unsafe fn steal() -> Self {
1700 Self {
1701 _marker: PhantomData,
1702 }
1703 }
1704}
1705impl Deref for I2s1 {
1706 type Target = i2s::RegisterBlock;
1707 #[inline(always)]
1708 fn deref(&self) -> &Self::Target {
1709 unsafe { &*Self::PTR }
1710 }
1711}
1712impl core::fmt::Debug for I2s1 {
1713 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1714 f.debug_struct("I2s1").finish()
1715 }
1716}
1717#[doc = "Inter-IC Sound (I2S) 1 Registers"]
1718pub use self::i2s as i2s1;
1719#[doc = "Inter-IC Sound (I2S) 2 Registers"]
1720pub struct I2s2 {
1721 _marker: PhantomData<*const ()>,
1722}
1723unsafe impl Send for I2s2 {}
1724impl I2s2 {
1725 #[doc = r"Pointer to the register block"]
1726 pub const PTR: *const i2s::RegisterBlock = 0xff8a_0000 as *const _;
1727 #[doc = r"Return the pointer to the register block"]
1728 #[inline(always)]
1729 pub const fn ptr() -> *const i2s::RegisterBlock {
1730 Self::PTR
1731 }
1732 #[doc = r" Steal an instance of this peripheral"]
1733 #[doc = r""]
1734 #[doc = r" # Safety"]
1735 #[doc = r""]
1736 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1737 #[doc = r" that may race with any existing instances, for example by only"]
1738 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1739 #[doc = r" original peripheral and using critical sections to coordinate"]
1740 #[doc = r" access between multiple new instances."]
1741 #[doc = r""]
1742 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1743 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1744 #[doc = r" no stolen instances are passed to such software."]
1745 pub unsafe fn steal() -> Self {
1746 Self {
1747 _marker: PhantomData,
1748 }
1749 }
1750}
1751impl Deref for I2s2 {
1752 type Target = i2s::RegisterBlock;
1753 #[inline(always)]
1754 fn deref(&self) -> &Self::Target {
1755 unsafe { &*Self::PTR }
1756 }
1757}
1758impl core::fmt::Debug for I2s2 {
1759 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1760 f.debug_struct("I2s2").finish()
1761 }
1762}
1763#[doc = "Inter-IC Sound (I2S) 2 Registers"]
1764pub use self::i2s as i2s2;
1765#[doc = "Image Enhancement Processor (IEP) Registers"]
1766pub struct Iep {
1767 _marker: PhantomData<*const ()>,
1768}
1769unsafe impl Send for Iep {}
1770impl Iep {
1771 #[doc = r"Pointer to the register block"]
1772 pub const PTR: *const iep::RegisterBlock = 0xff67_0000 as *const _;
1773 #[doc = r"Return the pointer to the register block"]
1774 #[inline(always)]
1775 pub const fn ptr() -> *const iep::RegisterBlock {
1776 Self::PTR
1777 }
1778 #[doc = r" Steal an instance of this peripheral"]
1779 #[doc = r""]
1780 #[doc = r" # Safety"]
1781 #[doc = r""]
1782 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1783 #[doc = r" that may race with any existing instances, for example by only"]
1784 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1785 #[doc = r" original peripheral and using critical sections to coordinate"]
1786 #[doc = r" access between multiple new instances."]
1787 #[doc = r""]
1788 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1789 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1790 #[doc = r" no stolen instances are passed to such software."]
1791 pub unsafe fn steal() -> Self {
1792 Self {
1793 _marker: PhantomData,
1794 }
1795 }
1796}
1797impl Deref for Iep {
1798 type Target = iep::RegisterBlock;
1799 #[inline(always)]
1800 fn deref(&self) -> &Self::Target {
1801 unsafe { &*Self::PTR }
1802 }
1803}
1804impl core::fmt::Debug for Iep {
1805 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1806 f.debug_struct("Iep").finish()
1807 }
1808}
1809#[doc = "Image Enhancement Processor (IEP) Registers"]
1810pub mod iep;
1811#[doc = "Image Signal Processor (ISP) Registers"]
1812pub struct Isp {
1813 _marker: PhantomData<*const ()>,
1814}
1815unsafe impl Send for Isp {}
1816impl Isp {
1817 #[doc = r"Pointer to the register block"]
1818 pub const PTR: *const isp::RegisterBlock = 0xff91_0000 as *const _;
1819 #[doc = r"Return the pointer to the register block"]
1820 #[inline(always)]
1821 pub const fn ptr() -> *const isp::RegisterBlock {
1822 Self::PTR
1823 }
1824 #[doc = r" Steal an instance of this peripheral"]
1825 #[doc = r""]
1826 #[doc = r" # Safety"]
1827 #[doc = r""]
1828 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1829 #[doc = r" that may race with any existing instances, for example by only"]
1830 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1831 #[doc = r" original peripheral and using critical sections to coordinate"]
1832 #[doc = r" access between multiple new instances."]
1833 #[doc = r""]
1834 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1835 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1836 #[doc = r" no stolen instances are passed to such software."]
1837 pub unsafe fn steal() -> Self {
1838 Self {
1839 _marker: PhantomData,
1840 }
1841 }
1842}
1843impl Deref for Isp {
1844 type Target = isp::RegisterBlock;
1845 #[inline(always)]
1846 fn deref(&self) -> &Self::Target {
1847 unsafe { &*Self::PTR }
1848 }
1849}
1850impl core::fmt::Debug for Isp {
1851 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1852 f.debug_struct("Isp").finish()
1853 }
1854}
1855#[doc = "Image Signal Processor (ISP) Registers"]
1856pub mod isp;
1857#[doc = "Image Signal Processor 0 (ISP0) Registers"]
1858pub struct Isp0 {
1859 _marker: PhantomData<*const ()>,
1860}
1861unsafe impl Send for Isp0 {}
1862impl Isp0 {
1863 #[doc = r"Pointer to the register block"]
1864 pub const PTR: *const isp::RegisterBlock = 0xff91_0000 as *const _;
1865 #[doc = r"Return the pointer to the register block"]
1866 #[inline(always)]
1867 pub const fn ptr() -> *const isp::RegisterBlock {
1868 Self::PTR
1869 }
1870 #[doc = r" Steal an instance of this peripheral"]
1871 #[doc = r""]
1872 #[doc = r" # Safety"]
1873 #[doc = r""]
1874 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1875 #[doc = r" that may race with any existing instances, for example by only"]
1876 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1877 #[doc = r" original peripheral and using critical sections to coordinate"]
1878 #[doc = r" access between multiple new instances."]
1879 #[doc = r""]
1880 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1881 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1882 #[doc = r" no stolen instances are passed to such software."]
1883 pub unsafe fn steal() -> Self {
1884 Self {
1885 _marker: PhantomData,
1886 }
1887 }
1888}
1889impl Deref for Isp0 {
1890 type Target = isp::RegisterBlock;
1891 #[inline(always)]
1892 fn deref(&self) -> &Self::Target {
1893 unsafe { &*Self::PTR }
1894 }
1895}
1896impl core::fmt::Debug for Isp0 {
1897 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1898 f.debug_struct("Isp0").finish()
1899 }
1900}
1901#[doc = "Image Signal Processor 0 (ISP0) Registers"]
1902pub use self::isp as isp0;
1903#[doc = "Image Signal Processor 1 (ISP1) Registers"]
1904pub struct Isp1 {
1905 _marker: PhantomData<*const ()>,
1906}
1907unsafe impl Send for Isp1 {}
1908impl Isp1 {
1909 #[doc = r"Pointer to the register block"]
1910 pub const PTR: *const isp::RegisterBlock = 0xff92_0000 as *const _;
1911 #[doc = r"Return the pointer to the register block"]
1912 #[inline(always)]
1913 pub const fn ptr() -> *const isp::RegisterBlock {
1914 Self::PTR
1915 }
1916 #[doc = r" Steal an instance of this peripheral"]
1917 #[doc = r""]
1918 #[doc = r" # Safety"]
1919 #[doc = r""]
1920 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1921 #[doc = r" that may race with any existing instances, for example by only"]
1922 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1923 #[doc = r" original peripheral and using critical sections to coordinate"]
1924 #[doc = r" access between multiple new instances."]
1925 #[doc = r""]
1926 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1927 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1928 #[doc = r" no stolen instances are passed to such software."]
1929 pub unsafe fn steal() -> Self {
1930 Self {
1931 _marker: PhantomData,
1932 }
1933 }
1934}
1935impl Deref for Isp1 {
1936 type Target = isp::RegisterBlock;
1937 #[inline(always)]
1938 fn deref(&self) -> &Self::Target {
1939 unsafe { &*Self::PTR }
1940 }
1941}
1942impl core::fmt::Debug for Isp1 {
1943 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1944 f.debug_struct("Isp1").finish()
1945 }
1946}
1947#[doc = "Image Signal Processor 1 (ISP1) Registers"]
1948pub use self::isp as isp1;
1949#[doc = "Mailbox Registers"]
1950pub struct Mailbox {
1951 _marker: PhantomData<*const ()>,
1952}
1953unsafe impl Send for Mailbox {}
1954impl Mailbox {
1955 #[doc = r"Pointer to the register block"]
1956 pub const PTR: *const mailbox::RegisterBlock = 0xff6b_0000 as *const _;
1957 #[doc = r"Return the pointer to the register block"]
1958 #[inline(always)]
1959 pub const fn ptr() -> *const mailbox::RegisterBlock {
1960 Self::PTR
1961 }
1962 #[doc = r" Steal an instance of this peripheral"]
1963 #[doc = r""]
1964 #[doc = r" # Safety"]
1965 #[doc = r""]
1966 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1967 #[doc = r" that may race with any existing instances, for example by only"]
1968 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1969 #[doc = r" original peripheral and using critical sections to coordinate"]
1970 #[doc = r" access between multiple new instances."]
1971 #[doc = r""]
1972 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1973 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1974 #[doc = r" no stolen instances are passed to such software."]
1975 pub unsafe fn steal() -> Self {
1976 Self {
1977 _marker: PhantomData,
1978 }
1979 }
1980}
1981impl Deref for Mailbox {
1982 type Target = mailbox::RegisterBlock;
1983 #[inline(always)]
1984 fn deref(&self) -> &Self::Target {
1985 unsafe { &*Self::PTR }
1986 }
1987}
1988impl core::fmt::Debug for Mailbox {
1989 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1990 f.debug_struct("Mailbox").finish()
1991 }
1992}
1993#[doc = "Mailbox Registers"]
1994pub mod mailbox;
1995#[doc = "Mailbox 0 Registers"]
1996pub struct Mailbox0 {
1997 _marker: PhantomData<*const ()>,
1998}
1999unsafe impl Send for Mailbox0 {}
2000impl Mailbox0 {
2001 #[doc = r"Pointer to the register block"]
2002 pub const PTR: *const mailbox::RegisterBlock = 0xff6b_0000 as *const _;
2003 #[doc = r"Return the pointer to the register block"]
2004 #[inline(always)]
2005 pub const fn ptr() -> *const mailbox::RegisterBlock {
2006 Self::PTR
2007 }
2008 #[doc = r" Steal an instance of this peripheral"]
2009 #[doc = r""]
2010 #[doc = r" # Safety"]
2011 #[doc = r""]
2012 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2013 #[doc = r" that may race with any existing instances, for example by only"]
2014 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2015 #[doc = r" original peripheral and using critical sections to coordinate"]
2016 #[doc = r" access between multiple new instances."]
2017 #[doc = r""]
2018 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2019 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2020 #[doc = r" no stolen instances are passed to such software."]
2021 pub unsafe fn steal() -> Self {
2022 Self {
2023 _marker: PhantomData,
2024 }
2025 }
2026}
2027impl Deref for Mailbox0 {
2028 type Target = mailbox::RegisterBlock;
2029 #[inline(always)]
2030 fn deref(&self) -> &Self::Target {
2031 unsafe { &*Self::PTR }
2032 }
2033}
2034impl core::fmt::Debug for Mailbox0 {
2035 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2036 f.debug_struct("Mailbox0").finish()
2037 }
2038}
2039#[doc = "Mailbox 0 Registers"]
2040pub use self::mailbox as mailbox0;
2041#[doc = "Mailbox 1 Registers"]
2042pub struct Mailbox1 {
2043 _marker: PhantomData<*const ()>,
2044}
2045unsafe impl Send for Mailbox1 {}
2046impl Mailbox1 {
2047 #[doc = r"Pointer to the register block"]
2048 pub const PTR: *const mailbox::RegisterBlock = 0xff39_0000 as *const _;
2049 #[doc = r"Return the pointer to the register block"]
2050 #[inline(always)]
2051 pub const fn ptr() -> *const mailbox::RegisterBlock {
2052 Self::PTR
2053 }
2054 #[doc = r" Steal an instance of this peripheral"]
2055 #[doc = r""]
2056 #[doc = r" # Safety"]
2057 #[doc = r""]
2058 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2059 #[doc = r" that may race with any existing instances, for example by only"]
2060 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2061 #[doc = r" original peripheral and using critical sections to coordinate"]
2062 #[doc = r" access between multiple new instances."]
2063 #[doc = r""]
2064 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2065 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2066 #[doc = r" no stolen instances are passed to such software."]
2067 pub unsafe fn steal() -> Self {
2068 Self {
2069 _marker: PhantomData,
2070 }
2071 }
2072}
2073impl Deref for Mailbox1 {
2074 type Target = mailbox::RegisterBlock;
2075 #[inline(always)]
2076 fn deref(&self) -> &Self::Target {
2077 unsafe { &*Self::PTR }
2078 }
2079}
2080impl core::fmt::Debug for Mailbox1 {
2081 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2082 f.debug_struct("Mailbox1").finish()
2083 }
2084}
2085#[doc = "Mailbox 1 Registers"]
2086pub use self::mailbox as mailbox1;
2087#[doc = "MIPI Display Serial Interface (DSI) Host Registers"]
2088pub struct MipiDsiHost {
2089 _marker: PhantomData<*const ()>,
2090}
2091unsafe impl Send for MipiDsiHost {}
2092impl MipiDsiHost {
2093 #[doc = r"Pointer to the register block"]
2094 pub const PTR: *const mipi_dsi_host::RegisterBlock = 0xff96_0000 as *const _;
2095 #[doc = r"Return the pointer to the register block"]
2096 #[inline(always)]
2097 pub const fn ptr() -> *const mipi_dsi_host::RegisterBlock {
2098 Self::PTR
2099 }
2100 #[doc = r" Steal an instance of this peripheral"]
2101 #[doc = r""]
2102 #[doc = r" # Safety"]
2103 #[doc = r""]
2104 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2105 #[doc = r" that may race with any existing instances, for example by only"]
2106 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2107 #[doc = r" original peripheral and using critical sections to coordinate"]
2108 #[doc = r" access between multiple new instances."]
2109 #[doc = r""]
2110 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2111 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2112 #[doc = r" no stolen instances are passed to such software."]
2113 pub unsafe fn steal() -> Self {
2114 Self {
2115 _marker: PhantomData,
2116 }
2117 }
2118}
2119impl Deref for MipiDsiHost {
2120 type Target = mipi_dsi_host::RegisterBlock;
2121 #[inline(always)]
2122 fn deref(&self) -> &Self::Target {
2123 unsafe { &*Self::PTR }
2124 }
2125}
2126impl core::fmt::Debug for MipiDsiHost {
2127 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2128 f.debug_struct("MipiDsiHost").finish()
2129 }
2130}
2131#[doc = "MIPI Display Serial Interface (DSI) Host Registers"]
2132pub mod mipi_dsi_host;
2133#[doc = "MIPI Display Serial Interface (DSI) Host 0 Registers"]
2134pub struct MipiDsiHost0 {
2135 _marker: PhantomData<*const ()>,
2136}
2137unsafe impl Send for MipiDsiHost0 {}
2138impl MipiDsiHost0 {
2139 #[doc = r"Pointer to the register block"]
2140 pub const PTR: *const mipi_dsi_host::RegisterBlock = 0xff96_0000 as *const _;
2141 #[doc = r"Return the pointer to the register block"]
2142 #[inline(always)]
2143 pub const fn ptr() -> *const mipi_dsi_host::RegisterBlock {
2144 Self::PTR
2145 }
2146 #[doc = r" Steal an instance of this peripheral"]
2147 #[doc = r""]
2148 #[doc = r" # Safety"]
2149 #[doc = r""]
2150 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2151 #[doc = r" that may race with any existing instances, for example by only"]
2152 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2153 #[doc = r" original peripheral and using critical sections to coordinate"]
2154 #[doc = r" access between multiple new instances."]
2155 #[doc = r""]
2156 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2157 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2158 #[doc = r" no stolen instances are passed to such software."]
2159 pub unsafe fn steal() -> Self {
2160 Self {
2161 _marker: PhantomData,
2162 }
2163 }
2164}
2165impl Deref for MipiDsiHost0 {
2166 type Target = mipi_dsi_host::RegisterBlock;
2167 #[inline(always)]
2168 fn deref(&self) -> &Self::Target {
2169 unsafe { &*Self::PTR }
2170 }
2171}
2172impl core::fmt::Debug for MipiDsiHost0 {
2173 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2174 f.debug_struct("MipiDsiHost0").finish()
2175 }
2176}
2177#[doc = "MIPI Display Serial Interface (DSI) Host 0 Registers"]
2178pub use self::mipi_dsi_host as mipi_dsi_host0;
2179#[doc = "MIPI Display Serial Interface (DSI) Host 1 Registers"]
2180pub struct MipiDsiHost1 {
2181 _marker: PhantomData<*const ()>,
2182}
2183unsafe impl Send for MipiDsiHost1 {}
2184impl MipiDsiHost1 {
2185 #[doc = r"Pointer to the register block"]
2186 pub const PTR: *const mipi_dsi_host::RegisterBlock = 0xff96_8000 as *const _;
2187 #[doc = r"Return the pointer to the register block"]
2188 #[inline(always)]
2189 pub const fn ptr() -> *const mipi_dsi_host::RegisterBlock {
2190 Self::PTR
2191 }
2192 #[doc = r" Steal an instance of this peripheral"]
2193 #[doc = r""]
2194 #[doc = r" # Safety"]
2195 #[doc = r""]
2196 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2197 #[doc = r" that may race with any existing instances, for example by only"]
2198 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2199 #[doc = r" original peripheral and using critical sections to coordinate"]
2200 #[doc = r" access between multiple new instances."]
2201 #[doc = r""]
2202 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2203 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2204 #[doc = r" no stolen instances are passed to such software."]
2205 pub unsafe fn steal() -> Self {
2206 Self {
2207 _marker: PhantomData,
2208 }
2209 }
2210}
2211impl Deref for MipiDsiHost1 {
2212 type Target = mipi_dsi_host::RegisterBlock;
2213 #[inline(always)]
2214 fn deref(&self) -> &Self::Target {
2215 unsafe { &*Self::PTR }
2216 }
2217}
2218impl core::fmt::Debug for MipiDsiHost1 {
2219 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2220 f.debug_struct("MipiDsiHost1").finish()
2221 }
2222}
2223#[doc = "MIPI Display Serial Interface (DSI) Host 1 Registers"]
2224pub use self::mipi_dsi_host as mipi_dsi_host1;
2225#[doc = "Memory Management Unit (MMU) Registers"]
2226pub struct Mmu {
2227 _marker: PhantomData<*const ()>,
2228}
2229unsafe impl Send for Mmu {}
2230impl Mmu {
2231 #[doc = r"Pointer to the register block"]
2232 pub const PTR: *const mmu::RegisterBlock = 0xff91_4000 as *const _;
2233 #[doc = r"Return the pointer to the register block"]
2234 #[inline(always)]
2235 pub const fn ptr() -> *const mmu::RegisterBlock {
2236 Self::PTR
2237 }
2238 #[doc = r" Steal an instance of this peripheral"]
2239 #[doc = r""]
2240 #[doc = r" # Safety"]
2241 #[doc = r""]
2242 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2243 #[doc = r" that may race with any existing instances, for example by only"]
2244 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2245 #[doc = r" original peripheral and using critical sections to coordinate"]
2246 #[doc = r" access between multiple new instances."]
2247 #[doc = r""]
2248 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2249 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2250 #[doc = r" no stolen instances are passed to such software."]
2251 pub unsafe fn steal() -> Self {
2252 Self {
2253 _marker: PhantomData,
2254 }
2255 }
2256}
2257impl Deref for Mmu {
2258 type Target = mmu::RegisterBlock;
2259 #[inline(always)]
2260 fn deref(&self) -> &Self::Target {
2261 unsafe { &*Self::PTR }
2262 }
2263}
2264impl core::fmt::Debug for Mmu {
2265 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2266 f.debug_struct("Mmu").finish()
2267 }
2268}
2269#[doc = "Memory Management Unit (MMU) Registers"]
2270pub mod mmu;
2271#[doc = "Registers of Memory Management Unit 0 (MMU0) for Image Signal Processor 0 (ISP0)"]
2272pub struct Mmu0Isp0 {
2273 _marker: PhantomData<*const ()>,
2274}
2275unsafe impl Send for Mmu0Isp0 {}
2276impl Mmu0Isp0 {
2277 #[doc = r"Pointer to the register block"]
2278 pub const PTR: *const mmu::RegisterBlock = 0xff91_4000 as *const _;
2279 #[doc = r"Return the pointer to the register block"]
2280 #[inline(always)]
2281 pub const fn ptr() -> *const mmu::RegisterBlock {
2282 Self::PTR
2283 }
2284 #[doc = r" Steal an instance of this peripheral"]
2285 #[doc = r""]
2286 #[doc = r" # Safety"]
2287 #[doc = r""]
2288 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2289 #[doc = r" that may race with any existing instances, for example by only"]
2290 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2291 #[doc = r" original peripheral and using critical sections to coordinate"]
2292 #[doc = r" access between multiple new instances."]
2293 #[doc = r""]
2294 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2295 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2296 #[doc = r" no stolen instances are passed to such software."]
2297 pub unsafe fn steal() -> Self {
2298 Self {
2299 _marker: PhantomData,
2300 }
2301 }
2302}
2303impl Deref for Mmu0Isp0 {
2304 type Target = mmu::RegisterBlock;
2305 #[inline(always)]
2306 fn deref(&self) -> &Self::Target {
2307 unsafe { &*Self::PTR }
2308 }
2309}
2310impl core::fmt::Debug for Mmu0Isp0 {
2311 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2312 f.debug_struct("Mmu0Isp0").finish()
2313 }
2314}
2315#[doc = "Registers of Memory Management Unit 0 (MMU0) for Image Signal Processor 0 (ISP0)"]
2316pub use self::mmu as mmu0_isp0;
2317#[doc = "Registers of Memory Management Unit 0 (MMU0) for Image Signal Processor 1 (ISP1)"]
2318pub struct Mmu0Isp1 {
2319 _marker: PhantomData<*const ()>,
2320}
2321unsafe impl Send for Mmu0Isp1 {}
2322impl Mmu0Isp1 {
2323 #[doc = r"Pointer to the register block"]
2324 pub const PTR: *const mmu::RegisterBlock = 0xff92_4000 as *const _;
2325 #[doc = r"Return the pointer to the register block"]
2326 #[inline(always)]
2327 pub const fn ptr() -> *const mmu::RegisterBlock {
2328 Self::PTR
2329 }
2330 #[doc = r" Steal an instance of this peripheral"]
2331 #[doc = r""]
2332 #[doc = r" # Safety"]
2333 #[doc = r""]
2334 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2335 #[doc = r" that may race with any existing instances, for example by only"]
2336 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2337 #[doc = r" original peripheral and using critical sections to coordinate"]
2338 #[doc = r" access between multiple new instances."]
2339 #[doc = r""]
2340 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2341 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2342 #[doc = r" no stolen instances are passed to such software."]
2343 pub unsafe fn steal() -> Self {
2344 Self {
2345 _marker: PhantomData,
2346 }
2347 }
2348}
2349impl Deref for Mmu0Isp1 {
2350 type Target = mmu::RegisterBlock;
2351 #[inline(always)]
2352 fn deref(&self) -> &Self::Target {
2353 unsafe { &*Self::PTR }
2354 }
2355}
2356impl core::fmt::Debug for Mmu0Isp1 {
2357 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2358 f.debug_struct("Mmu0Isp1").finish()
2359 }
2360}
2361#[doc = "Registers of Memory Management Unit 0 (MMU0) for Image Signal Processor 1 (ISP1)"]
2362pub use self::mmu as mmu0_isp1;
2363#[doc = "Registers of Memory Management Unit 1 (MMU1) for Image Signal Processor 0 (ISP0)"]
2364pub struct Mmu1Isp0 {
2365 _marker: PhantomData<*const ()>,
2366}
2367unsafe impl Send for Mmu1Isp0 {}
2368impl Mmu1Isp0 {
2369 #[doc = r"Pointer to the register block"]
2370 pub const PTR: *const mmu::RegisterBlock = 0xff91_5000 as *const _;
2371 #[doc = r"Return the pointer to the register block"]
2372 #[inline(always)]
2373 pub const fn ptr() -> *const mmu::RegisterBlock {
2374 Self::PTR
2375 }
2376 #[doc = r" Steal an instance of this peripheral"]
2377 #[doc = r""]
2378 #[doc = r" # Safety"]
2379 #[doc = r""]
2380 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2381 #[doc = r" that may race with any existing instances, for example by only"]
2382 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2383 #[doc = r" original peripheral and using critical sections to coordinate"]
2384 #[doc = r" access between multiple new instances."]
2385 #[doc = r""]
2386 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2387 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2388 #[doc = r" no stolen instances are passed to such software."]
2389 pub unsafe fn steal() -> Self {
2390 Self {
2391 _marker: PhantomData,
2392 }
2393 }
2394}
2395impl Deref for Mmu1Isp0 {
2396 type Target = mmu::RegisterBlock;
2397 #[inline(always)]
2398 fn deref(&self) -> &Self::Target {
2399 unsafe { &*Self::PTR }
2400 }
2401}
2402impl core::fmt::Debug for Mmu1Isp0 {
2403 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2404 f.debug_struct("Mmu1Isp0").finish()
2405 }
2406}
2407#[doc = "Registers of Memory Management Unit 1 (MMU1) for Image Signal Processor 0 (ISP0)"]
2408pub use self::mmu as mmu1_isp0;
2409#[doc = "Registers of Memory Management Unit 1 (MMU1) for Image Signal Processor 1 (ISP1)"]
2410pub struct Mmu1Isp1 {
2411 _marker: PhantomData<*const ()>,
2412}
2413unsafe impl Send for Mmu1Isp1 {}
2414impl Mmu1Isp1 {
2415 #[doc = r"Pointer to the register block"]
2416 pub const PTR: *const mmu::RegisterBlock = 0xff92_5000 as *const _;
2417 #[doc = r"Return the pointer to the register block"]
2418 #[inline(always)]
2419 pub const fn ptr() -> *const mmu::RegisterBlock {
2420 Self::PTR
2421 }
2422 #[doc = r" Steal an instance of this peripheral"]
2423 #[doc = r""]
2424 #[doc = r" # Safety"]
2425 #[doc = r""]
2426 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2427 #[doc = r" that may race with any existing instances, for example by only"]
2428 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2429 #[doc = r" original peripheral and using critical sections to coordinate"]
2430 #[doc = r" access between multiple new instances."]
2431 #[doc = r""]
2432 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2433 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2434 #[doc = r" no stolen instances are passed to such software."]
2435 pub unsafe fn steal() -> Self {
2436 Self {
2437 _marker: PhantomData,
2438 }
2439 }
2440}
2441impl Deref for Mmu1Isp1 {
2442 type Target = mmu::RegisterBlock;
2443 #[inline(always)]
2444 fn deref(&self) -> &Self::Target {
2445 unsafe { &*Self::PTR }
2446 }
2447}
2448impl core::fmt::Debug for Mmu1Isp1 {
2449 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2450 f.debug_struct("Mmu1Isp1").finish()
2451 }
2452}
2453#[doc = "Registers of Memory Management Unit 1 (MMU1) for Image Signal Processor 1 (ISP1)"]
2454pub use self::mmu as mmu1_isp1;
2455#[doc = "Registers of Memory Management Unit (MMU) for High-bandwidth Digital Content Protection (HDCP)"]
2456pub struct MmuHdcp {
2457 _marker: PhantomData<*const ()>,
2458}
2459unsafe impl Send for MmuHdcp {}
2460impl MmuHdcp {
2461 #[doc = r"Pointer to the register block"]
2462 pub const PTR: *const mmu::RegisterBlock = 0xff93_0000 as *const _;
2463 #[doc = r"Return the pointer to the register block"]
2464 #[inline(always)]
2465 pub const fn ptr() -> *const mmu::RegisterBlock {
2466 Self::PTR
2467 }
2468 #[doc = r" Steal an instance of this peripheral"]
2469 #[doc = r""]
2470 #[doc = r" # Safety"]
2471 #[doc = r""]
2472 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2473 #[doc = r" that may race with any existing instances, for example by only"]
2474 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2475 #[doc = r" original peripheral and using critical sections to coordinate"]
2476 #[doc = r" access between multiple new instances."]
2477 #[doc = r""]
2478 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2479 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2480 #[doc = r" no stolen instances are passed to such software."]
2481 pub unsafe fn steal() -> Self {
2482 Self {
2483 _marker: PhantomData,
2484 }
2485 }
2486}
2487impl Deref for MmuHdcp {
2488 type Target = mmu::RegisterBlock;
2489 #[inline(always)]
2490 fn deref(&self) -> &Self::Target {
2491 unsafe { &*Self::PTR }
2492 }
2493}
2494impl core::fmt::Debug for MmuHdcp {
2495 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2496 f.debug_struct("MmuHdcp").finish()
2497 }
2498}
2499#[doc = "Registers of Memory Management Unit (MMU) for High-bandwidth Digital Content Protection (HDCP)"]
2500pub use self::mmu as mmu_hdcp;
2501#[doc = "Registers of Memory Management Unit (MMU) for Image Enhancement Processor (IEP)"]
2502pub struct MmuIep {
2503 _marker: PhantomData<*const ()>,
2504}
2505unsafe impl Send for MmuIep {}
2506impl MmuIep {
2507 #[doc = r"Pointer to the register block"]
2508 pub const PTR: *const mmu::RegisterBlock = 0xff67_0800 as *const _;
2509 #[doc = r"Return the pointer to the register block"]
2510 #[inline(always)]
2511 pub const fn ptr() -> *const mmu::RegisterBlock {
2512 Self::PTR
2513 }
2514 #[doc = r" Steal an instance of this peripheral"]
2515 #[doc = r""]
2516 #[doc = r" # Safety"]
2517 #[doc = r""]
2518 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2519 #[doc = r" that may race with any existing instances, for example by only"]
2520 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2521 #[doc = r" original peripheral and using critical sections to coordinate"]
2522 #[doc = r" access between multiple new instances."]
2523 #[doc = r""]
2524 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2525 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2526 #[doc = r" no stolen instances are passed to such software."]
2527 pub unsafe fn steal() -> Self {
2528 Self {
2529 _marker: PhantomData,
2530 }
2531 }
2532}
2533impl Deref for MmuIep {
2534 type Target = mmu::RegisterBlock;
2535 #[inline(always)]
2536 fn deref(&self) -> &Self::Target {
2537 unsafe { &*Self::PTR }
2538 }
2539}
2540impl core::fmt::Debug for MmuIep {
2541 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2542 f.debug_struct("MmuIep").finish()
2543 }
2544}
2545#[doc = "Registers of Memory Management Unit (MMU) for Image Enhancement Processor (IEP)"]
2546pub use self::mmu as mmu_iep;
2547#[doc = "Registers of Memory Management Unit (MMU) for Rockchip Video Decoder (RKVDEC) Read"]
2548pub struct MmuRkvdecR {
2549 _marker: PhantomData<*const ()>,
2550}
2551unsafe impl Send for MmuRkvdecR {}
2552impl MmuRkvdecR {
2553 #[doc = r"Pointer to the register block"]
2554 pub const PTR: *const mmu::RegisterBlock = 0xff66_0480 as *const _;
2555 #[doc = r"Return the pointer to the register block"]
2556 #[inline(always)]
2557 pub const fn ptr() -> *const mmu::RegisterBlock {
2558 Self::PTR
2559 }
2560 #[doc = r" Steal an instance of this peripheral"]
2561 #[doc = r""]
2562 #[doc = r" # Safety"]
2563 #[doc = r""]
2564 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2565 #[doc = r" that may race with any existing instances, for example by only"]
2566 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2567 #[doc = r" original peripheral and using critical sections to coordinate"]
2568 #[doc = r" access between multiple new instances."]
2569 #[doc = r""]
2570 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2571 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2572 #[doc = r" no stolen instances are passed to such software."]
2573 pub unsafe fn steal() -> Self {
2574 Self {
2575 _marker: PhantomData,
2576 }
2577 }
2578}
2579impl Deref for MmuRkvdecR {
2580 type Target = mmu::RegisterBlock;
2581 #[inline(always)]
2582 fn deref(&self) -> &Self::Target {
2583 unsafe { &*Self::PTR }
2584 }
2585}
2586impl core::fmt::Debug for MmuRkvdecR {
2587 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2588 f.debug_struct("MmuRkvdecR").finish()
2589 }
2590}
2591#[doc = "Registers of Memory Management Unit (MMU) for Rockchip Video Decoder (RKVDEC) Read"]
2592pub use self::mmu as mmu_rkvdec_r;
2593#[doc = "Registers of Memory Management Unit (MMU) for Rockchip Video Decoder (RKVDEC) Write"]
2594pub struct MmuRkvdecW {
2595 _marker: PhantomData<*const ()>,
2596}
2597unsafe impl Send for MmuRkvdecW {}
2598impl MmuRkvdecW {
2599 #[doc = r"Pointer to the register block"]
2600 pub const PTR: *const mmu::RegisterBlock = 0xff66_04c0 as *const _;
2601 #[doc = r"Return the pointer to the register block"]
2602 #[inline(always)]
2603 pub const fn ptr() -> *const mmu::RegisterBlock {
2604 Self::PTR
2605 }
2606 #[doc = r" Steal an instance of this peripheral"]
2607 #[doc = r""]
2608 #[doc = r" # Safety"]
2609 #[doc = r""]
2610 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2611 #[doc = r" that may race with any existing instances, for example by only"]
2612 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2613 #[doc = r" original peripheral and using critical sections to coordinate"]
2614 #[doc = r" access between multiple new instances."]
2615 #[doc = r""]
2616 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2617 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2618 #[doc = r" no stolen instances are passed to such software."]
2619 pub unsafe fn steal() -> Self {
2620 Self {
2621 _marker: PhantomData,
2622 }
2623 }
2624}
2625impl Deref for MmuRkvdecW {
2626 type Target = mmu::RegisterBlock;
2627 #[inline(always)]
2628 fn deref(&self) -> &Self::Target {
2629 unsafe { &*Self::PTR }
2630 }
2631}
2632impl core::fmt::Debug for MmuRkvdecW {
2633 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2634 f.debug_struct("MmuRkvdecW").finish()
2635 }
2636}
2637#[doc = "Registers of Memory Management Unit (MMU) for Rockchip Video Decoder (RKVDEC) Write"]
2638pub use self::mmu as mmu_rkvdec_w;
2639#[doc = "Registers of Memory Management Unit (MMU) for Visual Output Processor (Big) (VOPB)"]
2640pub struct MmuVopb {
2641 _marker: PhantomData<*const ()>,
2642}
2643unsafe impl Send for MmuVopb {}
2644impl MmuVopb {
2645 #[doc = r"Pointer to the register block"]
2646 pub const PTR: *const mmu::RegisterBlock = 0xff90_3f00 as *const _;
2647 #[doc = r"Return the pointer to the register block"]
2648 #[inline(always)]
2649 pub const fn ptr() -> *const mmu::RegisterBlock {
2650 Self::PTR
2651 }
2652 #[doc = r" Steal an instance of this peripheral"]
2653 #[doc = r""]
2654 #[doc = r" # Safety"]
2655 #[doc = r""]
2656 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2657 #[doc = r" that may race with any existing instances, for example by only"]
2658 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2659 #[doc = r" original peripheral and using critical sections to coordinate"]
2660 #[doc = r" access between multiple new instances."]
2661 #[doc = r""]
2662 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2663 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2664 #[doc = r" no stolen instances are passed to such software."]
2665 pub unsafe fn steal() -> Self {
2666 Self {
2667 _marker: PhantomData,
2668 }
2669 }
2670}
2671impl Deref for MmuVopb {
2672 type Target = mmu::RegisterBlock;
2673 #[inline(always)]
2674 fn deref(&self) -> &Self::Target {
2675 unsafe { &*Self::PTR }
2676 }
2677}
2678impl core::fmt::Debug for MmuVopb {
2679 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2680 f.debug_struct("MmuVopb").finish()
2681 }
2682}
2683#[doc = "Registers of Memory Management Unit (MMU) for Visual Output Processor (Big) (VOPB)"]
2684pub use self::mmu as mmu_vopb;
2685#[doc = "Registers of Memory Management Unit (MMU) for Visual Output Processor (Little) (VOPL)"]
2686pub struct MmuVopl {
2687 _marker: PhantomData<*const ()>,
2688}
2689unsafe impl Send for MmuVopl {}
2690impl MmuVopl {
2691 #[doc = r"Pointer to the register block"]
2692 pub const PTR: *const mmu::RegisterBlock = 0xff8f_3f00 as *const _;
2693 #[doc = r"Return the pointer to the register block"]
2694 #[inline(always)]
2695 pub const fn ptr() -> *const mmu::RegisterBlock {
2696 Self::PTR
2697 }
2698 #[doc = r" Steal an instance of this peripheral"]
2699 #[doc = r""]
2700 #[doc = r" # Safety"]
2701 #[doc = r""]
2702 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2703 #[doc = r" that may race with any existing instances, for example by only"]
2704 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2705 #[doc = r" original peripheral and using critical sections to coordinate"]
2706 #[doc = r" access between multiple new instances."]
2707 #[doc = r""]
2708 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2709 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2710 #[doc = r" no stolen instances are passed to such software."]
2711 pub unsafe fn steal() -> Self {
2712 Self {
2713 _marker: PhantomData,
2714 }
2715 }
2716}
2717impl Deref for MmuVopl {
2718 type Target = mmu::RegisterBlock;
2719 #[inline(always)]
2720 fn deref(&self) -> &Self::Target {
2721 unsafe { &*Self::PTR }
2722 }
2723}
2724impl core::fmt::Debug for MmuVopl {
2725 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2726 f.debug_struct("MmuVopl").finish()
2727 }
2728}
2729#[doc = "Registers of Memory Management Unit (MMU) for Visual Output Processor (Little) (VOPL)"]
2730pub use self::mmu as mmu_vopl;
2731#[doc = "Registers of Memory Management Unit (MMU) for Video Processing Unit (VPU)"]
2732pub struct MmuVpu {
2733 _marker: PhantomData<*const ()>,
2734}
2735unsafe impl Send for MmuVpu {}
2736impl MmuVpu {
2737 #[doc = r"Pointer to the register block"]
2738 pub const PTR: *const mmu::RegisterBlock = 0xff65_0800 as *const _;
2739 #[doc = r"Return the pointer to the register block"]
2740 #[inline(always)]
2741 pub const fn ptr() -> *const mmu::RegisterBlock {
2742 Self::PTR
2743 }
2744 #[doc = r" Steal an instance of this peripheral"]
2745 #[doc = r""]
2746 #[doc = r" # Safety"]
2747 #[doc = r""]
2748 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2749 #[doc = r" that may race with any existing instances, for example by only"]
2750 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2751 #[doc = r" original peripheral and using critical sections to coordinate"]
2752 #[doc = r" access between multiple new instances."]
2753 #[doc = r""]
2754 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2755 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2756 #[doc = r" no stolen instances are passed to such software."]
2757 pub unsafe fn steal() -> Self {
2758 Self {
2759 _marker: PhantomData,
2760 }
2761 }
2762}
2763impl Deref for MmuVpu {
2764 type Target = mmu::RegisterBlock;
2765 #[inline(always)]
2766 fn deref(&self) -> &Self::Target {
2767 unsafe { &*Self::PTR }
2768 }
2769}
2770impl core::fmt::Debug for MmuVpu {
2771 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2772 f.debug_struct("MmuVpu").finish()
2773 }
2774}
2775#[doc = "Registers of Memory Management Unit (MMU) for Video Processing Unit (VPU)"]
2776pub use self::mmu as mmu_vpu;
2777#[doc = "Memory Schedule (MSCH) Registers"]
2778pub struct Msch {
2779 _marker: PhantomData<*const ()>,
2780}
2781unsafe impl Send for Msch {}
2782impl Msch {
2783 #[doc = r"Pointer to the register block"]
2784 pub const PTR: *const msch::RegisterBlock = 0xffa8_4000 as *const _;
2785 #[doc = r"Return the pointer to the register block"]
2786 #[inline(always)]
2787 pub const fn ptr() -> *const msch::RegisterBlock {
2788 Self::PTR
2789 }
2790 #[doc = r" Steal an instance of this peripheral"]
2791 #[doc = r""]
2792 #[doc = r" # Safety"]
2793 #[doc = r""]
2794 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2795 #[doc = r" that may race with any existing instances, for example by only"]
2796 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2797 #[doc = r" original peripheral and using critical sections to coordinate"]
2798 #[doc = r" access between multiple new instances."]
2799 #[doc = r""]
2800 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2801 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2802 #[doc = r" no stolen instances are passed to such software."]
2803 pub unsafe fn steal() -> Self {
2804 Self {
2805 _marker: PhantomData,
2806 }
2807 }
2808}
2809impl Deref for Msch {
2810 type Target = msch::RegisterBlock;
2811 #[inline(always)]
2812 fn deref(&self) -> &Self::Target {
2813 unsafe { &*Self::PTR }
2814 }
2815}
2816impl core::fmt::Debug for Msch {
2817 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2818 f.debug_struct("Msch").finish()
2819 }
2820}
2821#[doc = "Memory Schedule (MSCH) Registers"]
2822pub mod msch;
2823#[doc = "Memory Schedule (MSCH) 0 Registers"]
2824pub struct Msch0 {
2825 _marker: PhantomData<*const ()>,
2826}
2827unsafe impl Send for Msch0 {}
2828impl Msch0 {
2829 #[doc = r"Pointer to the register block"]
2830 pub const PTR: *const msch::RegisterBlock = 0xffa8_4000 as *const _;
2831 #[doc = r"Return the pointer to the register block"]
2832 #[inline(always)]
2833 pub const fn ptr() -> *const msch::RegisterBlock {
2834 Self::PTR
2835 }
2836 #[doc = r" Steal an instance of this peripheral"]
2837 #[doc = r""]
2838 #[doc = r" # Safety"]
2839 #[doc = r""]
2840 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2841 #[doc = r" that may race with any existing instances, for example by only"]
2842 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2843 #[doc = r" original peripheral and using critical sections to coordinate"]
2844 #[doc = r" access between multiple new instances."]
2845 #[doc = r""]
2846 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2847 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2848 #[doc = r" no stolen instances are passed to such software."]
2849 pub unsafe fn steal() -> Self {
2850 Self {
2851 _marker: PhantomData,
2852 }
2853 }
2854}
2855impl Deref for Msch0 {
2856 type Target = msch::RegisterBlock;
2857 #[inline(always)]
2858 fn deref(&self) -> &Self::Target {
2859 unsafe { &*Self::PTR }
2860 }
2861}
2862impl core::fmt::Debug for Msch0 {
2863 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2864 f.debug_struct("Msch0").finish()
2865 }
2866}
2867#[doc = "Memory Schedule (MSCH) 0 Registers"]
2868pub use self::msch as msch0;
2869#[doc = "Memory Schedule (MSCH) 1 Registers"]
2870pub struct Msch1 {
2871 _marker: PhantomData<*const ()>,
2872}
2873unsafe impl Send for Msch1 {}
2874impl Msch1 {
2875 #[doc = r"Pointer to the register block"]
2876 pub const PTR: *const msch::RegisterBlock = 0xffa8_c000 as *const _;
2877 #[doc = r"Return the pointer to the register block"]
2878 #[inline(always)]
2879 pub const fn ptr() -> *const msch::RegisterBlock {
2880 Self::PTR
2881 }
2882 #[doc = r" Steal an instance of this peripheral"]
2883 #[doc = r""]
2884 #[doc = r" # Safety"]
2885 #[doc = r""]
2886 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2887 #[doc = r" that may race with any existing instances, for example by only"]
2888 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2889 #[doc = r" original peripheral and using critical sections to coordinate"]
2890 #[doc = r" access between multiple new instances."]
2891 #[doc = r""]
2892 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2893 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2894 #[doc = r" no stolen instances are passed to such software."]
2895 pub unsafe fn steal() -> Self {
2896 Self {
2897 _marker: PhantomData,
2898 }
2899 }
2900}
2901impl Deref for Msch1 {
2902 type Target = msch::RegisterBlock;
2903 #[inline(always)]
2904 fn deref(&self) -> &Self::Target {
2905 unsafe { &*Self::PTR }
2906 }
2907}
2908impl core::fmt::Debug for Msch1 {
2909 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2910 f.debug_struct("Msch1").finish()
2911 }
2912}
2913#[doc = "Memory Schedule (MSCH) 1 Registers"]
2914pub use self::msch as msch1;
2915#[doc = "PCIe Client Registers"]
2916pub struct PcieClient {
2917 _marker: PhantomData<*const ()>,
2918}
2919unsafe impl Send for PcieClient {}
2920impl PcieClient {
2921 #[doc = r"Pointer to the register block"]
2922 pub const PTR: *const pcie_client::RegisterBlock = 0xfd00_0000 as *const _;
2923 #[doc = r"Return the pointer to the register block"]
2924 #[inline(always)]
2925 pub const fn ptr() -> *const pcie_client::RegisterBlock {
2926 Self::PTR
2927 }
2928 #[doc = r" Steal an instance of this peripheral"]
2929 #[doc = r""]
2930 #[doc = r" # Safety"]
2931 #[doc = r""]
2932 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2933 #[doc = r" that may race with any existing instances, for example by only"]
2934 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2935 #[doc = r" original peripheral and using critical sections to coordinate"]
2936 #[doc = r" access between multiple new instances."]
2937 #[doc = r""]
2938 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2939 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2940 #[doc = r" no stolen instances are passed to such software."]
2941 pub unsafe fn steal() -> Self {
2942 Self {
2943 _marker: PhantomData,
2944 }
2945 }
2946}
2947impl Deref for PcieClient {
2948 type Target = pcie_client::RegisterBlock;
2949 #[inline(always)]
2950 fn deref(&self) -> &Self::Target {
2951 unsafe { &*Self::PTR }
2952 }
2953}
2954impl core::fmt::Debug for PcieClient {
2955 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2956 f.debug_struct("PcieClient").finish()
2957 }
2958}
2959#[doc = "PCIe Client Registers"]
2960pub mod pcie_client;
2961#[doc = "PCIe Core Registers"]
2962pub struct PcieCore {
2963 _marker: PhantomData<*const ()>,
2964}
2965unsafe impl Send for PcieCore {}
2966impl PcieCore {
2967 #[doc = r"Pointer to the register block"]
2968 pub const PTR: *const pcie_core::RegisterBlock = 0xfd80_0000 as *const _;
2969 #[doc = r"Return the pointer to the register block"]
2970 #[inline(always)]
2971 pub const fn ptr() -> *const pcie_core::RegisterBlock {
2972 Self::PTR
2973 }
2974 #[doc = r" Steal an instance of this peripheral"]
2975 #[doc = r""]
2976 #[doc = r" # Safety"]
2977 #[doc = r""]
2978 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
2979 #[doc = r" that may race with any existing instances, for example by only"]
2980 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
2981 #[doc = r" original peripheral and using critical sections to coordinate"]
2982 #[doc = r" access between multiple new instances."]
2983 #[doc = r""]
2984 #[doc = r" Additionally, other software such as HALs may rely on only one"]
2985 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
2986 #[doc = r" no stolen instances are passed to such software."]
2987 pub unsafe fn steal() -> Self {
2988 Self {
2989 _marker: PhantomData,
2990 }
2991 }
2992}
2993impl Deref for PcieCore {
2994 type Target = pcie_core::RegisterBlock;
2995 #[inline(always)]
2996 fn deref(&self) -> &Self::Target {
2997 unsafe { &*Self::PTR }
2998 }
2999}
3000impl core::fmt::Debug for PcieCore {
3001 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3002 f.debug_struct("PcieCore").finish()
3003 }
3004}
3005#[doc = "PCIe Core Registers"]
3006pub mod pcie_core;
3007#[doc = "Power Management Unit (PMU) Registers"]
3008pub struct Pmu {
3009 _marker: PhantomData<*const ()>,
3010}
3011unsafe impl Send for Pmu {}
3012impl Pmu {
3013 #[doc = r"Pointer to the register block"]
3014 pub const PTR: *const pmu::RegisterBlock = 0xff31_0000 as *const _;
3015 #[doc = r"Return the pointer to the register block"]
3016 #[inline(always)]
3017 pub const fn ptr() -> *const pmu::RegisterBlock {
3018 Self::PTR
3019 }
3020 #[doc = r" Steal an instance of this peripheral"]
3021 #[doc = r""]
3022 #[doc = r" # Safety"]
3023 #[doc = r""]
3024 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3025 #[doc = r" that may race with any existing instances, for example by only"]
3026 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3027 #[doc = r" original peripheral and using critical sections to coordinate"]
3028 #[doc = r" access between multiple new instances."]
3029 #[doc = r""]
3030 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3031 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3032 #[doc = r" no stolen instances are passed to such software."]
3033 pub unsafe fn steal() -> Self {
3034 Self {
3035 _marker: PhantomData,
3036 }
3037 }
3038}
3039impl Deref for Pmu {
3040 type Target = pmu::RegisterBlock;
3041 #[inline(always)]
3042 fn deref(&self) -> &Self::Target {
3043 unsafe { &*Self::PTR }
3044 }
3045}
3046impl core::fmt::Debug for Pmu {
3047 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3048 f.debug_struct("Pmu").finish()
3049 }
3050}
3051#[doc = "Power Management Unit (PMU) Registers"]
3052pub mod pmu;
3053#[doc = "Power Management Unit Clock and Reset Unit (PMUCRU) Registers"]
3054pub struct Pmucru {
3055 _marker: PhantomData<*const ()>,
3056}
3057unsafe impl Send for Pmucru {}
3058impl Pmucru {
3059 #[doc = r"Pointer to the register block"]
3060 pub const PTR: *const pmucru::RegisterBlock = 0xff75_0000 as *const _;
3061 #[doc = r"Return the pointer to the register block"]
3062 #[inline(always)]
3063 pub const fn ptr() -> *const pmucru::RegisterBlock {
3064 Self::PTR
3065 }
3066 #[doc = r" Steal an instance of this peripheral"]
3067 #[doc = r""]
3068 #[doc = r" # Safety"]
3069 #[doc = r""]
3070 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3071 #[doc = r" that may race with any existing instances, for example by only"]
3072 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3073 #[doc = r" original peripheral and using critical sections to coordinate"]
3074 #[doc = r" access between multiple new instances."]
3075 #[doc = r""]
3076 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3077 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3078 #[doc = r" no stolen instances are passed to such software."]
3079 pub unsafe fn steal() -> Self {
3080 Self {
3081 _marker: PhantomData,
3082 }
3083 }
3084}
3085impl Deref for Pmucru {
3086 type Target = pmucru::RegisterBlock;
3087 #[inline(always)]
3088 fn deref(&self) -> &Self::Target {
3089 unsafe { &*Self::PTR }
3090 }
3091}
3092impl core::fmt::Debug for Pmucru {
3093 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3094 f.debug_struct("Pmucru").finish()
3095 }
3096}
3097#[doc = "Power Management Unit Clock and Reset Unit (PMUCRU) Registers"]
3098pub mod pmucru;
3099#[doc = "Power Management Unit General Register File (PMUGRF) Registers"]
3100pub struct Pmugrf {
3101 _marker: PhantomData<*const ()>,
3102}
3103unsafe impl Send for Pmugrf {}
3104impl Pmugrf {
3105 #[doc = r"Pointer to the register block"]
3106 pub const PTR: *const pmugrf::RegisterBlock = 0xff32_0000 as *const _;
3107 #[doc = r"Return the pointer to the register block"]
3108 #[inline(always)]
3109 pub const fn ptr() -> *const pmugrf::RegisterBlock {
3110 Self::PTR
3111 }
3112 #[doc = r" Steal an instance of this peripheral"]
3113 #[doc = r""]
3114 #[doc = r" # Safety"]
3115 #[doc = r""]
3116 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3117 #[doc = r" that may race with any existing instances, for example by only"]
3118 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3119 #[doc = r" original peripheral and using critical sections to coordinate"]
3120 #[doc = r" access between multiple new instances."]
3121 #[doc = r""]
3122 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3123 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3124 #[doc = r" no stolen instances are passed to such software."]
3125 pub unsafe fn steal() -> Self {
3126 Self {
3127 _marker: PhantomData,
3128 }
3129 }
3130}
3131impl Deref for Pmugrf {
3132 type Target = pmugrf::RegisterBlock;
3133 #[inline(always)]
3134 fn deref(&self) -> &Self::Target {
3135 unsafe { &*Self::PTR }
3136 }
3137}
3138impl core::fmt::Debug for Pmugrf {
3139 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3140 f.debug_struct("Pmugrf").finish()
3141 }
3142}
3143#[doc = "Power Management Unit General Register File (PMUGRF) Registers"]
3144pub mod pmugrf;
3145#[doc = "VPU Prefetch Cache Registers"]
3146pub struct PrefCache {
3147 _marker: PhantomData<*const ()>,
3148}
3149unsafe impl Send for PrefCache {}
3150impl PrefCache {
3151 #[doc = r"Pointer to the register block"]
3152 pub const PTR: *const pref_cache::RegisterBlock = 0xff66_0400 as *const _;
3153 #[doc = r"Return the pointer to the register block"]
3154 #[inline(always)]
3155 pub const fn ptr() -> *const pref_cache::RegisterBlock {
3156 Self::PTR
3157 }
3158 #[doc = r" Steal an instance of this peripheral"]
3159 #[doc = r""]
3160 #[doc = r" # Safety"]
3161 #[doc = r""]
3162 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3163 #[doc = r" that may race with any existing instances, for example by only"]
3164 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3165 #[doc = r" original peripheral and using critical sections to coordinate"]
3166 #[doc = r" access between multiple new instances."]
3167 #[doc = r""]
3168 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3169 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3170 #[doc = r" no stolen instances are passed to such software."]
3171 pub unsafe fn steal() -> Self {
3172 Self {
3173 _marker: PhantomData,
3174 }
3175 }
3176}
3177impl Deref for PrefCache {
3178 type Target = pref_cache::RegisterBlock;
3179 #[inline(always)]
3180 fn deref(&self) -> &Self::Target {
3181 unsafe { &*Self::PTR }
3182 }
3183}
3184impl core::fmt::Debug for PrefCache {
3185 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3186 f.debug_struct("PrefCache").finish()
3187 }
3188}
3189#[doc = "VPU Prefetch Cache Registers"]
3190pub mod pref_cache;
3191#[doc = "RKVDEC Chroma Prefetch Cache Control Registers"]
3192pub struct PrefCacheRkvdecChroma {
3193 _marker: PhantomData<*const ()>,
3194}
3195unsafe impl Send for PrefCacheRkvdecChroma {}
3196impl PrefCacheRkvdecChroma {
3197 #[doc = r"Pointer to the register block"]
3198 pub const PTR: *const pref_cache::RegisterBlock = 0xff66_0440 as *const _;
3199 #[doc = r"Return the pointer to the register block"]
3200 #[inline(always)]
3201 pub const fn ptr() -> *const pref_cache::RegisterBlock {
3202 Self::PTR
3203 }
3204 #[doc = r" Steal an instance of this peripheral"]
3205 #[doc = r""]
3206 #[doc = r" # Safety"]
3207 #[doc = r""]
3208 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3209 #[doc = r" that may race with any existing instances, for example by only"]
3210 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3211 #[doc = r" original peripheral and using critical sections to coordinate"]
3212 #[doc = r" access between multiple new instances."]
3213 #[doc = r""]
3214 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3215 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3216 #[doc = r" no stolen instances are passed to such software."]
3217 pub unsafe fn steal() -> Self {
3218 Self {
3219 _marker: PhantomData,
3220 }
3221 }
3222}
3223impl Deref for PrefCacheRkvdecChroma {
3224 type Target = pref_cache::RegisterBlock;
3225 #[inline(always)]
3226 fn deref(&self) -> &Self::Target {
3227 unsafe { &*Self::PTR }
3228 }
3229}
3230impl core::fmt::Debug for PrefCacheRkvdecChroma {
3231 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3232 f.debug_struct("PrefCacheRkvdecChroma").finish()
3233 }
3234}
3235#[doc = "RKVDEC Chroma Prefetch Cache Control Registers"]
3236pub use self::pref_cache as pref_cache_rkvdec_chroma;
3237#[doc = "RKVDEC Luma Prefetch Cache Control Registers"]
3238pub struct PrefCacheRkvdecLuma {
3239 _marker: PhantomData<*const ()>,
3240}
3241unsafe impl Send for PrefCacheRkvdecLuma {}
3242impl PrefCacheRkvdecLuma {
3243 #[doc = r"Pointer to the register block"]
3244 pub const PTR: *const pref_cache::RegisterBlock = 0xff66_0400 as *const _;
3245 #[doc = r"Return the pointer to the register block"]
3246 #[inline(always)]
3247 pub const fn ptr() -> *const pref_cache::RegisterBlock {
3248 Self::PTR
3249 }
3250 #[doc = r" Steal an instance of this peripheral"]
3251 #[doc = r""]
3252 #[doc = r" # Safety"]
3253 #[doc = r""]
3254 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3255 #[doc = r" that may race with any existing instances, for example by only"]
3256 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3257 #[doc = r" original peripheral and using critical sections to coordinate"]
3258 #[doc = r" access between multiple new instances."]
3259 #[doc = r""]
3260 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3261 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3262 #[doc = r" no stolen instances are passed to such software."]
3263 pub unsafe fn steal() -> Self {
3264 Self {
3265 _marker: PhantomData,
3266 }
3267 }
3268}
3269impl Deref for PrefCacheRkvdecLuma {
3270 type Target = pref_cache::RegisterBlock;
3271 #[inline(always)]
3272 fn deref(&self) -> &Self::Target {
3273 unsafe { &*Self::PTR }
3274 }
3275}
3276impl core::fmt::Debug for PrefCacheRkvdecLuma {
3277 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3278 f.debug_struct("PrefCacheRkvdecLuma").finish()
3279 }
3280}
3281#[doc = "RKVDEC Luma Prefetch Cache Control Registers"]
3282pub use self::pref_cache as pref_cache_rkvdec_luma;
3283#[doc = "VPU Prefetch Cache Control Registers"]
3284pub struct PrefCacheVpu {
3285 _marker: PhantomData<*const ()>,
3286}
3287unsafe impl Send for PrefCacheVpu {}
3288impl PrefCacheVpu {
3289 #[doc = r"Pointer to the register block"]
3290 pub const PTR: *const pref_cache::RegisterBlock = 0xff65_0c00 as *const _;
3291 #[doc = r"Return the pointer to the register block"]
3292 #[inline(always)]
3293 pub const fn ptr() -> *const pref_cache::RegisterBlock {
3294 Self::PTR
3295 }
3296 #[doc = r" Steal an instance of this peripheral"]
3297 #[doc = r""]
3298 #[doc = r" # Safety"]
3299 #[doc = r""]
3300 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3301 #[doc = r" that may race with any existing instances, for example by only"]
3302 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3303 #[doc = r" original peripheral and using critical sections to coordinate"]
3304 #[doc = r" access between multiple new instances."]
3305 #[doc = r""]
3306 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3307 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3308 #[doc = r" no stolen instances are passed to such software."]
3309 pub unsafe fn steal() -> Self {
3310 Self {
3311 _marker: PhantomData,
3312 }
3313 }
3314}
3315impl Deref for PrefCacheVpu {
3316 type Target = pref_cache::RegisterBlock;
3317 #[inline(always)]
3318 fn deref(&self) -> &Self::Target {
3319 unsafe { &*Self::PTR }
3320 }
3321}
3322impl core::fmt::Debug for PrefCacheVpu {
3323 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3324 f.debug_struct("PrefCacheVpu").finish()
3325 }
3326}
3327#[doc = "VPU Prefetch Cache Control Registers"]
3328pub use self::pref_cache as pref_cache_vpu;
3329#[doc = "Probe Registers"]
3330pub struct Probe {
3331 _marker: PhantomData<*const ()>,
3332}
3333unsafe impl Send for Probe {}
3334impl Probe {
3335 #[doc = r"Pointer to the register block"]
3336 pub const PTR: *const probe::RegisterBlock = 0xffa8_6000 as *const _;
3337 #[doc = r"Return the pointer to the register block"]
3338 #[inline(always)]
3339 pub const fn ptr() -> *const probe::RegisterBlock {
3340 Self::PTR
3341 }
3342 #[doc = r" Steal an instance of this peripheral"]
3343 #[doc = r""]
3344 #[doc = r" # Safety"]
3345 #[doc = r""]
3346 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3347 #[doc = r" that may race with any existing instances, for example by only"]
3348 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3349 #[doc = r" original peripheral and using critical sections to coordinate"]
3350 #[doc = r" access between multiple new instances."]
3351 #[doc = r""]
3352 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3353 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3354 #[doc = r" no stolen instances are passed to such software."]
3355 pub unsafe fn steal() -> Self {
3356 Self {
3357 _marker: PhantomData,
3358 }
3359 }
3360}
3361impl Deref for Probe {
3362 type Target = probe::RegisterBlock;
3363 #[inline(always)]
3364 fn deref(&self) -> &Self::Target {
3365 unsafe { &*Self::PTR }
3366 }
3367}
3368impl core::fmt::Debug for Probe {
3369 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3370 f.debug_struct("Probe").finish()
3371 }
3372}
3373#[doc = "Probe Registers"]
3374pub mod probe;
3375#[doc = "Registers for the probe covering paths from the CCI_M1 to the memory schedule 0"]
3376pub struct ProbeCciMsch0 {
3377 _marker: PhantomData<*const ()>,
3378}
3379unsafe impl Send for ProbeCciMsch0 {}
3380impl ProbeCciMsch0 {
3381 #[doc = r"Pointer to the register block"]
3382 pub const PTR: *const probe::RegisterBlock = 0xffa8_6000 as *const _;
3383 #[doc = r"Return the pointer to the register block"]
3384 #[inline(always)]
3385 pub const fn ptr() -> *const probe::RegisterBlock {
3386 Self::PTR
3387 }
3388 #[doc = r" Steal an instance of this peripheral"]
3389 #[doc = r""]
3390 #[doc = r" # Safety"]
3391 #[doc = r""]
3392 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3393 #[doc = r" that may race with any existing instances, for example by only"]
3394 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3395 #[doc = r" original peripheral and using critical sections to coordinate"]
3396 #[doc = r" access between multiple new instances."]
3397 #[doc = r""]
3398 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3399 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3400 #[doc = r" no stolen instances are passed to such software."]
3401 pub unsafe fn steal() -> Self {
3402 Self {
3403 _marker: PhantomData,
3404 }
3405 }
3406}
3407impl Deref for ProbeCciMsch0 {
3408 type Target = probe::RegisterBlock;
3409 #[inline(always)]
3410 fn deref(&self) -> &Self::Target {
3411 unsafe { &*Self::PTR }
3412 }
3413}
3414impl core::fmt::Debug for ProbeCciMsch0 {
3415 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3416 f.debug_struct("ProbeCciMsch0").finish()
3417 }
3418}
3419#[doc = "Registers for the probe covering paths from the CCI_M1 to the memory schedule 0"]
3420pub use self::probe as probe_cci_msch0;
3421#[doc = "Registers for the probe covering paths from the CCI_M1 to the memory schedule 1"]
3422pub struct ProbeCciMsch1 {
3423 _marker: PhantomData<*const ()>,
3424}
3425unsafe impl Send for ProbeCciMsch1 {}
3426impl ProbeCciMsch1 {
3427 #[doc = r"Pointer to the register block"]
3428 pub const PTR: *const probe::RegisterBlock = 0xffa8_e000 as *const _;
3429 #[doc = r"Return the pointer to the register block"]
3430 #[inline(always)]
3431 pub const fn ptr() -> *const probe::RegisterBlock {
3432 Self::PTR
3433 }
3434 #[doc = r" Steal an instance of this peripheral"]
3435 #[doc = r""]
3436 #[doc = r" # Safety"]
3437 #[doc = r""]
3438 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3439 #[doc = r" that may race with any existing instances, for example by only"]
3440 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3441 #[doc = r" original peripheral and using critical sections to coordinate"]
3442 #[doc = r" access between multiple new instances."]
3443 #[doc = r""]
3444 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3445 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3446 #[doc = r" no stolen instances are passed to such software."]
3447 pub unsafe fn steal() -> Self {
3448 Self {
3449 _marker: PhantomData,
3450 }
3451 }
3452}
3453impl Deref for ProbeCciMsch1 {
3454 type Target = probe::RegisterBlock;
3455 #[inline(always)]
3456 fn deref(&self) -> &Self::Target {
3457 unsafe { &*Self::PTR }
3458 }
3459}
3460impl core::fmt::Debug for ProbeCciMsch1 {
3461 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3462 f.debug_struct("ProbeCciMsch1").finish()
3463 }
3464}
3465#[doc = "Registers for the probe covering paths from the CCI_M1 to the memory schedule 1"]
3466pub use self::probe as probe_cci_msch1;
3467#[doc = "Registers for the probe covering paths from the GPU to the memory schedule 0"]
3468pub struct ProbeGpuMsch0 {
3469 _marker: PhantomData<*const ()>,
3470}
3471unsafe impl Send for ProbeGpuMsch0 {}
3472impl ProbeGpuMsch0 {
3473 #[doc = r"Pointer to the register block"]
3474 pub const PTR: *const probe::RegisterBlock = 0xffa8_6400 as *const _;
3475 #[doc = r"Return the pointer to the register block"]
3476 #[inline(always)]
3477 pub const fn ptr() -> *const probe::RegisterBlock {
3478 Self::PTR
3479 }
3480 #[doc = r" Steal an instance of this peripheral"]
3481 #[doc = r""]
3482 #[doc = r" # Safety"]
3483 #[doc = r""]
3484 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3485 #[doc = r" that may race with any existing instances, for example by only"]
3486 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3487 #[doc = r" original peripheral and using critical sections to coordinate"]
3488 #[doc = r" access between multiple new instances."]
3489 #[doc = r""]
3490 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3491 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3492 #[doc = r" no stolen instances are passed to such software."]
3493 pub unsafe fn steal() -> Self {
3494 Self {
3495 _marker: PhantomData,
3496 }
3497 }
3498}
3499impl Deref for ProbeGpuMsch0 {
3500 type Target = probe::RegisterBlock;
3501 #[inline(always)]
3502 fn deref(&self) -> &Self::Target {
3503 unsafe { &*Self::PTR }
3504 }
3505}
3506impl core::fmt::Debug for ProbeGpuMsch0 {
3507 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3508 f.debug_struct("ProbeGpuMsch0").finish()
3509 }
3510}
3511#[doc = "Registers for the probe covering paths from the GPU to the memory schedule 0"]
3512pub use self::probe as probe_gpu_msch0;
3513#[doc = "Registers for the probe covering paths from the GPU to the memory schedule 1"]
3514pub struct ProbeGpuMsch1 {
3515 _marker: PhantomData<*const ()>,
3516}
3517unsafe impl Send for ProbeGpuMsch1 {}
3518impl ProbeGpuMsch1 {
3519 #[doc = r"Pointer to the register block"]
3520 pub const PTR: *const probe::RegisterBlock = 0xffa8_e400 as *const _;
3521 #[doc = r"Return the pointer to the register block"]
3522 #[inline(always)]
3523 pub const fn ptr() -> *const probe::RegisterBlock {
3524 Self::PTR
3525 }
3526 #[doc = r" Steal an instance of this peripheral"]
3527 #[doc = r""]
3528 #[doc = r" # Safety"]
3529 #[doc = r""]
3530 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3531 #[doc = r" that may race with any existing instances, for example by only"]
3532 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3533 #[doc = r" original peripheral and using critical sections to coordinate"]
3534 #[doc = r" access between multiple new instances."]
3535 #[doc = r""]
3536 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3537 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3538 #[doc = r" no stolen instances are passed to such software."]
3539 pub unsafe fn steal() -> Self {
3540 Self {
3541 _marker: PhantomData,
3542 }
3543 }
3544}
3545impl Deref for ProbeGpuMsch1 {
3546 type Target = probe::RegisterBlock;
3547 #[inline(always)]
3548 fn deref(&self) -> &Self::Target {
3549 unsafe { &*Self::PTR }
3550 }
3551}
3552impl core::fmt::Debug for ProbeGpuMsch1 {
3553 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3554 f.debug_struct("ProbeGpuMsch1").finish()
3555 }
3556}
3557#[doc = "Registers for the probe covering paths from the GPU to the memory schedule 1"]
3558pub use self::probe as probe_gpu_msch1;
3559#[doc = "Registers for the probe covering paths from the perihp master NIU to the memory schedule 0"]
3560pub struct ProbePerihpMsch0 {
3561 _marker: PhantomData<*const ()>,
3562}
3563unsafe impl Send for ProbePerihpMsch0 {}
3564impl ProbePerihpMsch0 {
3565 #[doc = r"Pointer to the register block"]
3566 pub const PTR: *const probe::RegisterBlock = 0xffa8_6800 as *const _;
3567 #[doc = r"Return the pointer to the register block"]
3568 #[inline(always)]
3569 pub const fn ptr() -> *const probe::RegisterBlock {
3570 Self::PTR
3571 }
3572 #[doc = r" Steal an instance of this peripheral"]
3573 #[doc = r""]
3574 #[doc = r" # Safety"]
3575 #[doc = r""]
3576 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3577 #[doc = r" that may race with any existing instances, for example by only"]
3578 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3579 #[doc = r" original peripheral and using critical sections to coordinate"]
3580 #[doc = r" access between multiple new instances."]
3581 #[doc = r""]
3582 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3583 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3584 #[doc = r" no stolen instances are passed to such software."]
3585 pub unsafe fn steal() -> Self {
3586 Self {
3587 _marker: PhantomData,
3588 }
3589 }
3590}
3591impl Deref for ProbePerihpMsch0 {
3592 type Target = probe::RegisterBlock;
3593 #[inline(always)]
3594 fn deref(&self) -> &Self::Target {
3595 unsafe { &*Self::PTR }
3596 }
3597}
3598impl core::fmt::Debug for ProbePerihpMsch0 {
3599 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3600 f.debug_struct("ProbePerihpMsch0").finish()
3601 }
3602}
3603#[doc = "Registers for the probe covering paths from the perihp master NIU to the memory schedule 0"]
3604pub use self::probe as probe_perihp_msch0;
3605#[doc = "Registers for the probe covering paths from the perihp master NIU to the memory schedule 1"]
3606pub struct ProbePerihpMsch1 {
3607 _marker: PhantomData<*const ()>,
3608}
3609unsafe impl Send for ProbePerihpMsch1 {}
3610impl ProbePerihpMsch1 {
3611 #[doc = r"Pointer to the register block"]
3612 pub const PTR: *const probe::RegisterBlock = 0xffa8_e800 as *const _;
3613 #[doc = r"Return the pointer to the register block"]
3614 #[inline(always)]
3615 pub const fn ptr() -> *const probe::RegisterBlock {
3616 Self::PTR
3617 }
3618 #[doc = r" Steal an instance of this peripheral"]
3619 #[doc = r""]
3620 #[doc = r" # Safety"]
3621 #[doc = r""]
3622 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3623 #[doc = r" that may race with any existing instances, for example by only"]
3624 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3625 #[doc = r" original peripheral and using critical sections to coordinate"]
3626 #[doc = r" access between multiple new instances."]
3627 #[doc = r""]
3628 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3629 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3630 #[doc = r" no stolen instances are passed to such software."]
3631 pub unsafe fn steal() -> Self {
3632 Self {
3633 _marker: PhantomData,
3634 }
3635 }
3636}
3637impl Deref for ProbePerihpMsch1 {
3638 type Target = probe::RegisterBlock;
3639 #[inline(always)]
3640 fn deref(&self) -> &Self::Target {
3641 unsafe { &*Self::PTR }
3642 }
3643}
3644impl core::fmt::Debug for ProbePerihpMsch1 {
3645 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3646 f.debug_struct("ProbePerihpMsch1").finish()
3647 }
3648}
3649#[doc = "Registers for the probe covering paths from the perihp master NIU to the memory schedule 1"]
3650pub use self::probe as probe_perihp_msch1;
3651#[doc = "Registers for the probe covering paths from the perilp master NIU, debug and CCI_M0 to the memory schedule 0"]
3652pub struct ProbePerilpMsch0 {
3653 _marker: PhantomData<*const ()>,
3654}
3655unsafe impl Send for ProbePerilpMsch0 {}
3656impl ProbePerilpMsch0 {
3657 #[doc = r"Pointer to the register block"]
3658 pub const PTR: *const probe::RegisterBlock = 0xffa8_6c00 as *const _;
3659 #[doc = r"Return the pointer to the register block"]
3660 #[inline(always)]
3661 pub const fn ptr() -> *const probe::RegisterBlock {
3662 Self::PTR
3663 }
3664 #[doc = r" Steal an instance of this peripheral"]
3665 #[doc = r""]
3666 #[doc = r" # Safety"]
3667 #[doc = r""]
3668 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3669 #[doc = r" that may race with any existing instances, for example by only"]
3670 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3671 #[doc = r" original peripheral and using critical sections to coordinate"]
3672 #[doc = r" access between multiple new instances."]
3673 #[doc = r""]
3674 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3675 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3676 #[doc = r" no stolen instances are passed to such software."]
3677 pub unsafe fn steal() -> Self {
3678 Self {
3679 _marker: PhantomData,
3680 }
3681 }
3682}
3683impl Deref for ProbePerilpMsch0 {
3684 type Target = probe::RegisterBlock;
3685 #[inline(always)]
3686 fn deref(&self) -> &Self::Target {
3687 unsafe { &*Self::PTR }
3688 }
3689}
3690impl core::fmt::Debug for ProbePerilpMsch0 {
3691 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3692 f.debug_struct("ProbePerilpMsch0").finish()
3693 }
3694}
3695#[doc = "Registers for the probe covering paths from the perilp master NIU, debug and CCI_M0 to the memory schedule 0"]
3696pub use self::probe as probe_perilp_msch0;
3697#[doc = "Registers for the probe covering paths from the perilp master NIU, debug and CCI_M0 to the memory schedule 1"]
3698pub struct ProbePerilpMsch1 {
3699 _marker: PhantomData<*const ()>,
3700}
3701unsafe impl Send for ProbePerilpMsch1 {}
3702impl ProbePerilpMsch1 {
3703 #[doc = r"Pointer to the register block"]
3704 pub const PTR: *const probe::RegisterBlock = 0xffa8_ec00 as *const _;
3705 #[doc = r"Return the pointer to the register block"]
3706 #[inline(always)]
3707 pub const fn ptr() -> *const probe::RegisterBlock {
3708 Self::PTR
3709 }
3710 #[doc = r" Steal an instance of this peripheral"]
3711 #[doc = r""]
3712 #[doc = r" # Safety"]
3713 #[doc = r""]
3714 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3715 #[doc = r" that may race with any existing instances, for example by only"]
3716 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3717 #[doc = r" original peripheral and using critical sections to coordinate"]
3718 #[doc = r" access between multiple new instances."]
3719 #[doc = r""]
3720 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3721 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3722 #[doc = r" no stolen instances are passed to such software."]
3723 pub unsafe fn steal() -> Self {
3724 Self {
3725 _marker: PhantomData,
3726 }
3727 }
3728}
3729impl Deref for ProbePerilpMsch1 {
3730 type Target = probe::RegisterBlock;
3731 #[inline(always)]
3732 fn deref(&self) -> &Self::Target {
3733 unsafe { &*Self::PTR }
3734 }
3735}
3736impl core::fmt::Debug for ProbePerilpMsch1 {
3737 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3738 f.debug_struct("ProbePerilpMsch1").finish()
3739 }
3740}
3741#[doc = "Registers for the probe covering paths from the perilp master NIU, debug and CCI_M0 to the memory schedule 1"]
3742pub use self::probe as probe_perilp_msch1;
3743#[doc = "Registers for the probe covering paths from video to the memory schedule 0"]
3744pub struct ProbeVideoMsch0 {
3745 _marker: PhantomData<*const ()>,
3746}
3747unsafe impl Send for ProbeVideoMsch0 {}
3748impl ProbeVideoMsch0 {
3749 #[doc = r"Pointer to the register block"]
3750 pub const PTR: *const probe::RegisterBlock = 0xffa8_7000 as *const _;
3751 #[doc = r"Return the pointer to the register block"]
3752 #[inline(always)]
3753 pub const fn ptr() -> *const probe::RegisterBlock {
3754 Self::PTR
3755 }
3756 #[doc = r" Steal an instance of this peripheral"]
3757 #[doc = r""]
3758 #[doc = r" # Safety"]
3759 #[doc = r""]
3760 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3761 #[doc = r" that may race with any existing instances, for example by only"]
3762 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3763 #[doc = r" original peripheral and using critical sections to coordinate"]
3764 #[doc = r" access between multiple new instances."]
3765 #[doc = r""]
3766 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3767 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3768 #[doc = r" no stolen instances are passed to such software."]
3769 pub unsafe fn steal() -> Self {
3770 Self {
3771 _marker: PhantomData,
3772 }
3773 }
3774}
3775impl Deref for ProbeVideoMsch0 {
3776 type Target = probe::RegisterBlock;
3777 #[inline(always)]
3778 fn deref(&self) -> &Self::Target {
3779 unsafe { &*Self::PTR }
3780 }
3781}
3782impl core::fmt::Debug for ProbeVideoMsch0 {
3783 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3784 f.debug_struct("ProbeVideoMsch0").finish()
3785 }
3786}
3787#[doc = "Registers for the probe covering paths from video to the memory schedule 0"]
3788pub use self::probe as probe_video_msch0;
3789#[doc = "Registers for the probe covering paths from video to the memory schedule 1"]
3790pub struct ProbeVideoMsch1 {
3791 _marker: PhantomData<*const ()>,
3792}
3793unsafe impl Send for ProbeVideoMsch1 {}
3794impl ProbeVideoMsch1 {
3795 #[doc = r"Pointer to the register block"]
3796 pub const PTR: *const probe::RegisterBlock = 0xffa8_f000 as *const _;
3797 #[doc = r"Return the pointer to the register block"]
3798 #[inline(always)]
3799 pub const fn ptr() -> *const probe::RegisterBlock {
3800 Self::PTR
3801 }
3802 #[doc = r" Steal an instance of this peripheral"]
3803 #[doc = r""]
3804 #[doc = r" # Safety"]
3805 #[doc = r""]
3806 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3807 #[doc = r" that may race with any existing instances, for example by only"]
3808 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3809 #[doc = r" original peripheral and using critical sections to coordinate"]
3810 #[doc = r" access between multiple new instances."]
3811 #[doc = r""]
3812 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3813 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3814 #[doc = r" no stolen instances are passed to such software."]
3815 pub unsafe fn steal() -> Self {
3816 Self {
3817 _marker: PhantomData,
3818 }
3819 }
3820}
3821impl Deref for ProbeVideoMsch1 {
3822 type Target = probe::RegisterBlock;
3823 #[inline(always)]
3824 fn deref(&self) -> &Self::Target {
3825 unsafe { &*Self::PTR }
3826 }
3827}
3828impl core::fmt::Debug for ProbeVideoMsch1 {
3829 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3830 f.debug_struct("ProbeVideoMsch1").finish()
3831 }
3832}
3833#[doc = "Registers for the probe covering paths from video to the memory schedule 1"]
3834pub use self::probe as probe_video_msch1;
3835#[doc = "Registers for the probe covering paths from the IEP, ISP0 and VOP-BIG to the memory schedule 0"]
3836pub struct ProbeVio0Msch0 {
3837 _marker: PhantomData<*const ()>,
3838}
3839unsafe impl Send for ProbeVio0Msch0 {}
3840impl ProbeVio0Msch0 {
3841 #[doc = r"Pointer to the register block"]
3842 pub const PTR: *const probe::RegisterBlock = 0xffa8_7400 as *const _;
3843 #[doc = r"Return the pointer to the register block"]
3844 #[inline(always)]
3845 pub const fn ptr() -> *const probe::RegisterBlock {
3846 Self::PTR
3847 }
3848 #[doc = r" Steal an instance of this peripheral"]
3849 #[doc = r""]
3850 #[doc = r" # Safety"]
3851 #[doc = r""]
3852 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3853 #[doc = r" that may race with any existing instances, for example by only"]
3854 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3855 #[doc = r" original peripheral and using critical sections to coordinate"]
3856 #[doc = r" access between multiple new instances."]
3857 #[doc = r""]
3858 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3859 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3860 #[doc = r" no stolen instances are passed to such software."]
3861 pub unsafe fn steal() -> Self {
3862 Self {
3863 _marker: PhantomData,
3864 }
3865 }
3866}
3867impl Deref for ProbeVio0Msch0 {
3868 type Target = probe::RegisterBlock;
3869 #[inline(always)]
3870 fn deref(&self) -> &Self::Target {
3871 unsafe { &*Self::PTR }
3872 }
3873}
3874impl core::fmt::Debug for ProbeVio0Msch0 {
3875 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3876 f.debug_struct("ProbeVio0Msch0").finish()
3877 }
3878}
3879#[doc = "Registers for the probe covering paths from the IEP, ISP0 and VOP-BIG to the memory schedule 0"]
3880pub use self::probe as probe_vio0_msch0;
3881#[doc = "Registers for the probe covering paths from the IEP, ISP0 and VOP-BIG to the memory schedule 1"]
3882pub struct ProbeVio0Msch1 {
3883 _marker: PhantomData<*const ()>,
3884}
3885unsafe impl Send for ProbeVio0Msch1 {}
3886impl ProbeVio0Msch1 {
3887 #[doc = r"Pointer to the register block"]
3888 pub const PTR: *const probe::RegisterBlock = 0xffa8_f400 as *const _;
3889 #[doc = r"Return the pointer to the register block"]
3890 #[inline(always)]
3891 pub const fn ptr() -> *const probe::RegisterBlock {
3892 Self::PTR
3893 }
3894 #[doc = r" Steal an instance of this peripheral"]
3895 #[doc = r""]
3896 #[doc = r" # Safety"]
3897 #[doc = r""]
3898 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3899 #[doc = r" that may race with any existing instances, for example by only"]
3900 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3901 #[doc = r" original peripheral and using critical sections to coordinate"]
3902 #[doc = r" access between multiple new instances."]
3903 #[doc = r""]
3904 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3905 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3906 #[doc = r" no stolen instances are passed to such software."]
3907 pub unsafe fn steal() -> Self {
3908 Self {
3909 _marker: PhantomData,
3910 }
3911 }
3912}
3913impl Deref for ProbeVio0Msch1 {
3914 type Target = probe::RegisterBlock;
3915 #[inline(always)]
3916 fn deref(&self) -> &Self::Target {
3917 unsafe { &*Self::PTR }
3918 }
3919}
3920impl core::fmt::Debug for ProbeVio0Msch1 {
3921 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3922 f.debug_struct("ProbeVio0Msch1").finish()
3923 }
3924}
3925#[doc = "Registers for the probe covering paths from the IEP, ISP0 and VOP-BIG to the memory schedule 1"]
3926pub use self::probe as probe_vio0_msch1;
3927#[doc = "Registers for the probe covering paths from the RGA, ISP1, VOP-LITTLE and HDCP to the memory schedule 0"]
3928pub struct ProbeVio1Msch0 {
3929 _marker: PhantomData<*const ()>,
3930}
3931unsafe impl Send for ProbeVio1Msch0 {}
3932impl ProbeVio1Msch0 {
3933 #[doc = r"Pointer to the register block"]
3934 pub const PTR: *const probe::RegisterBlock = 0xffa8_7800 as *const _;
3935 #[doc = r"Return the pointer to the register block"]
3936 #[inline(always)]
3937 pub const fn ptr() -> *const probe::RegisterBlock {
3938 Self::PTR
3939 }
3940 #[doc = r" Steal an instance of this peripheral"]
3941 #[doc = r""]
3942 #[doc = r" # Safety"]
3943 #[doc = r""]
3944 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3945 #[doc = r" that may race with any existing instances, for example by only"]
3946 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3947 #[doc = r" original peripheral and using critical sections to coordinate"]
3948 #[doc = r" access between multiple new instances."]
3949 #[doc = r""]
3950 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3951 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3952 #[doc = r" no stolen instances are passed to such software."]
3953 pub unsafe fn steal() -> Self {
3954 Self {
3955 _marker: PhantomData,
3956 }
3957 }
3958}
3959impl Deref for ProbeVio1Msch0 {
3960 type Target = probe::RegisterBlock;
3961 #[inline(always)]
3962 fn deref(&self) -> &Self::Target {
3963 unsafe { &*Self::PTR }
3964 }
3965}
3966impl core::fmt::Debug for ProbeVio1Msch0 {
3967 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3968 f.debug_struct("ProbeVio1Msch0").finish()
3969 }
3970}
3971#[doc = "Registers for the probe covering paths from the RGA, ISP1, VOP-LITTLE and HDCP to the memory schedule 0"]
3972pub use self::probe as probe_vio1_msch0;
3973#[doc = "Registers for the probe covering paths from the RGA, ISP1, VOP-LITTLE and HDCP to the memory schedule 1"]
3974pub struct ProbeVio1Msch1 {
3975 _marker: PhantomData<*const ()>,
3976}
3977unsafe impl Send for ProbeVio1Msch1 {}
3978impl ProbeVio1Msch1 {
3979 #[doc = r"Pointer to the register block"]
3980 pub const PTR: *const probe::RegisterBlock = 0xffa8_f800 as *const _;
3981 #[doc = r"Return the pointer to the register block"]
3982 #[inline(always)]
3983 pub const fn ptr() -> *const probe::RegisterBlock {
3984 Self::PTR
3985 }
3986 #[doc = r" Steal an instance of this peripheral"]
3987 #[doc = r""]
3988 #[doc = r" # Safety"]
3989 #[doc = r""]
3990 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
3991 #[doc = r" that may race with any existing instances, for example by only"]
3992 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
3993 #[doc = r" original peripheral and using critical sections to coordinate"]
3994 #[doc = r" access between multiple new instances."]
3995 #[doc = r""]
3996 #[doc = r" Additionally, other software such as HALs may rely on only one"]
3997 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
3998 #[doc = r" no stolen instances are passed to such software."]
3999 pub unsafe fn steal() -> Self {
4000 Self {
4001 _marker: PhantomData,
4002 }
4003 }
4004}
4005impl Deref for ProbeVio1Msch1 {
4006 type Target = probe::RegisterBlock;
4007 #[inline(always)]
4008 fn deref(&self) -> &Self::Target {
4009 unsafe { &*Self::PTR }
4010 }
4011}
4012impl core::fmt::Debug for ProbeVio1Msch1 {
4013 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4014 f.debug_struct("ProbeVio1Msch1").finish()
4015 }
4016}
4017#[doc = "Registers for the probe covering paths from the RGA, ISP1, VOP-LITTLE and HDCP to the memory schedule 1"]
4018pub use self::probe as probe_vio1_msch1;
4019#[doc = "Pulse Width Modulation (PWM) Registers"]
4020pub struct Pwm {
4021 _marker: PhantomData<*const ()>,
4022}
4023unsafe impl Send for Pwm {}
4024impl Pwm {
4025 #[doc = r"Pointer to the register block"]
4026 pub const PTR: *const pwm::RegisterBlock = 0xff42_0000 as *const _;
4027 #[doc = r"Return the pointer to the register block"]
4028 #[inline(always)]
4029 pub const fn ptr() -> *const pwm::RegisterBlock {
4030 Self::PTR
4031 }
4032 #[doc = r" Steal an instance of this peripheral"]
4033 #[doc = r""]
4034 #[doc = r" # Safety"]
4035 #[doc = r""]
4036 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4037 #[doc = r" that may race with any existing instances, for example by only"]
4038 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4039 #[doc = r" original peripheral and using critical sections to coordinate"]
4040 #[doc = r" access between multiple new instances."]
4041 #[doc = r""]
4042 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4043 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4044 #[doc = r" no stolen instances are passed to such software."]
4045 pub unsafe fn steal() -> Self {
4046 Self {
4047 _marker: PhantomData,
4048 }
4049 }
4050}
4051impl Deref for Pwm {
4052 type Target = pwm::RegisterBlock;
4053 #[inline(always)]
4054 fn deref(&self) -> &Self::Target {
4055 unsafe { &*Self::PTR }
4056 }
4057}
4058impl core::fmt::Debug for Pwm {
4059 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4060 f.debug_struct("Pwm").finish()
4061 }
4062}
4063#[doc = "Pulse Width Modulation (PWM) Registers"]
4064pub mod pwm;
4065#[doc = "Quality of Service (QOS) Registers"]
4066pub struct Qos {
4067 _marker: PhantomData<*const ()>,
4068}
4069unsafe impl Send for Qos {}
4070impl Qos {
4071 #[doc = r"Pointer to the register block"]
4072 pub const PTR: *const qos::RegisterBlock = 0xffa5_0000 as *const _;
4073 #[doc = r"Return the pointer to the register block"]
4074 #[inline(always)]
4075 pub const fn ptr() -> *const qos::RegisterBlock {
4076 Self::PTR
4077 }
4078 #[doc = r" Steal an instance of this peripheral"]
4079 #[doc = r""]
4080 #[doc = r" # Safety"]
4081 #[doc = r""]
4082 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4083 #[doc = r" that may race with any existing instances, for example by only"]
4084 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4085 #[doc = r" original peripheral and using critical sections to coordinate"]
4086 #[doc = r" access between multiple new instances."]
4087 #[doc = r""]
4088 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4089 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4090 #[doc = r" no stolen instances are passed to such software."]
4091 pub unsafe fn steal() -> Self {
4092 Self {
4093 _marker: PhantomData,
4094 }
4095 }
4096}
4097impl Deref for Qos {
4098 type Target = qos::RegisterBlock;
4099 #[inline(always)]
4100 fn deref(&self) -> &Self::Target {
4101 unsafe { &*Self::PTR }
4102 }
4103}
4104impl core::fmt::Debug for Qos {
4105 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4106 f.debug_struct("Qos").finish()
4107 }
4108}
4109#[doc = "Quality of Service (QOS) Registers"]
4110pub mod qos;
4111#[doc = "QoS Registers for CCI_M0"]
4112pub struct QosCciM0 {
4113 _marker: PhantomData<*const ()>,
4114}
4115unsafe impl Send for QosCciM0 {}
4116impl QosCciM0 {
4117 #[doc = r"Pointer to the register block"]
4118 pub const PTR: *const qos::RegisterBlock = 0xffa5_0000 as *const _;
4119 #[doc = r"Return the pointer to the register block"]
4120 #[inline(always)]
4121 pub const fn ptr() -> *const qos::RegisterBlock {
4122 Self::PTR
4123 }
4124 #[doc = r" Steal an instance of this peripheral"]
4125 #[doc = r""]
4126 #[doc = r" # Safety"]
4127 #[doc = r""]
4128 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4129 #[doc = r" that may race with any existing instances, for example by only"]
4130 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4131 #[doc = r" original peripheral and using critical sections to coordinate"]
4132 #[doc = r" access between multiple new instances."]
4133 #[doc = r""]
4134 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4135 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4136 #[doc = r" no stolen instances are passed to such software."]
4137 pub unsafe fn steal() -> Self {
4138 Self {
4139 _marker: PhantomData,
4140 }
4141 }
4142}
4143impl Deref for QosCciM0 {
4144 type Target = qos::RegisterBlock;
4145 #[inline(always)]
4146 fn deref(&self) -> &Self::Target {
4147 unsafe { &*Self::PTR }
4148 }
4149}
4150impl core::fmt::Debug for QosCciM0 {
4151 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4152 f.debug_struct("QosCciM0").finish()
4153 }
4154}
4155#[doc = "QoS Registers for CCI_M0"]
4156pub use self::qos as qos_cci_m0;
4157#[doc = "QoS Registers for CCI_M1"]
4158pub struct QosCciM1 {
4159 _marker: PhantomData<*const ()>,
4160}
4161unsafe impl Send for QosCciM1 {}
4162impl QosCciM1 {
4163 #[doc = r"Pointer to the register block"]
4164 pub const PTR: *const qos::RegisterBlock = 0xffad_8000 as *const _;
4165 #[doc = r"Return the pointer to the register block"]
4166 #[inline(always)]
4167 pub const fn ptr() -> *const qos::RegisterBlock {
4168 Self::PTR
4169 }
4170 #[doc = r" Steal an instance of this peripheral"]
4171 #[doc = r""]
4172 #[doc = r" # Safety"]
4173 #[doc = r""]
4174 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4175 #[doc = r" that may race with any existing instances, for example by only"]
4176 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4177 #[doc = r" original peripheral and using critical sections to coordinate"]
4178 #[doc = r" access between multiple new instances."]
4179 #[doc = r""]
4180 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4181 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4182 #[doc = r" no stolen instances are passed to such software."]
4183 pub unsafe fn steal() -> Self {
4184 Self {
4185 _marker: PhantomData,
4186 }
4187 }
4188}
4189impl Deref for QosCciM1 {
4190 type Target = qos::RegisterBlock;
4191 #[inline(always)]
4192 fn deref(&self) -> &Self::Target {
4193 unsafe { &*Self::PTR }
4194 }
4195}
4196impl core::fmt::Debug for QosCciM1 {
4197 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4198 f.debug_struct("QosCciM1").finish()
4199 }
4200}
4201#[doc = "QoS Registers for CCI_M1"]
4202pub use self::qos as qos_cci_m1;
4203#[doc = "QoS Registers for CRYPTO0"]
4204pub struct QosCrypto0 {
4205 _marker: PhantomData<*const ()>,
4206}
4207unsafe impl Send for QosCrypto0 {}
4208impl QosCrypto0 {
4209 #[doc = r"Pointer to the register block"]
4210 pub const PTR: *const qos::RegisterBlock = 0xffa6_4100 as *const _;
4211 #[doc = r"Return the pointer to the register block"]
4212 #[inline(always)]
4213 pub const fn ptr() -> *const qos::RegisterBlock {
4214 Self::PTR
4215 }
4216 #[doc = r" Steal an instance of this peripheral"]
4217 #[doc = r""]
4218 #[doc = r" # Safety"]
4219 #[doc = r""]
4220 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4221 #[doc = r" that may race with any existing instances, for example by only"]
4222 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4223 #[doc = r" original peripheral and using critical sections to coordinate"]
4224 #[doc = r" access between multiple new instances."]
4225 #[doc = r""]
4226 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4227 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4228 #[doc = r" no stolen instances are passed to such software."]
4229 pub unsafe fn steal() -> Self {
4230 Self {
4231 _marker: PhantomData,
4232 }
4233 }
4234}
4235impl Deref for QosCrypto0 {
4236 type Target = qos::RegisterBlock;
4237 #[inline(always)]
4238 fn deref(&self) -> &Self::Target {
4239 unsafe { &*Self::PTR }
4240 }
4241}
4242impl core::fmt::Debug for QosCrypto0 {
4243 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4244 f.debug_struct("QosCrypto0").finish()
4245 }
4246}
4247#[doc = "QoS Registers for CRYPTO0"]
4248pub use self::qos as qos_crypto0;
4249#[doc = "QoS Registers for CRYPTO1"]
4250pub struct QosCrypto1 {
4251 _marker: PhantomData<*const ()>,
4252}
4253unsafe impl Send for QosCrypto1 {}
4254impl QosCrypto1 {
4255 #[doc = r"Pointer to the register block"]
4256 pub const PTR: *const qos::RegisterBlock = 0xffa6_4080 as *const _;
4257 #[doc = r"Return the pointer to the register block"]
4258 #[inline(always)]
4259 pub const fn ptr() -> *const qos::RegisterBlock {
4260 Self::PTR
4261 }
4262 #[doc = r" Steal an instance of this peripheral"]
4263 #[doc = r""]
4264 #[doc = r" # Safety"]
4265 #[doc = r""]
4266 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4267 #[doc = r" that may race with any existing instances, for example by only"]
4268 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4269 #[doc = r" original peripheral and using critical sections to coordinate"]
4270 #[doc = r" access between multiple new instances."]
4271 #[doc = r""]
4272 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4273 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4274 #[doc = r" no stolen instances are passed to such software."]
4275 pub unsafe fn steal() -> Self {
4276 Self {
4277 _marker: PhantomData,
4278 }
4279 }
4280}
4281impl Deref for QosCrypto1 {
4282 type Target = qos::RegisterBlock;
4283 #[inline(always)]
4284 fn deref(&self) -> &Self::Target {
4285 unsafe { &*Self::PTR }
4286 }
4287}
4288impl core::fmt::Debug for QosCrypto1 {
4289 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4290 f.debug_struct("QosCrypto1").finish()
4291 }
4292}
4293#[doc = "QoS Registers for CRYPTO1"]
4294pub use self::qos as qos_crypto1;
4295#[doc = "QoS Registers for DCF"]
4296pub struct QosDcf {
4297 _marker: PhantomData<*const ()>,
4298}
4299unsafe impl Send for QosDcf {}
4300impl QosDcf {
4301 #[doc = r"Pointer to the register block"]
4302 pub const PTR: *const qos::RegisterBlock = 0xffa6_4180 as *const _;
4303 #[doc = r"Return the pointer to the register block"]
4304 #[inline(always)]
4305 pub const fn ptr() -> *const qos::RegisterBlock {
4306 Self::PTR
4307 }
4308 #[doc = r" Steal an instance of this peripheral"]
4309 #[doc = r""]
4310 #[doc = r" # Safety"]
4311 #[doc = r""]
4312 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4313 #[doc = r" that may race with any existing instances, for example by only"]
4314 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4315 #[doc = r" original peripheral and using critical sections to coordinate"]
4316 #[doc = r" access between multiple new instances."]
4317 #[doc = r""]
4318 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4319 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4320 #[doc = r" no stolen instances are passed to such software."]
4321 pub unsafe fn steal() -> Self {
4322 Self {
4323 _marker: PhantomData,
4324 }
4325 }
4326}
4327impl Deref for QosDcf {
4328 type Target = qos::RegisterBlock;
4329 #[inline(always)]
4330 fn deref(&self) -> &Self::Target {
4331 unsafe { &*Self::PTR }
4332 }
4333}
4334impl core::fmt::Debug for QosDcf {
4335 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4336 f.debug_struct("QosDcf").finish()
4337 }
4338}
4339#[doc = "QoS Registers for DCF"]
4340pub use self::qos as qos_dcf;
4341#[doc = "QoS Registers for DMAC0"]
4342pub struct QosDmac0 {
4343 _marker: PhantomData<*const ()>,
4344}
4345unsafe impl Send for QosDmac0 {}
4346impl QosDmac0 {
4347 #[doc = r"Pointer to the register block"]
4348 pub const PTR: *const qos::RegisterBlock = 0xffa6_4200 as *const _;
4349 #[doc = r"Return the pointer to the register block"]
4350 #[inline(always)]
4351 pub const fn ptr() -> *const qos::RegisterBlock {
4352 Self::PTR
4353 }
4354 #[doc = r" Steal an instance of this peripheral"]
4355 #[doc = r""]
4356 #[doc = r" # Safety"]
4357 #[doc = r""]
4358 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4359 #[doc = r" that may race with any existing instances, for example by only"]
4360 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4361 #[doc = r" original peripheral and using critical sections to coordinate"]
4362 #[doc = r" access between multiple new instances."]
4363 #[doc = r""]
4364 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4365 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4366 #[doc = r" no stolen instances are passed to such software."]
4367 pub unsafe fn steal() -> Self {
4368 Self {
4369 _marker: PhantomData,
4370 }
4371 }
4372}
4373impl Deref for QosDmac0 {
4374 type Target = qos::RegisterBlock;
4375 #[inline(always)]
4376 fn deref(&self) -> &Self::Target {
4377 unsafe { &*Self::PTR }
4378 }
4379}
4380impl core::fmt::Debug for QosDmac0 {
4381 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4382 f.debug_struct("QosDmac0").finish()
4383 }
4384}
4385#[doc = "QoS Registers for DMAC0"]
4386pub use self::qos as qos_dmac0;
4387#[doc = "QoS Registers for DMAC1"]
4388pub struct QosDmac1 {
4389 _marker: PhantomData<*const ()>,
4390}
4391unsafe impl Send for QosDmac1 {}
4392impl QosDmac1 {
4393 #[doc = r"Pointer to the register block"]
4394 pub const PTR: *const qos::RegisterBlock = 0xffa6_4280 as *const _;
4395 #[doc = r"Return the pointer to the register block"]
4396 #[inline(always)]
4397 pub const fn ptr() -> *const qos::RegisterBlock {
4398 Self::PTR
4399 }
4400 #[doc = r" Steal an instance of this peripheral"]
4401 #[doc = r""]
4402 #[doc = r" # Safety"]
4403 #[doc = r""]
4404 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4405 #[doc = r" that may race with any existing instances, for example by only"]
4406 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4407 #[doc = r" original peripheral and using critical sections to coordinate"]
4408 #[doc = r" access between multiple new instances."]
4409 #[doc = r""]
4410 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4411 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4412 #[doc = r" no stolen instances are passed to such software."]
4413 pub unsafe fn steal() -> Self {
4414 Self {
4415 _marker: PhantomData,
4416 }
4417 }
4418}
4419impl Deref for QosDmac1 {
4420 type Target = qos::RegisterBlock;
4421 #[inline(always)]
4422 fn deref(&self) -> &Self::Target {
4423 unsafe { &*Self::PTR }
4424 }
4425}
4426impl core::fmt::Debug for QosDmac1 {
4427 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4428 f.debug_struct("QosDmac1").finish()
4429 }
4430}
4431#[doc = "QoS Registers for DMAC1"]
4432pub use self::qos as qos_dmac1;
4433#[doc = "QoS Registers for EMMC"]
4434pub struct QosEmmc {
4435 _marker: PhantomData<*const ()>,
4436}
4437unsafe impl Send for QosEmmc {}
4438impl QosEmmc {
4439 #[doc = r"Pointer to the register block"]
4440 pub const PTR: *const qos::RegisterBlock = 0xffa5_8000 as *const _;
4441 #[doc = r"Return the pointer to the register block"]
4442 #[inline(always)]
4443 pub const fn ptr() -> *const qos::RegisterBlock {
4444 Self::PTR
4445 }
4446 #[doc = r" Steal an instance of this peripheral"]
4447 #[doc = r""]
4448 #[doc = r" # Safety"]
4449 #[doc = r""]
4450 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4451 #[doc = r" that may race with any existing instances, for example by only"]
4452 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4453 #[doc = r" original peripheral and using critical sections to coordinate"]
4454 #[doc = r" access between multiple new instances."]
4455 #[doc = r""]
4456 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4457 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4458 #[doc = r" no stolen instances are passed to such software."]
4459 pub unsafe fn steal() -> Self {
4460 Self {
4461 _marker: PhantomData,
4462 }
4463 }
4464}
4465impl Deref for QosEmmc {
4466 type Target = qos::RegisterBlock;
4467 #[inline(always)]
4468 fn deref(&self) -> &Self::Target {
4469 unsafe { &*Self::PTR }
4470 }
4471}
4472impl core::fmt::Debug for QosEmmc {
4473 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4474 f.debug_struct("QosEmmc").finish()
4475 }
4476}
4477#[doc = "QoS Registers for EMMC"]
4478pub use self::qos as qos_emmc;
4479#[doc = "QoS Registers for GIC"]
4480pub struct QosGic {
4481 _marker: PhantomData<*const ()>,
4482}
4483unsafe impl Send for QosGic {}
4484impl QosGic {
4485 #[doc = r"Pointer to the register block"]
4486 pub const PTR: *const qos::RegisterBlock = 0xffa7_8000 as *const _;
4487 #[doc = r"Return the pointer to the register block"]
4488 #[inline(always)]
4489 pub const fn ptr() -> *const qos::RegisterBlock {
4490 Self::PTR
4491 }
4492 #[doc = r" Steal an instance of this peripheral"]
4493 #[doc = r""]
4494 #[doc = r" # Safety"]
4495 #[doc = r""]
4496 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4497 #[doc = r" that may race with any existing instances, for example by only"]
4498 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4499 #[doc = r" original peripheral and using critical sections to coordinate"]
4500 #[doc = r" access between multiple new instances."]
4501 #[doc = r""]
4502 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4503 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4504 #[doc = r" no stolen instances are passed to such software."]
4505 pub unsafe fn steal() -> Self {
4506 Self {
4507 _marker: PhantomData,
4508 }
4509 }
4510}
4511impl Deref for QosGic {
4512 type Target = qos::RegisterBlock;
4513 #[inline(always)]
4514 fn deref(&self) -> &Self::Target {
4515 unsafe { &*Self::PTR }
4516 }
4517}
4518impl core::fmt::Debug for QosGic {
4519 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4520 f.debug_struct("QosGic").finish()
4521 }
4522}
4523#[doc = "QoS Registers for GIC"]
4524pub use self::qos as qos_gic;
4525#[doc = "QoS Registers for GMAC"]
4526pub struct QosGmac {
4527 _marker: PhantomData<*const ()>,
4528}
4529unsafe impl Send for QosGmac {}
4530impl QosGmac {
4531 #[doc = r"Pointer to the register block"]
4532 pub const PTR: *const qos::RegisterBlock = 0xffa5_c000 as *const _;
4533 #[doc = r"Return the pointer to the register block"]
4534 #[inline(always)]
4535 pub const fn ptr() -> *const qos::RegisterBlock {
4536 Self::PTR
4537 }
4538 #[doc = r" Steal an instance of this peripheral"]
4539 #[doc = r""]
4540 #[doc = r" # Safety"]
4541 #[doc = r""]
4542 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4543 #[doc = r" that may race with any existing instances, for example by only"]
4544 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4545 #[doc = r" original peripheral and using critical sections to coordinate"]
4546 #[doc = r" access between multiple new instances."]
4547 #[doc = r""]
4548 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4549 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4550 #[doc = r" no stolen instances are passed to such software."]
4551 pub unsafe fn steal() -> Self {
4552 Self {
4553 _marker: PhantomData,
4554 }
4555 }
4556}
4557impl Deref for QosGmac {
4558 type Target = qos::RegisterBlock;
4559 #[inline(always)]
4560 fn deref(&self) -> &Self::Target {
4561 unsafe { &*Self::PTR }
4562 }
4563}
4564impl core::fmt::Debug for QosGmac {
4565 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4566 f.debug_struct("QosGmac").finish()
4567 }
4568}
4569#[doc = "QoS Registers for GMAC"]
4570pub use self::qos as qos_gmac;
4571#[doc = "QoS Registers for GPU"]
4572pub struct QosGpu {
4573 _marker: PhantomData<*const ()>,
4574}
4575unsafe impl Send for QosGpu {}
4576impl QosGpu {
4577 #[doc = r"Pointer to the register block"]
4578 pub const PTR: *const qos::RegisterBlock = 0xffae_0000 as *const _;
4579 #[doc = r"Return the pointer to the register block"]
4580 #[inline(always)]
4581 pub const fn ptr() -> *const qos::RegisterBlock {
4582 Self::PTR
4583 }
4584 #[doc = r" Steal an instance of this peripheral"]
4585 #[doc = r""]
4586 #[doc = r" # Safety"]
4587 #[doc = r""]
4588 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4589 #[doc = r" that may race with any existing instances, for example by only"]
4590 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4591 #[doc = r" original peripheral and using critical sections to coordinate"]
4592 #[doc = r" access between multiple new instances."]
4593 #[doc = r""]
4594 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4595 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4596 #[doc = r" no stolen instances are passed to such software."]
4597 pub unsafe fn steal() -> Self {
4598 Self {
4599 _marker: PhantomData,
4600 }
4601 }
4602}
4603impl Deref for QosGpu {
4604 type Target = qos::RegisterBlock;
4605 #[inline(always)]
4606 fn deref(&self) -> &Self::Target {
4607 unsafe { &*Self::PTR }
4608 }
4609}
4610impl core::fmt::Debug for QosGpu {
4611 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4612 f.debug_struct("QosGpu").finish()
4613 }
4614}
4615#[doc = "QoS Registers for GPU"]
4616pub use self::qos as qos_gpu;
4617#[doc = "QoS Registers for HDCP"]
4618pub struct QosHdcp {
4619 _marker: PhantomData<*const ()>,
4620}
4621unsafe impl Send for QosHdcp {}
4622impl QosHdcp {
4623 #[doc = r"Pointer to the register block"]
4624 pub const PTR: *const qos::RegisterBlock = 0xffa9_0000 as *const _;
4625 #[doc = r"Return the pointer to the register block"]
4626 #[inline(always)]
4627 pub const fn ptr() -> *const qos::RegisterBlock {
4628 Self::PTR
4629 }
4630 #[doc = r" Steal an instance of this peripheral"]
4631 #[doc = r""]
4632 #[doc = r" # Safety"]
4633 #[doc = r""]
4634 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4635 #[doc = r" that may race with any existing instances, for example by only"]
4636 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4637 #[doc = r" original peripheral and using critical sections to coordinate"]
4638 #[doc = r" access between multiple new instances."]
4639 #[doc = r""]
4640 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4641 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4642 #[doc = r" no stolen instances are passed to such software."]
4643 pub unsafe fn steal() -> Self {
4644 Self {
4645 _marker: PhantomData,
4646 }
4647 }
4648}
4649impl Deref for QosHdcp {
4650 type Target = qos::RegisterBlock;
4651 #[inline(always)]
4652 fn deref(&self) -> &Self::Target {
4653 unsafe { &*Self::PTR }
4654 }
4655}
4656impl core::fmt::Debug for QosHdcp {
4657 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4658 f.debug_struct("QosHdcp").finish()
4659 }
4660}
4661#[doc = "QoS Registers for HDCP"]
4662pub use self::qos as qos_hdcp;
4663#[doc = "QoS Registers for HSIC"]
4664pub struct QosHsic {
4665 _marker: PhantomData<*const ()>,
4666}
4667unsafe impl Send for QosHsic {}
4668impl QosHsic {
4669 #[doc = r"Pointer to the register block"]
4670 pub const PTR: *const qos::RegisterBlock = 0xffa6_0000 as *const _;
4671 #[doc = r"Return the pointer to the register block"]
4672 #[inline(always)]
4673 pub const fn ptr() -> *const qos::RegisterBlock {
4674 Self::PTR
4675 }
4676 #[doc = r" Steal an instance of this peripheral"]
4677 #[doc = r""]
4678 #[doc = r" # Safety"]
4679 #[doc = r""]
4680 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4681 #[doc = r" that may race with any existing instances, for example by only"]
4682 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4683 #[doc = r" original peripheral and using critical sections to coordinate"]
4684 #[doc = r" access between multiple new instances."]
4685 #[doc = r""]
4686 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4687 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4688 #[doc = r" no stolen instances are passed to such software."]
4689 pub unsafe fn steal() -> Self {
4690 Self {
4691 _marker: PhantomData,
4692 }
4693 }
4694}
4695impl Deref for QosHsic {
4696 type Target = qos::RegisterBlock;
4697 #[inline(always)]
4698 fn deref(&self) -> &Self::Target {
4699 unsafe { &*Self::PTR }
4700 }
4701}
4702impl core::fmt::Debug for QosHsic {
4703 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4704 f.debug_struct("QosHsic").finish()
4705 }
4706}
4707#[doc = "QoS Registers for HSIC"]
4708pub use self::qos as qos_hsic;
4709#[doc = "QoS Registers for IEP"]
4710pub struct QosIep {
4711 _marker: PhantomData<*const ()>,
4712}
4713unsafe impl Send for QosIep {}
4714impl QosIep {
4715 #[doc = r"Pointer to the register block"]
4716 pub const PTR: *const qos::RegisterBlock = 0xffa9_8000 as *const _;
4717 #[doc = r"Return the pointer to the register block"]
4718 #[inline(always)]
4719 pub const fn ptr() -> *const qos::RegisterBlock {
4720 Self::PTR
4721 }
4722 #[doc = r" Steal an instance of this peripheral"]
4723 #[doc = r""]
4724 #[doc = r" # Safety"]
4725 #[doc = r""]
4726 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4727 #[doc = r" that may race with any existing instances, for example by only"]
4728 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4729 #[doc = r" original peripheral and using critical sections to coordinate"]
4730 #[doc = r" access between multiple new instances."]
4731 #[doc = r""]
4732 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4733 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4734 #[doc = r" no stolen instances are passed to such software."]
4735 pub unsafe fn steal() -> Self {
4736 Self {
4737 _marker: PhantomData,
4738 }
4739 }
4740}
4741impl Deref for QosIep {
4742 type Target = qos::RegisterBlock;
4743 #[inline(always)]
4744 fn deref(&self) -> &Self::Target {
4745 unsafe { &*Self::PTR }
4746 }
4747}
4748impl core::fmt::Debug for QosIep {
4749 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4750 f.debug_struct("QosIep").finish()
4751 }
4752}
4753#[doc = "QoS Registers for IEP"]
4754pub use self::qos as qos_iep;
4755#[doc = "QoS Registers for ISP0_M0"]
4756pub struct QosIsp0M0 {
4757 _marker: PhantomData<*const ()>,
4758}
4759unsafe impl Send for QosIsp0M0 {}
4760impl QosIsp0M0 {
4761 #[doc = r"Pointer to the register block"]
4762 pub const PTR: *const qos::RegisterBlock = 0xffaa_0000 as *const _;
4763 #[doc = r"Return the pointer to the register block"]
4764 #[inline(always)]
4765 pub const fn ptr() -> *const qos::RegisterBlock {
4766 Self::PTR
4767 }
4768 #[doc = r" Steal an instance of this peripheral"]
4769 #[doc = r""]
4770 #[doc = r" # Safety"]
4771 #[doc = r""]
4772 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4773 #[doc = r" that may race with any existing instances, for example by only"]
4774 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4775 #[doc = r" original peripheral and using critical sections to coordinate"]
4776 #[doc = r" access between multiple new instances."]
4777 #[doc = r""]
4778 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4779 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4780 #[doc = r" no stolen instances are passed to such software."]
4781 pub unsafe fn steal() -> Self {
4782 Self {
4783 _marker: PhantomData,
4784 }
4785 }
4786}
4787impl Deref for QosIsp0M0 {
4788 type Target = qos::RegisterBlock;
4789 #[inline(always)]
4790 fn deref(&self) -> &Self::Target {
4791 unsafe { &*Self::PTR }
4792 }
4793}
4794impl core::fmt::Debug for QosIsp0M0 {
4795 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4796 f.debug_struct("QosIsp0M0").finish()
4797 }
4798}
4799#[doc = "QoS Registers for ISP0_M0"]
4800pub use self::qos as qos_isp0_m0;
4801#[doc = "QoS Registers for ISP0_M1"]
4802pub struct QosIsp0M1 {
4803 _marker: PhantomData<*const ()>,
4804}
4805unsafe impl Send for QosIsp0M1 {}
4806impl QosIsp0M1 {
4807 #[doc = r"Pointer to the register block"]
4808 pub const PTR: *const qos::RegisterBlock = 0xffaa_0080 as *const _;
4809 #[doc = r"Return the pointer to the register block"]
4810 #[inline(always)]
4811 pub const fn ptr() -> *const qos::RegisterBlock {
4812 Self::PTR
4813 }
4814 #[doc = r" Steal an instance of this peripheral"]
4815 #[doc = r""]
4816 #[doc = r" # Safety"]
4817 #[doc = r""]
4818 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4819 #[doc = r" that may race with any existing instances, for example by only"]
4820 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4821 #[doc = r" original peripheral and using critical sections to coordinate"]
4822 #[doc = r" access between multiple new instances."]
4823 #[doc = r""]
4824 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4825 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4826 #[doc = r" no stolen instances are passed to such software."]
4827 pub unsafe fn steal() -> Self {
4828 Self {
4829 _marker: PhantomData,
4830 }
4831 }
4832}
4833impl Deref for QosIsp0M1 {
4834 type Target = qos::RegisterBlock;
4835 #[inline(always)]
4836 fn deref(&self) -> &Self::Target {
4837 unsafe { &*Self::PTR }
4838 }
4839}
4840impl core::fmt::Debug for QosIsp0M1 {
4841 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4842 f.debug_struct("QosIsp0M1").finish()
4843 }
4844}
4845#[doc = "QoS Registers for ISP0_M1"]
4846pub use self::qos as qos_isp0_m1;
4847#[doc = "QoS Registers for ISP1_M0"]
4848pub struct QosIsp1M0 {
4849 _marker: PhantomData<*const ()>,
4850}
4851unsafe impl Send for QosIsp1M0 {}
4852impl QosIsp1M0 {
4853 #[doc = r"Pointer to the register block"]
4854 pub const PTR: *const qos::RegisterBlock = 0xffaa_8000 as *const _;
4855 #[doc = r"Return the pointer to the register block"]
4856 #[inline(always)]
4857 pub const fn ptr() -> *const qos::RegisterBlock {
4858 Self::PTR
4859 }
4860 #[doc = r" Steal an instance of this peripheral"]
4861 #[doc = r""]
4862 #[doc = r" # Safety"]
4863 #[doc = r""]
4864 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4865 #[doc = r" that may race with any existing instances, for example by only"]
4866 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4867 #[doc = r" original peripheral and using critical sections to coordinate"]
4868 #[doc = r" access between multiple new instances."]
4869 #[doc = r""]
4870 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4871 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4872 #[doc = r" no stolen instances are passed to such software."]
4873 pub unsafe fn steal() -> Self {
4874 Self {
4875 _marker: PhantomData,
4876 }
4877 }
4878}
4879impl Deref for QosIsp1M0 {
4880 type Target = qos::RegisterBlock;
4881 #[inline(always)]
4882 fn deref(&self) -> &Self::Target {
4883 unsafe { &*Self::PTR }
4884 }
4885}
4886impl core::fmt::Debug for QosIsp1M0 {
4887 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4888 f.debug_struct("QosIsp1M0").finish()
4889 }
4890}
4891#[doc = "QoS Registers for ISP1_M0"]
4892pub use self::qos as qos_isp1_m0;
4893#[doc = "QoS Registers for ISP1_M1"]
4894pub struct QosIsp1M1 {
4895 _marker: PhantomData<*const ()>,
4896}
4897unsafe impl Send for QosIsp1M1 {}
4898impl QosIsp1M1 {
4899 #[doc = r"Pointer to the register block"]
4900 pub const PTR: *const qos::RegisterBlock = 0xffaa_8080 as *const _;
4901 #[doc = r"Return the pointer to the register block"]
4902 #[inline(always)]
4903 pub const fn ptr() -> *const qos::RegisterBlock {
4904 Self::PTR
4905 }
4906 #[doc = r" Steal an instance of this peripheral"]
4907 #[doc = r""]
4908 #[doc = r" # Safety"]
4909 #[doc = r""]
4910 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4911 #[doc = r" that may race with any existing instances, for example by only"]
4912 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4913 #[doc = r" original peripheral and using critical sections to coordinate"]
4914 #[doc = r" access between multiple new instances."]
4915 #[doc = r""]
4916 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4917 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4918 #[doc = r" no stolen instances are passed to such software."]
4919 pub unsafe fn steal() -> Self {
4920 Self {
4921 _marker: PhantomData,
4922 }
4923 }
4924}
4925impl Deref for QosIsp1M1 {
4926 type Target = qos::RegisterBlock;
4927 #[inline(always)]
4928 fn deref(&self) -> &Self::Target {
4929 unsafe { &*Self::PTR }
4930 }
4931}
4932impl core::fmt::Debug for QosIsp1M1 {
4933 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4934 f.debug_struct("QosIsp1M1").finish()
4935 }
4936}
4937#[doc = "QoS Registers for ISP1_M1"]
4938pub use self::qos as qos_isp1_m1;
4939#[doc = "QoS Registers for PCIE"]
4940pub struct QosPcie {
4941 _marker: PhantomData<*const ()>,
4942}
4943unsafe impl Send for QosPcie {}
4944impl QosPcie {
4945 #[doc = r"Pointer to the register block"]
4946 pub const PTR: *const qos::RegisterBlock = 0xffa6_0080 as *const _;
4947 #[doc = r"Return the pointer to the register block"]
4948 #[inline(always)]
4949 pub const fn ptr() -> *const qos::RegisterBlock {
4950 Self::PTR
4951 }
4952 #[doc = r" Steal an instance of this peripheral"]
4953 #[doc = r""]
4954 #[doc = r" # Safety"]
4955 #[doc = r""]
4956 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
4957 #[doc = r" that may race with any existing instances, for example by only"]
4958 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
4959 #[doc = r" original peripheral and using critical sections to coordinate"]
4960 #[doc = r" access between multiple new instances."]
4961 #[doc = r""]
4962 #[doc = r" Additionally, other software such as HALs may rely on only one"]
4963 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
4964 #[doc = r" no stolen instances are passed to such software."]
4965 pub unsafe fn steal() -> Self {
4966 Self {
4967 _marker: PhantomData,
4968 }
4969 }
4970}
4971impl Deref for QosPcie {
4972 type Target = qos::RegisterBlock;
4973 #[inline(always)]
4974 fn deref(&self) -> &Self::Target {
4975 unsafe { &*Self::PTR }
4976 }
4977}
4978impl core::fmt::Debug for QosPcie {
4979 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4980 f.debug_struct("QosPcie").finish()
4981 }
4982}
4983#[doc = "QoS Registers for PCIE"]
4984pub use self::qos as qos_pcie;
4985#[doc = "QoS Registers for PERIHP_NSP"]
4986pub struct QosPerihpNsp {
4987 _marker: PhantomData<*const ()>,
4988}
4989unsafe impl Send for QosPerihpNsp {}
4990impl QosPerihpNsp {
4991 #[doc = r"Pointer to the register block"]
4992 pub const PTR: *const qos::RegisterBlock = 0xffad_8080 as *const _;
4993 #[doc = r"Return the pointer to the register block"]
4994 #[inline(always)]
4995 pub const fn ptr() -> *const qos::RegisterBlock {
4996 Self::PTR
4997 }
4998 #[doc = r" Steal an instance of this peripheral"]
4999 #[doc = r""]
5000 #[doc = r" # Safety"]
5001 #[doc = r""]
5002 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5003 #[doc = r" that may race with any existing instances, for example by only"]
5004 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5005 #[doc = r" original peripheral and using critical sections to coordinate"]
5006 #[doc = r" access between multiple new instances."]
5007 #[doc = r""]
5008 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5009 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5010 #[doc = r" no stolen instances are passed to such software."]
5011 pub unsafe fn steal() -> Self {
5012 Self {
5013 _marker: PhantomData,
5014 }
5015 }
5016}
5017impl Deref for QosPerihpNsp {
5018 type Target = qos::RegisterBlock;
5019 #[inline(always)]
5020 fn deref(&self) -> &Self::Target {
5021 unsafe { &*Self::PTR }
5022 }
5023}
5024impl core::fmt::Debug for QosPerihpNsp {
5025 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5026 f.debug_struct("QosPerihpNsp").finish()
5027 }
5028}
5029#[doc = "QoS Registers for PERIHP_NSP"]
5030pub use self::qos as qos_perihp_nsp;
5031#[doc = "QoS Registers for PERILPSLV_NSP"]
5032pub struct QosPerilpslvNsp {
5033 _marker: PhantomData<*const ()>,
5034}
5035unsafe impl Send for QosPerilpslvNsp {}
5036impl QosPerilpslvNsp {
5037 #[doc = r"Pointer to the register block"]
5038 pub const PTR: *const qos::RegisterBlock = 0xffad_8100 as *const _;
5039 #[doc = r"Return the pointer to the register block"]
5040 #[inline(always)]
5041 pub const fn ptr() -> *const qos::RegisterBlock {
5042 Self::PTR
5043 }
5044 #[doc = r" Steal an instance of this peripheral"]
5045 #[doc = r""]
5046 #[doc = r" # Safety"]
5047 #[doc = r""]
5048 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5049 #[doc = r" that may race with any existing instances, for example by only"]
5050 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5051 #[doc = r" original peripheral and using critical sections to coordinate"]
5052 #[doc = r" access between multiple new instances."]
5053 #[doc = r""]
5054 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5055 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5056 #[doc = r" no stolen instances are passed to such software."]
5057 pub unsafe fn steal() -> Self {
5058 Self {
5059 _marker: PhantomData,
5060 }
5061 }
5062}
5063impl Deref for QosPerilpslvNsp {
5064 type Target = qos::RegisterBlock;
5065 #[inline(always)]
5066 fn deref(&self) -> &Self::Target {
5067 unsafe { &*Self::PTR }
5068 }
5069}
5070impl core::fmt::Debug for QosPerilpslvNsp {
5071 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5072 f.debug_struct("QosPerilpslvNsp").finish()
5073 }
5074}
5075#[doc = "QoS Registers for PERILPSLV_NSP"]
5076pub use self::qos as qos_perilpslv_nsp;
5077#[doc = "QoS Registers for PERILP_NSP"]
5078pub struct QosPerilpNsp {
5079 _marker: PhantomData<*const ()>,
5080}
5081unsafe impl Send for QosPerilpNsp {}
5082impl QosPerilpNsp {
5083 #[doc = r"Pointer to the register block"]
5084 pub const PTR: *const qos::RegisterBlock = 0xffad_8180 as *const _;
5085 #[doc = r"Return the pointer to the register block"]
5086 #[inline(always)]
5087 pub const fn ptr() -> *const qos::RegisterBlock {
5088 Self::PTR
5089 }
5090 #[doc = r" Steal an instance of this peripheral"]
5091 #[doc = r""]
5092 #[doc = r" # Safety"]
5093 #[doc = r""]
5094 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5095 #[doc = r" that may race with any existing instances, for example by only"]
5096 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5097 #[doc = r" original peripheral and using critical sections to coordinate"]
5098 #[doc = r" access between multiple new instances."]
5099 #[doc = r""]
5100 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5101 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5102 #[doc = r" no stolen instances are passed to such software."]
5103 pub unsafe fn steal() -> Self {
5104 Self {
5105 _marker: PhantomData,
5106 }
5107 }
5108}
5109impl Deref for QosPerilpNsp {
5110 type Target = qos::RegisterBlock;
5111 #[inline(always)]
5112 fn deref(&self) -> &Self::Target {
5113 unsafe { &*Self::PTR }
5114 }
5115}
5116impl core::fmt::Debug for QosPerilpNsp {
5117 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5118 f.debug_struct("QosPerilpNsp").finish()
5119 }
5120}
5121#[doc = "QoS Registers for PERILP_NSP"]
5122pub use self::qos as qos_perilp_nsp;
5123#[doc = "QoS Registers for PERI_CM0"]
5124pub struct QosPeriCm0 {
5125 _marker: PhantomData<*const ()>,
5126}
5127unsafe impl Send for QosPeriCm0 {}
5128impl QosPeriCm0 {
5129 #[doc = r"Pointer to the register block"]
5130 pub const PTR: *const qos::RegisterBlock = 0xffa6_4300 as *const _;
5131 #[doc = r"Return the pointer to the register block"]
5132 #[inline(always)]
5133 pub const fn ptr() -> *const qos::RegisterBlock {
5134 Self::PTR
5135 }
5136 #[doc = r" Steal an instance of this peripheral"]
5137 #[doc = r""]
5138 #[doc = r" # Safety"]
5139 #[doc = r""]
5140 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5141 #[doc = r" that may race with any existing instances, for example by only"]
5142 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5143 #[doc = r" original peripheral and using critical sections to coordinate"]
5144 #[doc = r" access between multiple new instances."]
5145 #[doc = r""]
5146 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5147 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5148 #[doc = r" no stolen instances are passed to such software."]
5149 pub unsafe fn steal() -> Self {
5150 Self {
5151 _marker: PhantomData,
5152 }
5153 }
5154}
5155impl Deref for QosPeriCm0 {
5156 type Target = qos::RegisterBlock;
5157 #[inline(always)]
5158 fn deref(&self) -> &Self::Target {
5159 unsafe { &*Self::PTR }
5160 }
5161}
5162impl core::fmt::Debug for QosPeriCm0 {
5163 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5164 f.debug_struct("QosPeriCm0").finish()
5165 }
5166}
5167#[doc = "QoS Registers for PERI_CM0"]
5168pub use self::qos as qos_peri_cm0;
5169#[doc = "QoS Registers for PMU_CM0"]
5170pub struct QosPmuCm0 {
5171 _marker: PhantomData<*const ()>,
5172}
5173unsafe impl Send for QosPmuCm0 {}
5174impl QosPmuCm0 {
5175 #[doc = r"Pointer to the register block"]
5176 pub const PTR: *const qos::RegisterBlock = 0xffa6_8000 as *const _;
5177 #[doc = r"Return the pointer to the register block"]
5178 #[inline(always)]
5179 pub const fn ptr() -> *const qos::RegisterBlock {
5180 Self::PTR
5181 }
5182 #[doc = r" Steal an instance of this peripheral"]
5183 #[doc = r""]
5184 #[doc = r" # Safety"]
5185 #[doc = r""]
5186 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5187 #[doc = r" that may race with any existing instances, for example by only"]
5188 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5189 #[doc = r" original peripheral and using critical sections to coordinate"]
5190 #[doc = r" access between multiple new instances."]
5191 #[doc = r""]
5192 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5193 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5194 #[doc = r" no stolen instances are passed to such software."]
5195 pub unsafe fn steal() -> Self {
5196 Self {
5197 _marker: PhantomData,
5198 }
5199 }
5200}
5201impl Deref for QosPmuCm0 {
5202 type Target = qos::RegisterBlock;
5203 #[inline(always)]
5204 fn deref(&self) -> &Self::Target {
5205 unsafe { &*Self::PTR }
5206 }
5207}
5208impl core::fmt::Debug for QosPmuCm0 {
5209 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5210 f.debug_struct("QosPmuCm0").finish()
5211 }
5212}
5213#[doc = "QoS Registers for PMU_CM0"]
5214pub use self::qos as qos_pmu_cm0;
5215#[doc = "QoS Registers for RGA_R"]
5216pub struct QosRgaR {
5217 _marker: PhantomData<*const ()>,
5218}
5219unsafe impl Send for QosRgaR {}
5220impl QosRgaR {
5221 #[doc = r"Pointer to the register block"]
5222 pub const PTR: *const qos::RegisterBlock = 0xffab_0000 as *const _;
5223 #[doc = r"Return the pointer to the register block"]
5224 #[inline(always)]
5225 pub const fn ptr() -> *const qos::RegisterBlock {
5226 Self::PTR
5227 }
5228 #[doc = r" Steal an instance of this peripheral"]
5229 #[doc = r""]
5230 #[doc = r" # Safety"]
5231 #[doc = r""]
5232 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5233 #[doc = r" that may race with any existing instances, for example by only"]
5234 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5235 #[doc = r" original peripheral and using critical sections to coordinate"]
5236 #[doc = r" access between multiple new instances."]
5237 #[doc = r""]
5238 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5239 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5240 #[doc = r" no stolen instances are passed to such software."]
5241 pub unsafe fn steal() -> Self {
5242 Self {
5243 _marker: PhantomData,
5244 }
5245 }
5246}
5247impl Deref for QosRgaR {
5248 type Target = qos::RegisterBlock;
5249 #[inline(always)]
5250 fn deref(&self) -> &Self::Target {
5251 unsafe { &*Self::PTR }
5252 }
5253}
5254impl core::fmt::Debug for QosRgaR {
5255 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5256 f.debug_struct("QosRgaR").finish()
5257 }
5258}
5259#[doc = "QoS Registers for RGA_R"]
5260pub use self::qos as qos_rga_r;
5261#[doc = "QoS Registers for RGA_W"]
5262pub struct QosRgaW {
5263 _marker: PhantomData<*const ()>,
5264}
5265unsafe impl Send for QosRgaW {}
5266impl QosRgaW {
5267 #[doc = r"Pointer to the register block"]
5268 pub const PTR: *const qos::RegisterBlock = 0xffab_0080 as *const _;
5269 #[doc = r"Return the pointer to the register block"]
5270 #[inline(always)]
5271 pub const fn ptr() -> *const qos::RegisterBlock {
5272 Self::PTR
5273 }
5274 #[doc = r" Steal an instance of this peripheral"]
5275 #[doc = r""]
5276 #[doc = r" # Safety"]
5277 #[doc = r""]
5278 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5279 #[doc = r" that may race with any existing instances, for example by only"]
5280 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5281 #[doc = r" original peripheral and using critical sections to coordinate"]
5282 #[doc = r" access between multiple new instances."]
5283 #[doc = r""]
5284 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5285 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5286 #[doc = r" no stolen instances are passed to such software."]
5287 pub unsafe fn steal() -> Self {
5288 Self {
5289 _marker: PhantomData,
5290 }
5291 }
5292}
5293impl Deref for QosRgaW {
5294 type Target = qos::RegisterBlock;
5295 #[inline(always)]
5296 fn deref(&self) -> &Self::Target {
5297 unsafe { &*Self::PTR }
5298 }
5299}
5300impl core::fmt::Debug for QosRgaW {
5301 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5302 f.debug_struct("QosRgaW").finish()
5303 }
5304}
5305#[doc = "QoS Registers for RGA_W"]
5306pub use self::qos as qos_rga_w;
5307#[doc = "QoS Registers for SDIO"]
5308pub struct QosSdio {
5309 _marker: PhantomData<*const ()>,
5310}
5311unsafe impl Send for QosSdio {}
5312impl QosSdio {
5313 #[doc = r"Pointer to the register block"]
5314 pub const PTR: *const qos::RegisterBlock = 0xffa7_6000 as *const _;
5315 #[doc = r"Return the pointer to the register block"]
5316 #[inline(always)]
5317 pub const fn ptr() -> *const qos::RegisterBlock {
5318 Self::PTR
5319 }
5320 #[doc = r" Steal an instance of this peripheral"]
5321 #[doc = r""]
5322 #[doc = r" # Safety"]
5323 #[doc = r""]
5324 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5325 #[doc = r" that may race with any existing instances, for example by only"]
5326 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5327 #[doc = r" original peripheral and using critical sections to coordinate"]
5328 #[doc = r" access between multiple new instances."]
5329 #[doc = r""]
5330 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5331 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5332 #[doc = r" no stolen instances are passed to such software."]
5333 pub unsafe fn steal() -> Self {
5334 Self {
5335 _marker: PhantomData,
5336 }
5337 }
5338}
5339impl Deref for QosSdio {
5340 type Target = qos::RegisterBlock;
5341 #[inline(always)]
5342 fn deref(&self) -> &Self::Target {
5343 unsafe { &*Self::PTR }
5344 }
5345}
5346impl core::fmt::Debug for QosSdio {
5347 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5348 f.debug_struct("QosSdio").finish()
5349 }
5350}
5351#[doc = "QoS Registers for SDIO"]
5352pub use self::qos as qos_sdio;
5353#[doc = "QoS Registers for SDMMC"]
5354pub struct QosSdmmc {
5355 _marker: PhantomData<*const ()>,
5356}
5357unsafe impl Send for QosSdmmc {}
5358impl QosSdmmc {
5359 #[doc = r"Pointer to the register block"]
5360 pub const PTR: *const qos::RegisterBlock = 0xffa7_4000 as *const _;
5361 #[doc = r"Return the pointer to the register block"]
5362 #[inline(always)]
5363 pub const fn ptr() -> *const qos::RegisterBlock {
5364 Self::PTR
5365 }
5366 #[doc = r" Steal an instance of this peripheral"]
5367 #[doc = r""]
5368 #[doc = r" # Safety"]
5369 #[doc = r""]
5370 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5371 #[doc = r" that may race with any existing instances, for example by only"]
5372 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5373 #[doc = r" original peripheral and using critical sections to coordinate"]
5374 #[doc = r" access between multiple new instances."]
5375 #[doc = r""]
5376 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5377 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5378 #[doc = r" no stolen instances are passed to such software."]
5379 pub unsafe fn steal() -> Self {
5380 Self {
5381 _marker: PhantomData,
5382 }
5383 }
5384}
5385impl Deref for QosSdmmc {
5386 type Target = qos::RegisterBlock;
5387 #[inline(always)]
5388 fn deref(&self) -> &Self::Target {
5389 unsafe { &*Self::PTR }
5390 }
5391}
5392impl core::fmt::Debug for QosSdmmc {
5393 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5394 f.debug_struct("QosSdmmc").finish()
5395 }
5396}
5397#[doc = "QoS Registers for SDMMC"]
5398pub use self::qos as qos_sdmmc;
5399#[doc = "QoS Registers for USB_HOST0"]
5400pub struct QosUsbHost0 {
5401 _marker: PhantomData<*const ()>,
5402}
5403unsafe impl Send for QosUsbHost0 {}
5404impl QosUsbHost0 {
5405 #[doc = r"Pointer to the register block"]
5406 pub const PTR: *const qos::RegisterBlock = 0xffa6_0100 as *const _;
5407 #[doc = r"Return the pointer to the register block"]
5408 #[inline(always)]
5409 pub const fn ptr() -> *const qos::RegisterBlock {
5410 Self::PTR
5411 }
5412 #[doc = r" Steal an instance of this peripheral"]
5413 #[doc = r""]
5414 #[doc = r" # Safety"]
5415 #[doc = r""]
5416 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5417 #[doc = r" that may race with any existing instances, for example by only"]
5418 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5419 #[doc = r" original peripheral and using critical sections to coordinate"]
5420 #[doc = r" access between multiple new instances."]
5421 #[doc = r""]
5422 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5423 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5424 #[doc = r" no stolen instances are passed to such software."]
5425 pub unsafe fn steal() -> Self {
5426 Self {
5427 _marker: PhantomData,
5428 }
5429 }
5430}
5431impl Deref for QosUsbHost0 {
5432 type Target = qos::RegisterBlock;
5433 #[inline(always)]
5434 fn deref(&self) -> &Self::Target {
5435 unsafe { &*Self::PTR }
5436 }
5437}
5438impl core::fmt::Debug for QosUsbHost0 {
5439 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5440 f.debug_struct("QosUsbHost0").finish()
5441 }
5442}
5443#[doc = "QoS Registers for USB_HOST0"]
5444pub use self::qos as qos_usb_host0;
5445#[doc = "QoS Registers for USB_HOST1"]
5446pub struct QosUsbHost1 {
5447 _marker: PhantomData<*const ()>,
5448}
5449unsafe impl Send for QosUsbHost1 {}
5450impl QosUsbHost1 {
5451 #[doc = r"Pointer to the register block"]
5452 pub const PTR: *const qos::RegisterBlock = 0xffa6_0180 as *const _;
5453 #[doc = r"Return the pointer to the register block"]
5454 #[inline(always)]
5455 pub const fn ptr() -> *const qos::RegisterBlock {
5456 Self::PTR
5457 }
5458 #[doc = r" Steal an instance of this peripheral"]
5459 #[doc = r""]
5460 #[doc = r" # Safety"]
5461 #[doc = r""]
5462 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5463 #[doc = r" that may race with any existing instances, for example by only"]
5464 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5465 #[doc = r" original peripheral and using critical sections to coordinate"]
5466 #[doc = r" access between multiple new instances."]
5467 #[doc = r""]
5468 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5469 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5470 #[doc = r" no stolen instances are passed to such software."]
5471 pub unsafe fn steal() -> Self {
5472 Self {
5473 _marker: PhantomData,
5474 }
5475 }
5476}
5477impl Deref for QosUsbHost1 {
5478 type Target = qos::RegisterBlock;
5479 #[inline(always)]
5480 fn deref(&self) -> &Self::Target {
5481 unsafe { &*Self::PTR }
5482 }
5483}
5484impl core::fmt::Debug for QosUsbHost1 {
5485 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5486 f.debug_struct("QosUsbHost1").finish()
5487 }
5488}
5489#[doc = "QoS Registers for USB_HOST1"]
5490pub use self::qos as qos_usb_host1;
5491#[doc = "QoS Registers for USB_OTG0"]
5492pub struct QosUsbOtg0 {
5493 _marker: PhantomData<*const ()>,
5494}
5495unsafe impl Send for QosUsbOtg0 {}
5496impl QosUsbOtg0 {
5497 #[doc = r"Pointer to the register block"]
5498 pub const PTR: *const qos::RegisterBlock = 0xffa7_0000 as *const _;
5499 #[doc = r"Return the pointer to the register block"]
5500 #[inline(always)]
5501 pub const fn ptr() -> *const qos::RegisterBlock {
5502 Self::PTR
5503 }
5504 #[doc = r" Steal an instance of this peripheral"]
5505 #[doc = r""]
5506 #[doc = r" # Safety"]
5507 #[doc = r""]
5508 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5509 #[doc = r" that may race with any existing instances, for example by only"]
5510 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5511 #[doc = r" original peripheral and using critical sections to coordinate"]
5512 #[doc = r" access between multiple new instances."]
5513 #[doc = r""]
5514 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5515 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5516 #[doc = r" no stolen instances are passed to such software."]
5517 pub unsafe fn steal() -> Self {
5518 Self {
5519 _marker: PhantomData,
5520 }
5521 }
5522}
5523impl Deref for QosUsbOtg0 {
5524 type Target = qos::RegisterBlock;
5525 #[inline(always)]
5526 fn deref(&self) -> &Self::Target {
5527 unsafe { &*Self::PTR }
5528 }
5529}
5530impl core::fmt::Debug for QosUsbOtg0 {
5531 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5532 f.debug_struct("QosUsbOtg0").finish()
5533 }
5534}
5535#[doc = "QoS Registers for USB_OTG0"]
5536pub use self::qos as qos_usb_otg0;
5537#[doc = "QoS Registers for USB_OTG1"]
5538pub struct QosUsbOtg1 {
5539 _marker: PhantomData<*const ()>,
5540}
5541unsafe impl Send for QosUsbOtg1 {}
5542impl QosUsbOtg1 {
5543 #[doc = r"Pointer to the register block"]
5544 pub const PTR: *const qos::RegisterBlock = 0xffa7_0080 as *const _;
5545 #[doc = r"Return the pointer to the register block"]
5546 #[inline(always)]
5547 pub const fn ptr() -> *const qos::RegisterBlock {
5548 Self::PTR
5549 }
5550 #[doc = r" Steal an instance of this peripheral"]
5551 #[doc = r""]
5552 #[doc = r" # Safety"]
5553 #[doc = r""]
5554 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5555 #[doc = r" that may race with any existing instances, for example by only"]
5556 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5557 #[doc = r" original peripheral and using critical sections to coordinate"]
5558 #[doc = r" access between multiple new instances."]
5559 #[doc = r""]
5560 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5561 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5562 #[doc = r" no stolen instances are passed to such software."]
5563 pub unsafe fn steal() -> Self {
5564 Self {
5565 _marker: PhantomData,
5566 }
5567 }
5568}
5569impl Deref for QosUsbOtg1 {
5570 type Target = qos::RegisterBlock;
5571 #[inline(always)]
5572 fn deref(&self) -> &Self::Target {
5573 unsafe { &*Self::PTR }
5574 }
5575}
5576impl core::fmt::Debug for QosUsbOtg1 {
5577 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5578 f.debug_struct("QosUsbOtg1").finish()
5579 }
5580}
5581#[doc = "QoS Registers for USB_OTG1"]
5582pub use self::qos as qos_usb_otg1;
5583#[doc = "QoS Registers for VIDEO_M0"]
5584pub struct QosVideoM0 {
5585 _marker: PhantomData<*const ()>,
5586}
5587unsafe impl Send for QosVideoM0 {}
5588impl QosVideoM0 {
5589 #[doc = r"Pointer to the register block"]
5590 pub const PTR: *const qos::RegisterBlock = 0xffab_8000 as *const _;
5591 #[doc = r"Return the pointer to the register block"]
5592 #[inline(always)]
5593 pub const fn ptr() -> *const qos::RegisterBlock {
5594 Self::PTR
5595 }
5596 #[doc = r" Steal an instance of this peripheral"]
5597 #[doc = r""]
5598 #[doc = r" # Safety"]
5599 #[doc = r""]
5600 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5601 #[doc = r" that may race with any existing instances, for example by only"]
5602 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5603 #[doc = r" original peripheral and using critical sections to coordinate"]
5604 #[doc = r" access between multiple new instances."]
5605 #[doc = r""]
5606 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5607 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5608 #[doc = r" no stolen instances are passed to such software."]
5609 pub unsafe fn steal() -> Self {
5610 Self {
5611 _marker: PhantomData,
5612 }
5613 }
5614}
5615impl Deref for QosVideoM0 {
5616 type Target = qos::RegisterBlock;
5617 #[inline(always)]
5618 fn deref(&self) -> &Self::Target {
5619 unsafe { &*Self::PTR }
5620 }
5621}
5622impl core::fmt::Debug for QosVideoM0 {
5623 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5624 f.debug_struct("QosVideoM0").finish()
5625 }
5626}
5627#[doc = "QoS Registers for VIDEO_M0"]
5628pub use self::qos as qos_video_m0;
5629#[doc = "QoS Registers for VIDEO_M1_R"]
5630pub struct QosVideoM1R {
5631 _marker: PhantomData<*const ()>,
5632}
5633unsafe impl Send for QosVideoM1R {}
5634impl QosVideoM1R {
5635 #[doc = r"Pointer to the register block"]
5636 pub const PTR: *const qos::RegisterBlock = 0xffac_0000 as *const _;
5637 #[doc = r"Return the pointer to the register block"]
5638 #[inline(always)]
5639 pub const fn ptr() -> *const qos::RegisterBlock {
5640 Self::PTR
5641 }
5642 #[doc = r" Steal an instance of this peripheral"]
5643 #[doc = r""]
5644 #[doc = r" # Safety"]
5645 #[doc = r""]
5646 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5647 #[doc = r" that may race with any existing instances, for example by only"]
5648 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5649 #[doc = r" original peripheral and using critical sections to coordinate"]
5650 #[doc = r" access between multiple new instances."]
5651 #[doc = r""]
5652 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5653 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5654 #[doc = r" no stolen instances are passed to such software."]
5655 pub unsafe fn steal() -> Self {
5656 Self {
5657 _marker: PhantomData,
5658 }
5659 }
5660}
5661impl Deref for QosVideoM1R {
5662 type Target = qos::RegisterBlock;
5663 #[inline(always)]
5664 fn deref(&self) -> &Self::Target {
5665 unsafe { &*Self::PTR }
5666 }
5667}
5668impl core::fmt::Debug for QosVideoM1R {
5669 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5670 f.debug_struct("QosVideoM1R").finish()
5671 }
5672}
5673#[doc = "QoS Registers for VIDEO_M1_R"]
5674pub use self::qos as qos_video_m1_r;
5675#[doc = "QoS Registers for VIDEO_M1_W"]
5676pub struct QosVideoM1W {
5677 _marker: PhantomData<*const ()>,
5678}
5679unsafe impl Send for QosVideoM1W {}
5680impl QosVideoM1W {
5681 #[doc = r"Pointer to the register block"]
5682 pub const PTR: *const qos::RegisterBlock = 0xffac_0080 as *const _;
5683 #[doc = r"Return the pointer to the register block"]
5684 #[inline(always)]
5685 pub const fn ptr() -> *const qos::RegisterBlock {
5686 Self::PTR
5687 }
5688 #[doc = r" Steal an instance of this peripheral"]
5689 #[doc = r""]
5690 #[doc = r" # Safety"]
5691 #[doc = r""]
5692 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5693 #[doc = r" that may race with any existing instances, for example by only"]
5694 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5695 #[doc = r" original peripheral and using critical sections to coordinate"]
5696 #[doc = r" access between multiple new instances."]
5697 #[doc = r""]
5698 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5699 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5700 #[doc = r" no stolen instances are passed to such software."]
5701 pub unsafe fn steal() -> Self {
5702 Self {
5703 _marker: PhantomData,
5704 }
5705 }
5706}
5707impl Deref for QosVideoM1W {
5708 type Target = qos::RegisterBlock;
5709 #[inline(always)]
5710 fn deref(&self) -> &Self::Target {
5711 unsafe { &*Self::PTR }
5712 }
5713}
5714impl core::fmt::Debug for QosVideoM1W {
5715 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5716 f.debug_struct("QosVideoM1W").finish()
5717 }
5718}
5719#[doc = "QoS Registers for VIDEO_M1_W"]
5720pub use self::qos as qos_video_m1_w;
5721#[doc = "QoS Registers for VOP-BIG_R"]
5722pub struct QosVopBigR {
5723 _marker: PhantomData<*const ()>,
5724}
5725unsafe impl Send for QosVopBigR {}
5726impl QosVopBigR {
5727 #[doc = r"Pointer to the register block"]
5728 pub const PTR: *const qos::RegisterBlock = 0xffac_8000 as *const _;
5729 #[doc = r"Return the pointer to the register block"]
5730 #[inline(always)]
5731 pub const fn ptr() -> *const qos::RegisterBlock {
5732 Self::PTR
5733 }
5734 #[doc = r" Steal an instance of this peripheral"]
5735 #[doc = r""]
5736 #[doc = r" # Safety"]
5737 #[doc = r""]
5738 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5739 #[doc = r" that may race with any existing instances, for example by only"]
5740 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5741 #[doc = r" original peripheral and using critical sections to coordinate"]
5742 #[doc = r" access between multiple new instances."]
5743 #[doc = r""]
5744 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5745 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5746 #[doc = r" no stolen instances are passed to such software."]
5747 pub unsafe fn steal() -> Self {
5748 Self {
5749 _marker: PhantomData,
5750 }
5751 }
5752}
5753impl Deref for QosVopBigR {
5754 type Target = qos::RegisterBlock;
5755 #[inline(always)]
5756 fn deref(&self) -> &Self::Target {
5757 unsafe { &*Self::PTR }
5758 }
5759}
5760impl core::fmt::Debug for QosVopBigR {
5761 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5762 f.debug_struct("QosVopBigR").finish()
5763 }
5764}
5765#[doc = "QoS Registers for VOP-BIG_R"]
5766pub use self::qos as qos_vop_big_r;
5767#[doc = "QoS Registers for VOP-BIG_W"]
5768pub struct QosVopBigW {
5769 _marker: PhantomData<*const ()>,
5770}
5771unsafe impl Send for QosVopBigW {}
5772impl QosVopBigW {
5773 #[doc = r"Pointer to the register block"]
5774 pub const PTR: *const qos::RegisterBlock = 0xffac_8080 as *const _;
5775 #[doc = r"Return the pointer to the register block"]
5776 #[inline(always)]
5777 pub const fn ptr() -> *const qos::RegisterBlock {
5778 Self::PTR
5779 }
5780 #[doc = r" Steal an instance of this peripheral"]
5781 #[doc = r""]
5782 #[doc = r" # Safety"]
5783 #[doc = r""]
5784 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5785 #[doc = r" that may race with any existing instances, for example by only"]
5786 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5787 #[doc = r" original peripheral and using critical sections to coordinate"]
5788 #[doc = r" access between multiple new instances."]
5789 #[doc = r""]
5790 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5791 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5792 #[doc = r" no stolen instances are passed to such software."]
5793 pub unsafe fn steal() -> Self {
5794 Self {
5795 _marker: PhantomData,
5796 }
5797 }
5798}
5799impl Deref for QosVopBigW {
5800 type Target = qos::RegisterBlock;
5801 #[inline(always)]
5802 fn deref(&self) -> &Self::Target {
5803 unsafe { &*Self::PTR }
5804 }
5805}
5806impl core::fmt::Debug for QosVopBigW {
5807 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5808 f.debug_struct("QosVopBigW").finish()
5809 }
5810}
5811#[doc = "QoS Registers for VOP-BIG_W"]
5812pub use self::qos as qos_vop_big_w;
5813#[doc = "QoS Registers for VOP-LITTLE"]
5814pub struct QosVopLittle {
5815 _marker: PhantomData<*const ()>,
5816}
5817unsafe impl Send for QosVopLittle {}
5818impl QosVopLittle {
5819 #[doc = r"Pointer to the register block"]
5820 pub const PTR: *const qos::RegisterBlock = 0xffad_0000 as *const _;
5821 #[doc = r"Return the pointer to the register block"]
5822 #[inline(always)]
5823 pub const fn ptr() -> *const qos::RegisterBlock {
5824 Self::PTR
5825 }
5826 #[doc = r" Steal an instance of this peripheral"]
5827 #[doc = r""]
5828 #[doc = r" # Safety"]
5829 #[doc = r""]
5830 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5831 #[doc = r" that may race with any existing instances, for example by only"]
5832 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5833 #[doc = r" original peripheral and using critical sections to coordinate"]
5834 #[doc = r" access between multiple new instances."]
5835 #[doc = r""]
5836 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5837 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5838 #[doc = r" no stolen instances are passed to such software."]
5839 pub unsafe fn steal() -> Self {
5840 Self {
5841 _marker: PhantomData,
5842 }
5843 }
5844}
5845impl Deref for QosVopLittle {
5846 type Target = qos::RegisterBlock;
5847 #[inline(always)]
5848 fn deref(&self) -> &Self::Target {
5849 unsafe { &*Self::PTR }
5850 }
5851}
5852impl core::fmt::Debug for QosVopLittle {
5853 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5854 f.debug_struct("QosVopLittle").finish()
5855 }
5856}
5857#[doc = "QoS Registers for VOP-LITTLE"]
5858pub use self::qos as qos_vop_little;
5859#[doc = "Rockchip Graphics Accelerator 2 (RGA2) Registers"]
5860pub struct Rga2 {
5861 _marker: PhantomData<*const ()>,
5862}
5863unsafe impl Send for Rga2 {}
5864impl Rga2 {
5865 #[doc = r"Pointer to the register block"]
5866 pub const PTR: *const rga2::RegisterBlock = 0xff68_0000 as *const _;
5867 #[doc = r"Return the pointer to the register block"]
5868 #[inline(always)]
5869 pub const fn ptr() -> *const rga2::RegisterBlock {
5870 Self::PTR
5871 }
5872 #[doc = r" Steal an instance of this peripheral"]
5873 #[doc = r""]
5874 #[doc = r" # Safety"]
5875 #[doc = r""]
5876 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5877 #[doc = r" that may race with any existing instances, for example by only"]
5878 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5879 #[doc = r" original peripheral and using critical sections to coordinate"]
5880 #[doc = r" access between multiple new instances."]
5881 #[doc = r""]
5882 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5883 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5884 #[doc = r" no stolen instances are passed to such software."]
5885 pub unsafe fn steal() -> Self {
5886 Self {
5887 _marker: PhantomData,
5888 }
5889 }
5890}
5891impl Deref for Rga2 {
5892 type Target = rga2::RegisterBlock;
5893 #[inline(always)]
5894 fn deref(&self) -> &Self::Target {
5895 unsafe { &*Self::PTR }
5896 }
5897}
5898impl core::fmt::Debug for Rga2 {
5899 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5900 f.debug_struct("Rga2").finish()
5901 }
5902}
5903#[doc = "Rockchip Graphics Accelerator 2 (RGA2) Registers"]
5904pub mod rga2;
5905#[doc = "Rockchip Inter-Integrated Circuit (RKI2C) Registers"]
5906pub struct Rki2c {
5907 _marker: PhantomData<*const ()>,
5908}
5909unsafe impl Send for Rki2c {}
5910impl Rki2c {
5911 #[doc = r"Pointer to the register block"]
5912 pub const PTR: *const rki2c::RegisterBlock = 0xff3c_0000 as *const _;
5913 #[doc = r"Return the pointer to the register block"]
5914 #[inline(always)]
5915 pub const fn ptr() -> *const rki2c::RegisterBlock {
5916 Self::PTR
5917 }
5918 #[doc = r" Steal an instance of this peripheral"]
5919 #[doc = r""]
5920 #[doc = r" # Safety"]
5921 #[doc = r""]
5922 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5923 #[doc = r" that may race with any existing instances, for example by only"]
5924 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5925 #[doc = r" original peripheral and using critical sections to coordinate"]
5926 #[doc = r" access between multiple new instances."]
5927 #[doc = r""]
5928 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5929 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5930 #[doc = r" no stolen instances are passed to such software."]
5931 pub unsafe fn steal() -> Self {
5932 Self {
5933 _marker: PhantomData,
5934 }
5935 }
5936}
5937impl Deref for Rki2c {
5938 type Target = rki2c::RegisterBlock;
5939 #[inline(always)]
5940 fn deref(&self) -> &Self::Target {
5941 unsafe { &*Self::PTR }
5942 }
5943}
5944impl core::fmt::Debug for Rki2c {
5945 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5946 f.debug_struct("Rki2c").finish()
5947 }
5948}
5949#[doc = "Rockchip Inter-Integrated Circuit (RKI2C) Registers"]
5950pub mod rki2c;
5951#[doc = "Rockchip Inter-Integrated Circuit (RKI2C) 0 Registers"]
5952pub struct Rki2c0 {
5953 _marker: PhantomData<*const ()>,
5954}
5955unsafe impl Send for Rki2c0 {}
5956impl Rki2c0 {
5957 #[doc = r"Pointer to the register block"]
5958 pub const PTR: *const rki2c::RegisterBlock = 0xff3c_0000 as *const _;
5959 #[doc = r"Return the pointer to the register block"]
5960 #[inline(always)]
5961 pub const fn ptr() -> *const rki2c::RegisterBlock {
5962 Self::PTR
5963 }
5964 #[doc = r" Steal an instance of this peripheral"]
5965 #[doc = r""]
5966 #[doc = r" # Safety"]
5967 #[doc = r""]
5968 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
5969 #[doc = r" that may race with any existing instances, for example by only"]
5970 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
5971 #[doc = r" original peripheral and using critical sections to coordinate"]
5972 #[doc = r" access between multiple new instances."]
5973 #[doc = r""]
5974 #[doc = r" Additionally, other software such as HALs may rely on only one"]
5975 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
5976 #[doc = r" no stolen instances are passed to such software."]
5977 pub unsafe fn steal() -> Self {
5978 Self {
5979 _marker: PhantomData,
5980 }
5981 }
5982}
5983impl Deref for Rki2c0 {
5984 type Target = rki2c::RegisterBlock;
5985 #[inline(always)]
5986 fn deref(&self) -> &Self::Target {
5987 unsafe { &*Self::PTR }
5988 }
5989}
5990impl core::fmt::Debug for Rki2c0 {
5991 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5992 f.debug_struct("Rki2c0").finish()
5993 }
5994}
5995#[doc = "Rockchip Inter-Integrated Circuit (RKI2C) 0 Registers"]
5996pub use self::rki2c as rki2c0;
5997#[doc = "Rockchip Inter-Integrated Circuit (RKI2C) 1 Registers"]
5998pub struct Rki2c1 {
5999 _marker: PhantomData<*const ()>,
6000}
6001unsafe impl Send for Rki2c1 {}
6002impl Rki2c1 {
6003 #[doc = r"Pointer to the register block"]
6004 pub const PTR: *const rki2c::RegisterBlock = 0xff11_0000 as *const _;
6005 #[doc = r"Return the pointer to the register block"]
6006 #[inline(always)]
6007 pub const fn ptr() -> *const rki2c::RegisterBlock {
6008 Self::PTR
6009 }
6010 #[doc = r" Steal an instance of this peripheral"]
6011 #[doc = r""]
6012 #[doc = r" # Safety"]
6013 #[doc = r""]
6014 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6015 #[doc = r" that may race with any existing instances, for example by only"]
6016 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6017 #[doc = r" original peripheral and using critical sections to coordinate"]
6018 #[doc = r" access between multiple new instances."]
6019 #[doc = r""]
6020 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6021 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6022 #[doc = r" no stolen instances are passed to such software."]
6023 pub unsafe fn steal() -> Self {
6024 Self {
6025 _marker: PhantomData,
6026 }
6027 }
6028}
6029impl Deref for Rki2c1 {
6030 type Target = rki2c::RegisterBlock;
6031 #[inline(always)]
6032 fn deref(&self) -> &Self::Target {
6033 unsafe { &*Self::PTR }
6034 }
6035}
6036impl core::fmt::Debug for Rki2c1 {
6037 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6038 f.debug_struct("Rki2c1").finish()
6039 }
6040}
6041#[doc = "Rockchip Inter-Integrated Circuit (RKI2C) 1 Registers"]
6042pub use self::rki2c as rki2c1;
6043#[doc = "Rockchip Inter-Integrated Circuit (RKI2C) 2 Registers"]
6044pub struct Rki2c2 {
6045 _marker: PhantomData<*const ()>,
6046}
6047unsafe impl Send for Rki2c2 {}
6048impl Rki2c2 {
6049 #[doc = r"Pointer to the register block"]
6050 pub const PTR: *const rki2c::RegisterBlock = 0xff12_0000 as *const _;
6051 #[doc = r"Return the pointer to the register block"]
6052 #[inline(always)]
6053 pub const fn ptr() -> *const rki2c::RegisterBlock {
6054 Self::PTR
6055 }
6056 #[doc = r" Steal an instance of this peripheral"]
6057 #[doc = r""]
6058 #[doc = r" # Safety"]
6059 #[doc = r""]
6060 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6061 #[doc = r" that may race with any existing instances, for example by only"]
6062 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6063 #[doc = r" original peripheral and using critical sections to coordinate"]
6064 #[doc = r" access between multiple new instances."]
6065 #[doc = r""]
6066 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6067 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6068 #[doc = r" no stolen instances are passed to such software."]
6069 pub unsafe fn steal() -> Self {
6070 Self {
6071 _marker: PhantomData,
6072 }
6073 }
6074}
6075impl Deref for Rki2c2 {
6076 type Target = rki2c::RegisterBlock;
6077 #[inline(always)]
6078 fn deref(&self) -> &Self::Target {
6079 unsafe { &*Self::PTR }
6080 }
6081}
6082impl core::fmt::Debug for Rki2c2 {
6083 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6084 f.debug_struct("Rki2c2").finish()
6085 }
6086}
6087#[doc = "Rockchip Inter-Integrated Circuit (RKI2C) 2 Registers"]
6088pub use self::rki2c as rki2c2;
6089#[doc = "Rockchip Inter-Integrated Circuit (RKI2C) 3 Registers"]
6090pub struct Rki2c3 {
6091 _marker: PhantomData<*const ()>,
6092}
6093unsafe impl Send for Rki2c3 {}
6094impl Rki2c3 {
6095 #[doc = r"Pointer to the register block"]
6096 pub const PTR: *const rki2c::RegisterBlock = 0xff13_0000 as *const _;
6097 #[doc = r"Return the pointer to the register block"]
6098 #[inline(always)]
6099 pub const fn ptr() -> *const rki2c::RegisterBlock {
6100 Self::PTR
6101 }
6102 #[doc = r" Steal an instance of this peripheral"]
6103 #[doc = r""]
6104 #[doc = r" # Safety"]
6105 #[doc = r""]
6106 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6107 #[doc = r" that may race with any existing instances, for example by only"]
6108 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6109 #[doc = r" original peripheral and using critical sections to coordinate"]
6110 #[doc = r" access between multiple new instances."]
6111 #[doc = r""]
6112 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6113 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6114 #[doc = r" no stolen instances are passed to such software."]
6115 pub unsafe fn steal() -> Self {
6116 Self {
6117 _marker: PhantomData,
6118 }
6119 }
6120}
6121impl Deref for Rki2c3 {
6122 type Target = rki2c::RegisterBlock;
6123 #[inline(always)]
6124 fn deref(&self) -> &Self::Target {
6125 unsafe { &*Self::PTR }
6126 }
6127}
6128impl core::fmt::Debug for Rki2c3 {
6129 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6130 f.debug_struct("Rki2c3").finish()
6131 }
6132}
6133#[doc = "Rockchip Inter-Integrated Circuit (RKI2C) 3 Registers"]
6134pub use self::rki2c as rki2c3;
6135#[doc = "Rockchip Inter-Integrated Circuit (RKI2C) 4 Registers"]
6136pub struct Rki2c4 {
6137 _marker: PhantomData<*const ()>,
6138}
6139unsafe impl Send for Rki2c4 {}
6140impl Rki2c4 {
6141 #[doc = r"Pointer to the register block"]
6142 pub const PTR: *const rki2c::RegisterBlock = 0xff3d_0000 as *const _;
6143 #[doc = r"Return the pointer to the register block"]
6144 #[inline(always)]
6145 pub const fn ptr() -> *const rki2c::RegisterBlock {
6146 Self::PTR
6147 }
6148 #[doc = r" Steal an instance of this peripheral"]
6149 #[doc = r""]
6150 #[doc = r" # Safety"]
6151 #[doc = r""]
6152 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6153 #[doc = r" that may race with any existing instances, for example by only"]
6154 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6155 #[doc = r" original peripheral and using critical sections to coordinate"]
6156 #[doc = r" access between multiple new instances."]
6157 #[doc = r""]
6158 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6159 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6160 #[doc = r" no stolen instances are passed to such software."]
6161 pub unsafe fn steal() -> Self {
6162 Self {
6163 _marker: PhantomData,
6164 }
6165 }
6166}
6167impl Deref for Rki2c4 {
6168 type Target = rki2c::RegisterBlock;
6169 #[inline(always)]
6170 fn deref(&self) -> &Self::Target {
6171 unsafe { &*Self::PTR }
6172 }
6173}
6174impl core::fmt::Debug for Rki2c4 {
6175 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6176 f.debug_struct("Rki2c4").finish()
6177 }
6178}
6179#[doc = "Rockchip Inter-Integrated Circuit (RKI2C) 4 Registers"]
6180pub use self::rki2c as rki2c4;
6181#[doc = "Rockchip Inter-Integrated Circuit (RKI2C) 5 Registers"]
6182pub struct Rki2c5 {
6183 _marker: PhantomData<*const ()>,
6184}
6185unsafe impl Send for Rki2c5 {}
6186impl Rki2c5 {
6187 #[doc = r"Pointer to the register block"]
6188 pub const PTR: *const rki2c::RegisterBlock = 0xff14_0000 as *const _;
6189 #[doc = r"Return the pointer to the register block"]
6190 #[inline(always)]
6191 pub const fn ptr() -> *const rki2c::RegisterBlock {
6192 Self::PTR
6193 }
6194 #[doc = r" Steal an instance of this peripheral"]
6195 #[doc = r""]
6196 #[doc = r" # Safety"]
6197 #[doc = r""]
6198 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6199 #[doc = r" that may race with any existing instances, for example by only"]
6200 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6201 #[doc = r" original peripheral and using critical sections to coordinate"]
6202 #[doc = r" access between multiple new instances."]
6203 #[doc = r""]
6204 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6205 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6206 #[doc = r" no stolen instances are passed to such software."]
6207 pub unsafe fn steal() -> Self {
6208 Self {
6209 _marker: PhantomData,
6210 }
6211 }
6212}
6213impl Deref for Rki2c5 {
6214 type Target = rki2c::RegisterBlock;
6215 #[inline(always)]
6216 fn deref(&self) -> &Self::Target {
6217 unsafe { &*Self::PTR }
6218 }
6219}
6220impl core::fmt::Debug for Rki2c5 {
6221 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6222 f.debug_struct("Rki2c5").finish()
6223 }
6224}
6225#[doc = "Rockchip Inter-Integrated Circuit (RKI2C) 5 Registers"]
6226pub use self::rki2c as rki2c5;
6227#[doc = "Rockchip Inter-Integrated Circuit (RKI2C) 6 Registers"]
6228pub struct Rki2c6 {
6229 _marker: PhantomData<*const ()>,
6230}
6231unsafe impl Send for Rki2c6 {}
6232impl Rki2c6 {
6233 #[doc = r"Pointer to the register block"]
6234 pub const PTR: *const rki2c::RegisterBlock = 0xff15_0000 as *const _;
6235 #[doc = r"Return the pointer to the register block"]
6236 #[inline(always)]
6237 pub const fn ptr() -> *const rki2c::RegisterBlock {
6238 Self::PTR
6239 }
6240 #[doc = r" Steal an instance of this peripheral"]
6241 #[doc = r""]
6242 #[doc = r" # Safety"]
6243 #[doc = r""]
6244 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6245 #[doc = r" that may race with any existing instances, for example by only"]
6246 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6247 #[doc = r" original peripheral and using critical sections to coordinate"]
6248 #[doc = r" access between multiple new instances."]
6249 #[doc = r""]
6250 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6251 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6252 #[doc = r" no stolen instances are passed to such software."]
6253 pub unsafe fn steal() -> Self {
6254 Self {
6255 _marker: PhantomData,
6256 }
6257 }
6258}
6259impl Deref for Rki2c6 {
6260 type Target = rki2c::RegisterBlock;
6261 #[inline(always)]
6262 fn deref(&self) -> &Self::Target {
6263 unsafe { &*Self::PTR }
6264 }
6265}
6266impl core::fmt::Debug for Rki2c6 {
6267 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6268 f.debug_struct("Rki2c6").finish()
6269 }
6270}
6271#[doc = "Rockchip Inter-Integrated Circuit (RKI2C) 6 Registers"]
6272pub use self::rki2c as rki2c6;
6273#[doc = "Rockchip Inter-Integrated Circuit (RKI2C) 7 Registers"]
6274pub struct Rki2c7 {
6275 _marker: PhantomData<*const ()>,
6276}
6277unsafe impl Send for Rki2c7 {}
6278impl Rki2c7 {
6279 #[doc = r"Pointer to the register block"]
6280 pub const PTR: *const rki2c::RegisterBlock = 0xff16_0000 as *const _;
6281 #[doc = r"Return the pointer to the register block"]
6282 #[inline(always)]
6283 pub const fn ptr() -> *const rki2c::RegisterBlock {
6284 Self::PTR
6285 }
6286 #[doc = r" Steal an instance of this peripheral"]
6287 #[doc = r""]
6288 #[doc = r" # Safety"]
6289 #[doc = r""]
6290 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6291 #[doc = r" that may race with any existing instances, for example by only"]
6292 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6293 #[doc = r" original peripheral and using critical sections to coordinate"]
6294 #[doc = r" access between multiple new instances."]
6295 #[doc = r""]
6296 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6297 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6298 #[doc = r" no stolen instances are passed to such software."]
6299 pub unsafe fn steal() -> Self {
6300 Self {
6301 _marker: PhantomData,
6302 }
6303 }
6304}
6305impl Deref for Rki2c7 {
6306 type Target = rki2c::RegisterBlock;
6307 #[inline(always)]
6308 fn deref(&self) -> &Self::Target {
6309 unsafe { &*Self::PTR }
6310 }
6311}
6312impl core::fmt::Debug for Rki2c7 {
6313 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6314 f.debug_struct("Rki2c7").finish()
6315 }
6316}
6317#[doc = "Rockchip Inter-Integrated Circuit (RKI2C) 7 Registers"]
6318pub use self::rki2c as rki2c7;
6319#[doc = "Rockchip Inter-Integrated Circuit (RKI2C) 8 Registers"]
6320pub struct Rki2c8 {
6321 _marker: PhantomData<*const ()>,
6322}
6323unsafe impl Send for Rki2c8 {}
6324impl Rki2c8 {
6325 #[doc = r"Pointer to the register block"]
6326 pub const PTR: *const rki2c::RegisterBlock = 0xff3e_0000 as *const _;
6327 #[doc = r"Return the pointer to the register block"]
6328 #[inline(always)]
6329 pub const fn ptr() -> *const rki2c::RegisterBlock {
6330 Self::PTR
6331 }
6332 #[doc = r" Steal an instance of this peripheral"]
6333 #[doc = r""]
6334 #[doc = r" # Safety"]
6335 #[doc = r""]
6336 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6337 #[doc = r" that may race with any existing instances, for example by only"]
6338 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6339 #[doc = r" original peripheral and using critical sections to coordinate"]
6340 #[doc = r" access between multiple new instances."]
6341 #[doc = r""]
6342 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6343 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6344 #[doc = r" no stolen instances are passed to such software."]
6345 pub unsafe fn steal() -> Self {
6346 Self {
6347 _marker: PhantomData,
6348 }
6349 }
6350}
6351impl Deref for Rki2c8 {
6352 type Target = rki2c::RegisterBlock;
6353 #[inline(always)]
6354 fn deref(&self) -> &Self::Target {
6355 unsafe { &*Self::PTR }
6356 }
6357}
6358impl core::fmt::Debug for Rki2c8 {
6359 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6360 f.debug_struct("Rki2c8").finish()
6361 }
6362}
6363#[doc = "Rockchip Inter-Integrated Circuit (RKI2C) 8 Registers"]
6364pub use self::rki2c as rki2c8;
6365#[doc = "Rockchip Video Decoder (RKVDEC) Registers"]
6366pub struct Rkvdec {
6367 _marker: PhantomData<*const ()>,
6368}
6369unsafe impl Send for Rkvdec {}
6370impl Rkvdec {
6371 #[doc = r"Pointer to the register block"]
6372 pub const PTR: *const rkvdec::RegisterBlock = 0xff66_0000 as *const _;
6373 #[doc = r"Return the pointer to the register block"]
6374 #[inline(always)]
6375 pub const fn ptr() -> *const rkvdec::RegisterBlock {
6376 Self::PTR
6377 }
6378 #[doc = r" Steal an instance of this peripheral"]
6379 #[doc = r""]
6380 #[doc = r" # Safety"]
6381 #[doc = r""]
6382 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6383 #[doc = r" that may race with any existing instances, for example by only"]
6384 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6385 #[doc = r" original peripheral and using critical sections to coordinate"]
6386 #[doc = r" access between multiple new instances."]
6387 #[doc = r""]
6388 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6389 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6390 #[doc = r" no stolen instances are passed to such software."]
6391 pub unsafe fn steal() -> Self {
6392 Self {
6393 _marker: PhantomData,
6394 }
6395 }
6396}
6397impl Deref for Rkvdec {
6398 type Target = rkvdec::RegisterBlock;
6399 #[inline(always)]
6400 fn deref(&self) -> &Self::Target {
6401 unsafe { &*Self::PTR }
6402 }
6403}
6404impl core::fmt::Debug for Rkvdec {
6405 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6406 f.debug_struct("Rkvdec").finish()
6407 }
6408}
6409#[doc = "Rockchip Video Decoder (RKVDEC) Registers"]
6410pub mod rkvdec;
6411#[doc = "Successive Approximation Register Analog-to-Digital Converter (SARADC) Registers"]
6412pub struct Saradc {
6413 _marker: PhantomData<*const ()>,
6414}
6415unsafe impl Send for Saradc {}
6416impl Saradc {
6417 #[doc = r"Pointer to the register block"]
6418 pub const PTR: *const saradc::RegisterBlock = 0xff10_0000 as *const _;
6419 #[doc = r"Return the pointer to the register block"]
6420 #[inline(always)]
6421 pub const fn ptr() -> *const saradc::RegisterBlock {
6422 Self::PTR
6423 }
6424 #[doc = r" Steal an instance of this peripheral"]
6425 #[doc = r""]
6426 #[doc = r" # Safety"]
6427 #[doc = r""]
6428 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6429 #[doc = r" that may race with any existing instances, for example by only"]
6430 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6431 #[doc = r" original peripheral and using critical sections to coordinate"]
6432 #[doc = r" access between multiple new instances."]
6433 #[doc = r""]
6434 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6435 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6436 #[doc = r" no stolen instances are passed to such software."]
6437 pub unsafe fn steal() -> Self {
6438 Self {
6439 _marker: PhantomData,
6440 }
6441 }
6442}
6443impl Deref for Saradc {
6444 type Target = saradc::RegisterBlock;
6445 #[inline(always)]
6446 fn deref(&self) -> &Self::Target {
6447 unsafe { &*Self::PTR }
6448 }
6449}
6450impl core::fmt::Debug for Saradc {
6451 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6452 f.debug_struct("Saradc").finish()
6453 }
6454}
6455#[doc = "Successive Approximation Register Analog-to-Digital Converter (SARADC) Registers"]
6456pub mod saradc;
6457#[doc = "Secure Digital MultiMedia Card (SDMMC) Registers"]
6458pub struct Sdmmc {
6459 _marker: PhantomData<*const ()>,
6460}
6461unsafe impl Send for Sdmmc {}
6462impl Sdmmc {
6463 #[doc = r"Pointer to the register block"]
6464 pub const PTR: *const sdmmc::RegisterBlock = 0xfe32_0000 as *const _;
6465 #[doc = r"Return the pointer to the register block"]
6466 #[inline(always)]
6467 pub const fn ptr() -> *const sdmmc::RegisterBlock {
6468 Self::PTR
6469 }
6470 #[doc = r" Steal an instance of this peripheral"]
6471 #[doc = r""]
6472 #[doc = r" # Safety"]
6473 #[doc = r""]
6474 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6475 #[doc = r" that may race with any existing instances, for example by only"]
6476 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6477 #[doc = r" original peripheral and using critical sections to coordinate"]
6478 #[doc = r" access between multiple new instances."]
6479 #[doc = r""]
6480 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6481 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6482 #[doc = r" no stolen instances are passed to such software."]
6483 pub unsafe fn steal() -> Self {
6484 Self {
6485 _marker: PhantomData,
6486 }
6487 }
6488}
6489impl Deref for Sdmmc {
6490 type Target = sdmmc::RegisterBlock;
6491 #[inline(always)]
6492 fn deref(&self) -> &Self::Target {
6493 unsafe { &*Self::PTR }
6494 }
6495}
6496impl core::fmt::Debug for Sdmmc {
6497 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6498 f.debug_struct("Sdmmc").finish()
6499 }
6500}
6501#[doc = "Secure Digital MultiMedia Card (SDMMC) Registers"]
6502pub mod sdmmc;
6503#[doc = "Sony/Philips Digital Interface (SPDIF) Registers"]
6504pub struct Spdif {
6505 _marker: PhantomData<*const ()>,
6506}
6507unsafe impl Send for Spdif {}
6508impl Spdif {
6509 #[doc = r"Pointer to the register block"]
6510 pub const PTR: *const spdif::RegisterBlock = 0xff87_0000 as *const _;
6511 #[doc = r"Return the pointer to the register block"]
6512 #[inline(always)]
6513 pub const fn ptr() -> *const spdif::RegisterBlock {
6514 Self::PTR
6515 }
6516 #[doc = r" Steal an instance of this peripheral"]
6517 #[doc = r""]
6518 #[doc = r" # Safety"]
6519 #[doc = r""]
6520 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6521 #[doc = r" that may race with any existing instances, for example by only"]
6522 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6523 #[doc = r" original peripheral and using critical sections to coordinate"]
6524 #[doc = r" access between multiple new instances."]
6525 #[doc = r""]
6526 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6527 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6528 #[doc = r" no stolen instances are passed to such software."]
6529 pub unsafe fn steal() -> Self {
6530 Self {
6531 _marker: PhantomData,
6532 }
6533 }
6534}
6535impl Deref for Spdif {
6536 type Target = spdif::RegisterBlock;
6537 #[inline(always)]
6538 fn deref(&self) -> &Self::Target {
6539 unsafe { &*Self::PTR }
6540 }
6541}
6542impl core::fmt::Debug for Spdif {
6543 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6544 f.debug_struct("Spdif").finish()
6545 }
6546}
6547#[doc = "Sony/Philips Digital Interface (SPDIF) Registers"]
6548pub mod spdif;
6549#[doc = "Serial Peripheral Interface (SPI) Registers"]
6550pub struct Spi {
6551 _marker: PhantomData<*const ()>,
6552}
6553unsafe impl Send for Spi {}
6554impl Spi {
6555 #[doc = r"Pointer to the register block"]
6556 pub const PTR: *const spi::RegisterBlock = 0xff1c_0000 as *const _;
6557 #[doc = r"Return the pointer to the register block"]
6558 #[inline(always)]
6559 pub const fn ptr() -> *const spi::RegisterBlock {
6560 Self::PTR
6561 }
6562 #[doc = r" Steal an instance of this peripheral"]
6563 #[doc = r""]
6564 #[doc = r" # Safety"]
6565 #[doc = r""]
6566 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6567 #[doc = r" that may race with any existing instances, for example by only"]
6568 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6569 #[doc = r" original peripheral and using critical sections to coordinate"]
6570 #[doc = r" access between multiple new instances."]
6571 #[doc = r""]
6572 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6573 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6574 #[doc = r" no stolen instances are passed to such software."]
6575 pub unsafe fn steal() -> Self {
6576 Self {
6577 _marker: PhantomData,
6578 }
6579 }
6580}
6581impl Deref for Spi {
6582 type Target = spi::RegisterBlock;
6583 #[inline(always)]
6584 fn deref(&self) -> &Self::Target {
6585 unsafe { &*Self::PTR }
6586 }
6587}
6588impl core::fmt::Debug for Spi {
6589 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6590 f.debug_struct("Spi").finish()
6591 }
6592}
6593#[doc = "Serial Peripheral Interface (SPI) Registers"]
6594pub mod spi;
6595#[doc = "Serial Peripheral Interface (SPI) 0 Registers"]
6596pub struct Spi0 {
6597 _marker: PhantomData<*const ()>,
6598}
6599unsafe impl Send for Spi0 {}
6600impl Spi0 {
6601 #[doc = r"Pointer to the register block"]
6602 pub const PTR: *const spi::RegisterBlock = 0xff1c_0000 as *const _;
6603 #[doc = r"Return the pointer to the register block"]
6604 #[inline(always)]
6605 pub const fn ptr() -> *const spi::RegisterBlock {
6606 Self::PTR
6607 }
6608 #[doc = r" Steal an instance of this peripheral"]
6609 #[doc = r""]
6610 #[doc = r" # Safety"]
6611 #[doc = r""]
6612 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6613 #[doc = r" that may race with any existing instances, for example by only"]
6614 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6615 #[doc = r" original peripheral and using critical sections to coordinate"]
6616 #[doc = r" access between multiple new instances."]
6617 #[doc = r""]
6618 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6619 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6620 #[doc = r" no stolen instances are passed to such software."]
6621 pub unsafe fn steal() -> Self {
6622 Self {
6623 _marker: PhantomData,
6624 }
6625 }
6626}
6627impl Deref for Spi0 {
6628 type Target = spi::RegisterBlock;
6629 #[inline(always)]
6630 fn deref(&self) -> &Self::Target {
6631 unsafe { &*Self::PTR }
6632 }
6633}
6634impl core::fmt::Debug for Spi0 {
6635 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6636 f.debug_struct("Spi0").finish()
6637 }
6638}
6639#[doc = "Serial Peripheral Interface (SPI) 0 Registers"]
6640pub use self::spi as spi0;
6641#[doc = "Serial Peripheral Interface (SPI) 1 Registers"]
6642pub struct Spi1 {
6643 _marker: PhantomData<*const ()>,
6644}
6645unsafe impl Send for Spi1 {}
6646impl Spi1 {
6647 #[doc = r"Pointer to the register block"]
6648 pub const PTR: *const spi::RegisterBlock = 0xff1d_0000 as *const _;
6649 #[doc = r"Return the pointer to the register block"]
6650 #[inline(always)]
6651 pub const fn ptr() -> *const spi::RegisterBlock {
6652 Self::PTR
6653 }
6654 #[doc = r" Steal an instance of this peripheral"]
6655 #[doc = r""]
6656 #[doc = r" # Safety"]
6657 #[doc = r""]
6658 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6659 #[doc = r" that may race with any existing instances, for example by only"]
6660 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6661 #[doc = r" original peripheral and using critical sections to coordinate"]
6662 #[doc = r" access between multiple new instances."]
6663 #[doc = r""]
6664 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6665 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6666 #[doc = r" no stolen instances are passed to such software."]
6667 pub unsafe fn steal() -> Self {
6668 Self {
6669 _marker: PhantomData,
6670 }
6671 }
6672}
6673impl Deref for Spi1 {
6674 type Target = spi::RegisterBlock;
6675 #[inline(always)]
6676 fn deref(&self) -> &Self::Target {
6677 unsafe { &*Self::PTR }
6678 }
6679}
6680impl core::fmt::Debug for Spi1 {
6681 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6682 f.debug_struct("Spi1").finish()
6683 }
6684}
6685#[doc = "Serial Peripheral Interface (SPI) 1 Registers"]
6686pub use self::spi as spi1;
6687#[doc = "Serial Peripheral Interface (SPI) 2 Registers"]
6688pub struct Spi2 {
6689 _marker: PhantomData<*const ()>,
6690}
6691unsafe impl Send for Spi2 {}
6692impl Spi2 {
6693 #[doc = r"Pointer to the register block"]
6694 pub const PTR: *const spi::RegisterBlock = 0xff1e_0000 as *const _;
6695 #[doc = r"Return the pointer to the register block"]
6696 #[inline(always)]
6697 pub const fn ptr() -> *const spi::RegisterBlock {
6698 Self::PTR
6699 }
6700 #[doc = r" Steal an instance of this peripheral"]
6701 #[doc = r""]
6702 #[doc = r" # Safety"]
6703 #[doc = r""]
6704 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6705 #[doc = r" that may race with any existing instances, for example by only"]
6706 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6707 #[doc = r" original peripheral and using critical sections to coordinate"]
6708 #[doc = r" access between multiple new instances."]
6709 #[doc = r""]
6710 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6711 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6712 #[doc = r" no stolen instances are passed to such software."]
6713 pub unsafe fn steal() -> Self {
6714 Self {
6715 _marker: PhantomData,
6716 }
6717 }
6718}
6719impl Deref for Spi2 {
6720 type Target = spi::RegisterBlock;
6721 #[inline(always)]
6722 fn deref(&self) -> &Self::Target {
6723 unsafe { &*Self::PTR }
6724 }
6725}
6726impl core::fmt::Debug for Spi2 {
6727 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6728 f.debug_struct("Spi2").finish()
6729 }
6730}
6731#[doc = "Serial Peripheral Interface (SPI) 2 Registers"]
6732pub use self::spi as spi2;
6733#[doc = "Serial Peripheral Interface (SPI) 3 Registers"]
6734pub struct Spi3 {
6735 _marker: PhantomData<*const ()>,
6736}
6737unsafe impl Send for Spi3 {}
6738impl Spi3 {
6739 #[doc = r"Pointer to the register block"]
6740 pub const PTR: *const spi::RegisterBlock = 0xff35_0000 as *const _;
6741 #[doc = r"Return the pointer to the register block"]
6742 #[inline(always)]
6743 pub const fn ptr() -> *const spi::RegisterBlock {
6744 Self::PTR
6745 }
6746 #[doc = r" Steal an instance of this peripheral"]
6747 #[doc = r""]
6748 #[doc = r" # Safety"]
6749 #[doc = r""]
6750 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6751 #[doc = r" that may race with any existing instances, for example by only"]
6752 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6753 #[doc = r" original peripheral and using critical sections to coordinate"]
6754 #[doc = r" access between multiple new instances."]
6755 #[doc = r""]
6756 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6757 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6758 #[doc = r" no stolen instances are passed to such software."]
6759 pub unsafe fn steal() -> Self {
6760 Self {
6761 _marker: PhantomData,
6762 }
6763 }
6764}
6765impl Deref for Spi3 {
6766 type Target = spi::RegisterBlock;
6767 #[inline(always)]
6768 fn deref(&self) -> &Self::Target {
6769 unsafe { &*Self::PTR }
6770 }
6771}
6772impl core::fmt::Debug for Spi3 {
6773 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6774 f.debug_struct("Spi3").finish()
6775 }
6776}
6777#[doc = "Serial Peripheral Interface (SPI) 3 Registers"]
6778pub use self::spi as spi3;
6779#[doc = "Serial Peripheral Interface (SPI) 4 Registers"]
6780pub struct Spi4 {
6781 _marker: PhantomData<*const ()>,
6782}
6783unsafe impl Send for Spi4 {}
6784impl Spi4 {
6785 #[doc = r"Pointer to the register block"]
6786 pub const PTR: *const spi::RegisterBlock = 0xff1f_0000 as *const _;
6787 #[doc = r"Return the pointer to the register block"]
6788 #[inline(always)]
6789 pub const fn ptr() -> *const spi::RegisterBlock {
6790 Self::PTR
6791 }
6792 #[doc = r" Steal an instance of this peripheral"]
6793 #[doc = r""]
6794 #[doc = r" # Safety"]
6795 #[doc = r""]
6796 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6797 #[doc = r" that may race with any existing instances, for example by only"]
6798 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6799 #[doc = r" original peripheral and using critical sections to coordinate"]
6800 #[doc = r" access between multiple new instances."]
6801 #[doc = r""]
6802 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6803 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6804 #[doc = r" no stolen instances are passed to such software."]
6805 pub unsafe fn steal() -> Self {
6806 Self {
6807 _marker: PhantomData,
6808 }
6809 }
6810}
6811impl Deref for Spi4 {
6812 type Target = spi::RegisterBlock;
6813 #[inline(always)]
6814 fn deref(&self) -> &Self::Target {
6815 unsafe { &*Self::PTR }
6816 }
6817}
6818impl core::fmt::Debug for Spi4 {
6819 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6820 f.debug_struct("Spi4").finish()
6821 }
6822}
6823#[doc = "Serial Peripheral Interface (SPI) 4 Registers"]
6824pub use self::spi as spi4;
6825#[doc = "Serial Peripheral Interface (SPI) 5 Registers"]
6826pub struct Spi5 {
6827 _marker: PhantomData<*const ()>,
6828}
6829unsafe impl Send for Spi5 {}
6830impl Spi5 {
6831 #[doc = r"Pointer to the register block"]
6832 pub const PTR: *const spi::RegisterBlock = 0xff20_0000 as *const _;
6833 #[doc = r"Return the pointer to the register block"]
6834 #[inline(always)]
6835 pub const fn ptr() -> *const spi::RegisterBlock {
6836 Self::PTR
6837 }
6838 #[doc = r" Steal an instance of this peripheral"]
6839 #[doc = r""]
6840 #[doc = r" # Safety"]
6841 #[doc = r""]
6842 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6843 #[doc = r" that may race with any existing instances, for example by only"]
6844 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6845 #[doc = r" original peripheral and using critical sections to coordinate"]
6846 #[doc = r" access between multiple new instances."]
6847 #[doc = r""]
6848 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6849 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6850 #[doc = r" no stolen instances are passed to such software."]
6851 pub unsafe fn steal() -> Self {
6852 Self {
6853 _marker: PhantomData,
6854 }
6855 }
6856}
6857impl Deref for Spi5 {
6858 type Target = spi::RegisterBlock;
6859 #[inline(always)]
6860 fn deref(&self) -> &Self::Target {
6861 unsafe { &*Self::PTR }
6862 }
6863}
6864impl core::fmt::Debug for Spi5 {
6865 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6866 f.debug_struct("Spi5").finish()
6867 }
6868}
6869#[doc = "Serial Peripheral Interface (SPI) 5 Registers"]
6870pub use self::spi as spi5;
6871#[doc = "Timer Registers"]
6872pub struct Timer {
6873 _marker: PhantomData<*const ()>,
6874}
6875unsafe impl Send for Timer {}
6876impl Timer {
6877 #[doc = r"Pointer to the register block"]
6878 pub const PTR: *const timer::RegisterBlock = 0xff85_0000 as *const _;
6879 #[doc = r"Return the pointer to the register block"]
6880 #[inline(always)]
6881 pub const fn ptr() -> *const timer::RegisterBlock {
6882 Self::PTR
6883 }
6884 #[doc = r" Steal an instance of this peripheral"]
6885 #[doc = r""]
6886 #[doc = r" # Safety"]
6887 #[doc = r""]
6888 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6889 #[doc = r" that may race with any existing instances, for example by only"]
6890 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6891 #[doc = r" original peripheral and using critical sections to coordinate"]
6892 #[doc = r" access between multiple new instances."]
6893 #[doc = r""]
6894 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6895 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6896 #[doc = r" no stolen instances are passed to such software."]
6897 pub unsafe fn steal() -> Self {
6898 Self {
6899 _marker: PhantomData,
6900 }
6901 }
6902}
6903impl Deref for Timer {
6904 type Target = timer::RegisterBlock;
6905 #[inline(always)]
6906 fn deref(&self) -> &Self::Target {
6907 unsafe { &*Self::PTR }
6908 }
6909}
6910impl core::fmt::Debug for Timer {
6911 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6912 f.debug_struct("Timer").finish()
6913 }
6914}
6915#[doc = "Timer Registers"]
6916pub mod timer;
6917#[doc = "Timer 0 Registers"]
6918pub struct Timer0 {
6919 _marker: PhantomData<*const ()>,
6920}
6921unsafe impl Send for Timer0 {}
6922impl Timer0 {
6923 #[doc = r"Pointer to the register block"]
6924 pub const PTR: *const timer::RegisterBlock = 0xff85_0000 as *const _;
6925 #[doc = r"Return the pointer to the register block"]
6926 #[inline(always)]
6927 pub const fn ptr() -> *const timer::RegisterBlock {
6928 Self::PTR
6929 }
6930 #[doc = r" Steal an instance of this peripheral"]
6931 #[doc = r""]
6932 #[doc = r" # Safety"]
6933 #[doc = r""]
6934 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6935 #[doc = r" that may race with any existing instances, for example by only"]
6936 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6937 #[doc = r" original peripheral and using critical sections to coordinate"]
6938 #[doc = r" access between multiple new instances."]
6939 #[doc = r""]
6940 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6941 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6942 #[doc = r" no stolen instances are passed to such software."]
6943 pub unsafe fn steal() -> Self {
6944 Self {
6945 _marker: PhantomData,
6946 }
6947 }
6948}
6949impl Deref for Timer0 {
6950 type Target = timer::RegisterBlock;
6951 #[inline(always)]
6952 fn deref(&self) -> &Self::Target {
6953 unsafe { &*Self::PTR }
6954 }
6955}
6956impl core::fmt::Debug for Timer0 {
6957 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6958 f.debug_struct("Timer0").finish()
6959 }
6960}
6961#[doc = "Timer 0 Registers"]
6962pub use self::timer as timer0;
6963#[doc = "Timer 1 Registers"]
6964pub struct Timer1 {
6965 _marker: PhantomData<*const ()>,
6966}
6967unsafe impl Send for Timer1 {}
6968impl Timer1 {
6969 #[doc = r"Pointer to the register block"]
6970 pub const PTR: *const timer::RegisterBlock = 0xff85_0020 as *const _;
6971 #[doc = r"Return the pointer to the register block"]
6972 #[inline(always)]
6973 pub const fn ptr() -> *const timer::RegisterBlock {
6974 Self::PTR
6975 }
6976 #[doc = r" Steal an instance of this peripheral"]
6977 #[doc = r""]
6978 #[doc = r" # Safety"]
6979 #[doc = r""]
6980 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
6981 #[doc = r" that may race with any existing instances, for example by only"]
6982 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
6983 #[doc = r" original peripheral and using critical sections to coordinate"]
6984 #[doc = r" access between multiple new instances."]
6985 #[doc = r""]
6986 #[doc = r" Additionally, other software such as HALs may rely on only one"]
6987 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
6988 #[doc = r" no stolen instances are passed to such software."]
6989 pub unsafe fn steal() -> Self {
6990 Self {
6991 _marker: PhantomData,
6992 }
6993 }
6994}
6995impl Deref for Timer1 {
6996 type Target = timer::RegisterBlock;
6997 #[inline(always)]
6998 fn deref(&self) -> &Self::Target {
6999 unsafe { &*Self::PTR }
7000 }
7001}
7002impl core::fmt::Debug for Timer1 {
7003 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7004 f.debug_struct("Timer1").finish()
7005 }
7006}
7007#[doc = "Timer 1 Registers"]
7008pub use self::timer as timer1;
7009#[doc = "Timer 10 Registers"]
7010pub struct Timer10 {
7011 _marker: PhantomData<*const ()>,
7012}
7013unsafe impl Send for Timer10 {}
7014impl Timer10 {
7015 #[doc = r"Pointer to the register block"]
7016 pub const PTR: *const timer::RegisterBlock = 0xff85_8080 as *const _;
7017 #[doc = r"Return the pointer to the register block"]
7018 #[inline(always)]
7019 pub const fn ptr() -> *const timer::RegisterBlock {
7020 Self::PTR
7021 }
7022 #[doc = r" Steal an instance of this peripheral"]
7023 #[doc = r""]
7024 #[doc = r" # Safety"]
7025 #[doc = r""]
7026 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7027 #[doc = r" that may race with any existing instances, for example by only"]
7028 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7029 #[doc = r" original peripheral and using critical sections to coordinate"]
7030 #[doc = r" access between multiple new instances."]
7031 #[doc = r""]
7032 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7033 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7034 #[doc = r" no stolen instances are passed to such software."]
7035 pub unsafe fn steal() -> Self {
7036 Self {
7037 _marker: PhantomData,
7038 }
7039 }
7040}
7041impl Deref for Timer10 {
7042 type Target = timer::RegisterBlock;
7043 #[inline(always)]
7044 fn deref(&self) -> &Self::Target {
7045 unsafe { &*Self::PTR }
7046 }
7047}
7048impl core::fmt::Debug for Timer10 {
7049 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7050 f.debug_struct("Timer10").finish()
7051 }
7052}
7053#[doc = "Timer 10 Registers"]
7054pub use self::timer as timer10;
7055#[doc = "Timer 11 Registers"]
7056pub struct Timer11 {
7057 _marker: PhantomData<*const ()>,
7058}
7059unsafe impl Send for Timer11 {}
7060impl Timer11 {
7061 #[doc = r"Pointer to the register block"]
7062 pub const PTR: *const timer::RegisterBlock = 0xff85_80a0 as *const _;
7063 #[doc = r"Return the pointer to the register block"]
7064 #[inline(always)]
7065 pub const fn ptr() -> *const timer::RegisterBlock {
7066 Self::PTR
7067 }
7068 #[doc = r" Steal an instance of this peripheral"]
7069 #[doc = r""]
7070 #[doc = r" # Safety"]
7071 #[doc = r""]
7072 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7073 #[doc = r" that may race with any existing instances, for example by only"]
7074 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7075 #[doc = r" original peripheral and using critical sections to coordinate"]
7076 #[doc = r" access between multiple new instances."]
7077 #[doc = r""]
7078 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7079 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7080 #[doc = r" no stolen instances are passed to such software."]
7081 pub unsafe fn steal() -> Self {
7082 Self {
7083 _marker: PhantomData,
7084 }
7085 }
7086}
7087impl Deref for Timer11 {
7088 type Target = timer::RegisterBlock;
7089 #[inline(always)]
7090 fn deref(&self) -> &Self::Target {
7091 unsafe { &*Self::PTR }
7092 }
7093}
7094impl core::fmt::Debug for Timer11 {
7095 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7096 f.debug_struct("Timer11").finish()
7097 }
7098}
7099#[doc = "Timer 11 Registers"]
7100pub use self::timer as timer11;
7101#[doc = "Timer 2 Registers"]
7102pub struct Timer2 {
7103 _marker: PhantomData<*const ()>,
7104}
7105unsafe impl Send for Timer2 {}
7106impl Timer2 {
7107 #[doc = r"Pointer to the register block"]
7108 pub const PTR: *const timer::RegisterBlock = 0xff85_0040 as *const _;
7109 #[doc = r"Return the pointer to the register block"]
7110 #[inline(always)]
7111 pub const fn ptr() -> *const timer::RegisterBlock {
7112 Self::PTR
7113 }
7114 #[doc = r" Steal an instance of this peripheral"]
7115 #[doc = r""]
7116 #[doc = r" # Safety"]
7117 #[doc = r""]
7118 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7119 #[doc = r" that may race with any existing instances, for example by only"]
7120 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7121 #[doc = r" original peripheral and using critical sections to coordinate"]
7122 #[doc = r" access between multiple new instances."]
7123 #[doc = r""]
7124 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7125 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7126 #[doc = r" no stolen instances are passed to such software."]
7127 pub unsafe fn steal() -> Self {
7128 Self {
7129 _marker: PhantomData,
7130 }
7131 }
7132}
7133impl Deref for Timer2 {
7134 type Target = timer::RegisterBlock;
7135 #[inline(always)]
7136 fn deref(&self) -> &Self::Target {
7137 unsafe { &*Self::PTR }
7138 }
7139}
7140impl core::fmt::Debug for Timer2 {
7141 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7142 f.debug_struct("Timer2").finish()
7143 }
7144}
7145#[doc = "Timer 2 Registers"]
7146pub use self::timer as timer2;
7147#[doc = "Timer 3 Registers"]
7148pub struct Timer3 {
7149 _marker: PhantomData<*const ()>,
7150}
7151unsafe impl Send for Timer3 {}
7152impl Timer3 {
7153 #[doc = r"Pointer to the register block"]
7154 pub const PTR: *const timer::RegisterBlock = 0xff85_0060 as *const _;
7155 #[doc = r"Return the pointer to the register block"]
7156 #[inline(always)]
7157 pub const fn ptr() -> *const timer::RegisterBlock {
7158 Self::PTR
7159 }
7160 #[doc = r" Steal an instance of this peripheral"]
7161 #[doc = r""]
7162 #[doc = r" # Safety"]
7163 #[doc = r""]
7164 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7165 #[doc = r" that may race with any existing instances, for example by only"]
7166 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7167 #[doc = r" original peripheral and using critical sections to coordinate"]
7168 #[doc = r" access between multiple new instances."]
7169 #[doc = r""]
7170 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7171 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7172 #[doc = r" no stolen instances are passed to such software."]
7173 pub unsafe fn steal() -> Self {
7174 Self {
7175 _marker: PhantomData,
7176 }
7177 }
7178}
7179impl Deref for Timer3 {
7180 type Target = timer::RegisterBlock;
7181 #[inline(always)]
7182 fn deref(&self) -> &Self::Target {
7183 unsafe { &*Self::PTR }
7184 }
7185}
7186impl core::fmt::Debug for Timer3 {
7187 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7188 f.debug_struct("Timer3").finish()
7189 }
7190}
7191#[doc = "Timer 3 Registers"]
7192pub use self::timer as timer3;
7193#[doc = "Timer 4 Registers"]
7194pub struct Timer4 {
7195 _marker: PhantomData<*const ()>,
7196}
7197unsafe impl Send for Timer4 {}
7198impl Timer4 {
7199 #[doc = r"Pointer to the register block"]
7200 pub const PTR: *const timer::RegisterBlock = 0xff85_0080 as *const _;
7201 #[doc = r"Return the pointer to the register block"]
7202 #[inline(always)]
7203 pub const fn ptr() -> *const timer::RegisterBlock {
7204 Self::PTR
7205 }
7206 #[doc = r" Steal an instance of this peripheral"]
7207 #[doc = r""]
7208 #[doc = r" # Safety"]
7209 #[doc = r""]
7210 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7211 #[doc = r" that may race with any existing instances, for example by only"]
7212 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7213 #[doc = r" original peripheral and using critical sections to coordinate"]
7214 #[doc = r" access between multiple new instances."]
7215 #[doc = r""]
7216 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7217 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7218 #[doc = r" no stolen instances are passed to such software."]
7219 pub unsafe fn steal() -> Self {
7220 Self {
7221 _marker: PhantomData,
7222 }
7223 }
7224}
7225impl Deref for Timer4 {
7226 type Target = timer::RegisterBlock;
7227 #[inline(always)]
7228 fn deref(&self) -> &Self::Target {
7229 unsafe { &*Self::PTR }
7230 }
7231}
7232impl core::fmt::Debug for Timer4 {
7233 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7234 f.debug_struct("Timer4").finish()
7235 }
7236}
7237#[doc = "Timer 4 Registers"]
7238pub use self::timer as timer4;
7239#[doc = "Timer 5 Registers"]
7240pub struct Timer5 {
7241 _marker: PhantomData<*const ()>,
7242}
7243unsafe impl Send for Timer5 {}
7244impl Timer5 {
7245 #[doc = r"Pointer to the register block"]
7246 pub const PTR: *const timer::RegisterBlock = 0xff85_00a0 as *const _;
7247 #[doc = r"Return the pointer to the register block"]
7248 #[inline(always)]
7249 pub const fn ptr() -> *const timer::RegisterBlock {
7250 Self::PTR
7251 }
7252 #[doc = r" Steal an instance of this peripheral"]
7253 #[doc = r""]
7254 #[doc = r" # Safety"]
7255 #[doc = r""]
7256 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7257 #[doc = r" that may race with any existing instances, for example by only"]
7258 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7259 #[doc = r" original peripheral and using critical sections to coordinate"]
7260 #[doc = r" access between multiple new instances."]
7261 #[doc = r""]
7262 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7263 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7264 #[doc = r" no stolen instances are passed to such software."]
7265 pub unsafe fn steal() -> Self {
7266 Self {
7267 _marker: PhantomData,
7268 }
7269 }
7270}
7271impl Deref for Timer5 {
7272 type Target = timer::RegisterBlock;
7273 #[inline(always)]
7274 fn deref(&self) -> &Self::Target {
7275 unsafe { &*Self::PTR }
7276 }
7277}
7278impl core::fmt::Debug for Timer5 {
7279 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7280 f.debug_struct("Timer5").finish()
7281 }
7282}
7283#[doc = "Timer 5 Registers"]
7284pub use self::timer as timer5;
7285#[doc = "Timer 6 Registers"]
7286pub struct Timer6 {
7287 _marker: PhantomData<*const ()>,
7288}
7289unsafe impl Send for Timer6 {}
7290impl Timer6 {
7291 #[doc = r"Pointer to the register block"]
7292 pub const PTR: *const timer::RegisterBlock = 0xff85_8000 as *const _;
7293 #[doc = r"Return the pointer to the register block"]
7294 #[inline(always)]
7295 pub const fn ptr() -> *const timer::RegisterBlock {
7296 Self::PTR
7297 }
7298 #[doc = r" Steal an instance of this peripheral"]
7299 #[doc = r""]
7300 #[doc = r" # Safety"]
7301 #[doc = r""]
7302 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7303 #[doc = r" that may race with any existing instances, for example by only"]
7304 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7305 #[doc = r" original peripheral and using critical sections to coordinate"]
7306 #[doc = r" access between multiple new instances."]
7307 #[doc = r""]
7308 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7309 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7310 #[doc = r" no stolen instances are passed to such software."]
7311 pub unsafe fn steal() -> Self {
7312 Self {
7313 _marker: PhantomData,
7314 }
7315 }
7316}
7317impl Deref for Timer6 {
7318 type Target = timer::RegisterBlock;
7319 #[inline(always)]
7320 fn deref(&self) -> &Self::Target {
7321 unsafe { &*Self::PTR }
7322 }
7323}
7324impl core::fmt::Debug for Timer6 {
7325 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7326 f.debug_struct("Timer6").finish()
7327 }
7328}
7329#[doc = "Timer 6 Registers"]
7330pub use self::timer as timer6;
7331#[doc = "Timer 7 Registers"]
7332pub struct Timer7 {
7333 _marker: PhantomData<*const ()>,
7334}
7335unsafe impl Send for Timer7 {}
7336impl Timer7 {
7337 #[doc = r"Pointer to the register block"]
7338 pub const PTR: *const timer::RegisterBlock = 0xff85_8020 as *const _;
7339 #[doc = r"Return the pointer to the register block"]
7340 #[inline(always)]
7341 pub const fn ptr() -> *const timer::RegisterBlock {
7342 Self::PTR
7343 }
7344 #[doc = r" Steal an instance of this peripheral"]
7345 #[doc = r""]
7346 #[doc = r" # Safety"]
7347 #[doc = r""]
7348 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7349 #[doc = r" that may race with any existing instances, for example by only"]
7350 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7351 #[doc = r" original peripheral and using critical sections to coordinate"]
7352 #[doc = r" access between multiple new instances."]
7353 #[doc = r""]
7354 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7355 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7356 #[doc = r" no stolen instances are passed to such software."]
7357 pub unsafe fn steal() -> Self {
7358 Self {
7359 _marker: PhantomData,
7360 }
7361 }
7362}
7363impl Deref for Timer7 {
7364 type Target = timer::RegisterBlock;
7365 #[inline(always)]
7366 fn deref(&self) -> &Self::Target {
7367 unsafe { &*Self::PTR }
7368 }
7369}
7370impl core::fmt::Debug for Timer7 {
7371 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7372 f.debug_struct("Timer7").finish()
7373 }
7374}
7375#[doc = "Timer 7 Registers"]
7376pub use self::timer as timer7;
7377#[doc = "Timer 8 Registers"]
7378pub struct Timer8 {
7379 _marker: PhantomData<*const ()>,
7380}
7381unsafe impl Send for Timer8 {}
7382impl Timer8 {
7383 #[doc = r"Pointer to the register block"]
7384 pub const PTR: *const timer::RegisterBlock = 0xff85_8040 as *const _;
7385 #[doc = r"Return the pointer to the register block"]
7386 #[inline(always)]
7387 pub const fn ptr() -> *const timer::RegisterBlock {
7388 Self::PTR
7389 }
7390 #[doc = r" Steal an instance of this peripheral"]
7391 #[doc = r""]
7392 #[doc = r" # Safety"]
7393 #[doc = r""]
7394 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7395 #[doc = r" that may race with any existing instances, for example by only"]
7396 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7397 #[doc = r" original peripheral and using critical sections to coordinate"]
7398 #[doc = r" access between multiple new instances."]
7399 #[doc = r""]
7400 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7401 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7402 #[doc = r" no stolen instances are passed to such software."]
7403 pub unsafe fn steal() -> Self {
7404 Self {
7405 _marker: PhantomData,
7406 }
7407 }
7408}
7409impl Deref for Timer8 {
7410 type Target = timer::RegisterBlock;
7411 #[inline(always)]
7412 fn deref(&self) -> &Self::Target {
7413 unsafe { &*Self::PTR }
7414 }
7415}
7416impl core::fmt::Debug for Timer8 {
7417 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7418 f.debug_struct("Timer8").finish()
7419 }
7420}
7421#[doc = "Timer 8 Registers"]
7422pub use self::timer as timer8;
7423#[doc = "Timer 9 Registers"]
7424pub struct Timer9 {
7425 _marker: PhantomData<*const ()>,
7426}
7427unsafe impl Send for Timer9 {}
7428impl Timer9 {
7429 #[doc = r"Pointer to the register block"]
7430 pub const PTR: *const timer::RegisterBlock = 0xff85_8060 as *const _;
7431 #[doc = r"Return the pointer to the register block"]
7432 #[inline(always)]
7433 pub const fn ptr() -> *const timer::RegisterBlock {
7434 Self::PTR
7435 }
7436 #[doc = r" Steal an instance of this peripheral"]
7437 #[doc = r""]
7438 #[doc = r" # Safety"]
7439 #[doc = r""]
7440 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7441 #[doc = r" that may race with any existing instances, for example by only"]
7442 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7443 #[doc = r" original peripheral and using critical sections to coordinate"]
7444 #[doc = r" access between multiple new instances."]
7445 #[doc = r""]
7446 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7447 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7448 #[doc = r" no stolen instances are passed to such software."]
7449 pub unsafe fn steal() -> Self {
7450 Self {
7451 _marker: PhantomData,
7452 }
7453 }
7454}
7455impl Deref for Timer9 {
7456 type Target = timer::RegisterBlock;
7457 #[inline(always)]
7458 fn deref(&self) -> &Self::Target {
7459 unsafe { &*Self::PTR }
7460 }
7461}
7462impl core::fmt::Debug for Timer9 {
7463 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7464 f.debug_struct("Timer9").finish()
7465 }
7466}
7467#[doc = "Timer 9 Registers"]
7468pub use self::timer as timer9;
7469#[doc = "Power Management Unit Timer 0 Registers"]
7470pub struct Pmutimer0 {
7471 _marker: PhantomData<*const ()>,
7472}
7473unsafe impl Send for Pmutimer0 {}
7474impl Pmutimer0 {
7475 #[doc = r"Pointer to the register block"]
7476 pub const PTR: *const timer::RegisterBlock = 0xff36_0000 as *const _;
7477 #[doc = r"Return the pointer to the register block"]
7478 #[inline(always)]
7479 pub const fn ptr() -> *const timer::RegisterBlock {
7480 Self::PTR
7481 }
7482 #[doc = r" Steal an instance of this peripheral"]
7483 #[doc = r""]
7484 #[doc = r" # Safety"]
7485 #[doc = r""]
7486 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7487 #[doc = r" that may race with any existing instances, for example by only"]
7488 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7489 #[doc = r" original peripheral and using critical sections to coordinate"]
7490 #[doc = r" access between multiple new instances."]
7491 #[doc = r""]
7492 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7493 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7494 #[doc = r" no stolen instances are passed to such software."]
7495 pub unsafe fn steal() -> Self {
7496 Self {
7497 _marker: PhantomData,
7498 }
7499 }
7500}
7501impl Deref for Pmutimer0 {
7502 type Target = timer::RegisterBlock;
7503 #[inline(always)]
7504 fn deref(&self) -> &Self::Target {
7505 unsafe { &*Self::PTR }
7506 }
7507}
7508impl core::fmt::Debug for Pmutimer0 {
7509 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7510 f.debug_struct("Pmutimer0").finish()
7511 }
7512}
7513#[doc = "Power Management Unit Timer 0 Registers"]
7514pub use self::timer as pmutimer0;
7515#[doc = "Power Management Unit Timer 1 Registers"]
7516pub struct Pmutimer1 {
7517 _marker: PhantomData<*const ()>,
7518}
7519unsafe impl Send for Pmutimer1 {}
7520impl Pmutimer1 {
7521 #[doc = r"Pointer to the register block"]
7522 pub const PTR: *const timer::RegisterBlock = 0xff36_0020 as *const _;
7523 #[doc = r"Return the pointer to the register block"]
7524 #[inline(always)]
7525 pub const fn ptr() -> *const timer::RegisterBlock {
7526 Self::PTR
7527 }
7528 #[doc = r" Steal an instance of this peripheral"]
7529 #[doc = r""]
7530 #[doc = r" # Safety"]
7531 #[doc = r""]
7532 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7533 #[doc = r" that may race with any existing instances, for example by only"]
7534 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7535 #[doc = r" original peripheral and using critical sections to coordinate"]
7536 #[doc = r" access between multiple new instances."]
7537 #[doc = r""]
7538 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7539 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7540 #[doc = r" no stolen instances are passed to such software."]
7541 pub unsafe fn steal() -> Self {
7542 Self {
7543 _marker: PhantomData,
7544 }
7545 }
7546}
7547impl Deref for Pmutimer1 {
7548 type Target = timer::RegisterBlock;
7549 #[inline(always)]
7550 fn deref(&self) -> &Self::Target {
7551 unsafe { &*Self::PTR }
7552 }
7553}
7554impl core::fmt::Debug for Pmutimer1 {
7555 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7556 f.debug_struct("Pmutimer1").finish()
7557 }
7558}
7559#[doc = "Power Management Unit Timer 1 Registers"]
7560pub use self::timer as pmutimer1;
7561#[doc = "Secure Timer 0 Registers"]
7562pub struct Stimer0 {
7563 _marker: PhantomData<*const ()>,
7564}
7565unsafe impl Send for Stimer0 {}
7566impl Stimer0 {
7567 #[doc = r"Pointer to the register block"]
7568 pub const PTR: *const timer::RegisterBlock = 0xff86_0000 as *const _;
7569 #[doc = r"Return the pointer to the register block"]
7570 #[inline(always)]
7571 pub const fn ptr() -> *const timer::RegisterBlock {
7572 Self::PTR
7573 }
7574 #[doc = r" Steal an instance of this peripheral"]
7575 #[doc = r""]
7576 #[doc = r" # Safety"]
7577 #[doc = r""]
7578 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7579 #[doc = r" that may race with any existing instances, for example by only"]
7580 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7581 #[doc = r" original peripheral and using critical sections to coordinate"]
7582 #[doc = r" access between multiple new instances."]
7583 #[doc = r""]
7584 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7585 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7586 #[doc = r" no stolen instances are passed to such software."]
7587 pub unsafe fn steal() -> Self {
7588 Self {
7589 _marker: PhantomData,
7590 }
7591 }
7592}
7593impl Deref for Stimer0 {
7594 type Target = timer::RegisterBlock;
7595 #[inline(always)]
7596 fn deref(&self) -> &Self::Target {
7597 unsafe { &*Self::PTR }
7598 }
7599}
7600impl core::fmt::Debug for Stimer0 {
7601 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7602 f.debug_struct("Stimer0").finish()
7603 }
7604}
7605#[doc = "Secure Timer 0 Registers"]
7606pub use self::timer as stimer0;
7607#[doc = "Secure Timer 1 Registers"]
7608pub struct Stimer1 {
7609 _marker: PhantomData<*const ()>,
7610}
7611unsafe impl Send for Stimer1 {}
7612impl Stimer1 {
7613 #[doc = r"Pointer to the register block"]
7614 pub const PTR: *const timer::RegisterBlock = 0xff86_0020 as *const _;
7615 #[doc = r"Return the pointer to the register block"]
7616 #[inline(always)]
7617 pub const fn ptr() -> *const timer::RegisterBlock {
7618 Self::PTR
7619 }
7620 #[doc = r" Steal an instance of this peripheral"]
7621 #[doc = r""]
7622 #[doc = r" # Safety"]
7623 #[doc = r""]
7624 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7625 #[doc = r" that may race with any existing instances, for example by only"]
7626 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7627 #[doc = r" original peripheral and using critical sections to coordinate"]
7628 #[doc = r" access between multiple new instances."]
7629 #[doc = r""]
7630 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7631 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7632 #[doc = r" no stolen instances are passed to such software."]
7633 pub unsafe fn steal() -> Self {
7634 Self {
7635 _marker: PhantomData,
7636 }
7637 }
7638}
7639impl Deref for Stimer1 {
7640 type Target = timer::RegisterBlock;
7641 #[inline(always)]
7642 fn deref(&self) -> &Self::Target {
7643 unsafe { &*Self::PTR }
7644 }
7645}
7646impl core::fmt::Debug for Stimer1 {
7647 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7648 f.debug_struct("Stimer1").finish()
7649 }
7650}
7651#[doc = "Secure Timer 1 Registers"]
7652pub use self::timer as stimer1;
7653#[doc = "Secure Timer 10 Registers"]
7654pub struct Stimer10 {
7655 _marker: PhantomData<*const ()>,
7656}
7657unsafe impl Send for Stimer10 {}
7658impl Stimer10 {
7659 #[doc = r"Pointer to the register block"]
7660 pub const PTR: *const timer::RegisterBlock = 0xff86_8080 as *const _;
7661 #[doc = r"Return the pointer to the register block"]
7662 #[inline(always)]
7663 pub const fn ptr() -> *const timer::RegisterBlock {
7664 Self::PTR
7665 }
7666 #[doc = r" Steal an instance of this peripheral"]
7667 #[doc = r""]
7668 #[doc = r" # Safety"]
7669 #[doc = r""]
7670 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7671 #[doc = r" that may race with any existing instances, for example by only"]
7672 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7673 #[doc = r" original peripheral and using critical sections to coordinate"]
7674 #[doc = r" access between multiple new instances."]
7675 #[doc = r""]
7676 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7677 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7678 #[doc = r" no stolen instances are passed to such software."]
7679 pub unsafe fn steal() -> Self {
7680 Self {
7681 _marker: PhantomData,
7682 }
7683 }
7684}
7685impl Deref for Stimer10 {
7686 type Target = timer::RegisterBlock;
7687 #[inline(always)]
7688 fn deref(&self) -> &Self::Target {
7689 unsafe { &*Self::PTR }
7690 }
7691}
7692impl core::fmt::Debug for Stimer10 {
7693 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7694 f.debug_struct("Stimer10").finish()
7695 }
7696}
7697#[doc = "Secure Timer 10 Registers"]
7698pub use self::timer as stimer10;
7699#[doc = "Secure Timer 11 Registers"]
7700pub struct Stimer11 {
7701 _marker: PhantomData<*const ()>,
7702}
7703unsafe impl Send for Stimer11 {}
7704impl Stimer11 {
7705 #[doc = r"Pointer to the register block"]
7706 pub const PTR: *const timer::RegisterBlock = 0xff86_80a0 as *const _;
7707 #[doc = r"Return the pointer to the register block"]
7708 #[inline(always)]
7709 pub const fn ptr() -> *const timer::RegisterBlock {
7710 Self::PTR
7711 }
7712 #[doc = r" Steal an instance of this peripheral"]
7713 #[doc = r""]
7714 #[doc = r" # Safety"]
7715 #[doc = r""]
7716 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7717 #[doc = r" that may race with any existing instances, for example by only"]
7718 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7719 #[doc = r" original peripheral and using critical sections to coordinate"]
7720 #[doc = r" access between multiple new instances."]
7721 #[doc = r""]
7722 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7723 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7724 #[doc = r" no stolen instances are passed to such software."]
7725 pub unsafe fn steal() -> Self {
7726 Self {
7727 _marker: PhantomData,
7728 }
7729 }
7730}
7731impl Deref for Stimer11 {
7732 type Target = timer::RegisterBlock;
7733 #[inline(always)]
7734 fn deref(&self) -> &Self::Target {
7735 unsafe { &*Self::PTR }
7736 }
7737}
7738impl core::fmt::Debug for Stimer11 {
7739 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7740 f.debug_struct("Stimer11").finish()
7741 }
7742}
7743#[doc = "Secure Timer 11 Registers"]
7744pub use self::timer as stimer11;
7745#[doc = "Secure Timer 2 Registers"]
7746pub struct Stimer2 {
7747 _marker: PhantomData<*const ()>,
7748}
7749unsafe impl Send for Stimer2 {}
7750impl Stimer2 {
7751 #[doc = r"Pointer to the register block"]
7752 pub const PTR: *const timer::RegisterBlock = 0xff86_0040 as *const _;
7753 #[doc = r"Return the pointer to the register block"]
7754 #[inline(always)]
7755 pub const fn ptr() -> *const timer::RegisterBlock {
7756 Self::PTR
7757 }
7758 #[doc = r" Steal an instance of this peripheral"]
7759 #[doc = r""]
7760 #[doc = r" # Safety"]
7761 #[doc = r""]
7762 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7763 #[doc = r" that may race with any existing instances, for example by only"]
7764 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7765 #[doc = r" original peripheral and using critical sections to coordinate"]
7766 #[doc = r" access between multiple new instances."]
7767 #[doc = r""]
7768 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7769 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7770 #[doc = r" no stolen instances are passed to such software."]
7771 pub unsafe fn steal() -> Self {
7772 Self {
7773 _marker: PhantomData,
7774 }
7775 }
7776}
7777impl Deref for Stimer2 {
7778 type Target = timer::RegisterBlock;
7779 #[inline(always)]
7780 fn deref(&self) -> &Self::Target {
7781 unsafe { &*Self::PTR }
7782 }
7783}
7784impl core::fmt::Debug for Stimer2 {
7785 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7786 f.debug_struct("Stimer2").finish()
7787 }
7788}
7789#[doc = "Secure Timer 2 Registers"]
7790pub use self::timer as stimer2;
7791#[doc = "Secure Timer 3 Registers"]
7792pub struct Stimer3 {
7793 _marker: PhantomData<*const ()>,
7794}
7795unsafe impl Send for Stimer3 {}
7796impl Stimer3 {
7797 #[doc = r"Pointer to the register block"]
7798 pub const PTR: *const timer::RegisterBlock = 0xff86_0060 as *const _;
7799 #[doc = r"Return the pointer to the register block"]
7800 #[inline(always)]
7801 pub const fn ptr() -> *const timer::RegisterBlock {
7802 Self::PTR
7803 }
7804 #[doc = r" Steal an instance of this peripheral"]
7805 #[doc = r""]
7806 #[doc = r" # Safety"]
7807 #[doc = r""]
7808 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7809 #[doc = r" that may race with any existing instances, for example by only"]
7810 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7811 #[doc = r" original peripheral and using critical sections to coordinate"]
7812 #[doc = r" access between multiple new instances."]
7813 #[doc = r""]
7814 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7815 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7816 #[doc = r" no stolen instances are passed to such software."]
7817 pub unsafe fn steal() -> Self {
7818 Self {
7819 _marker: PhantomData,
7820 }
7821 }
7822}
7823impl Deref for Stimer3 {
7824 type Target = timer::RegisterBlock;
7825 #[inline(always)]
7826 fn deref(&self) -> &Self::Target {
7827 unsafe { &*Self::PTR }
7828 }
7829}
7830impl core::fmt::Debug for Stimer3 {
7831 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7832 f.debug_struct("Stimer3").finish()
7833 }
7834}
7835#[doc = "Secure Timer 3 Registers"]
7836pub use self::timer as stimer3;
7837#[doc = "Secure Timer 4 Registers"]
7838pub struct Stimer4 {
7839 _marker: PhantomData<*const ()>,
7840}
7841unsafe impl Send for Stimer4 {}
7842impl Stimer4 {
7843 #[doc = r"Pointer to the register block"]
7844 pub const PTR: *const timer::RegisterBlock = 0xff86_0080 as *const _;
7845 #[doc = r"Return the pointer to the register block"]
7846 #[inline(always)]
7847 pub const fn ptr() -> *const timer::RegisterBlock {
7848 Self::PTR
7849 }
7850 #[doc = r" Steal an instance of this peripheral"]
7851 #[doc = r""]
7852 #[doc = r" # Safety"]
7853 #[doc = r""]
7854 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7855 #[doc = r" that may race with any existing instances, for example by only"]
7856 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7857 #[doc = r" original peripheral and using critical sections to coordinate"]
7858 #[doc = r" access between multiple new instances."]
7859 #[doc = r""]
7860 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7861 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7862 #[doc = r" no stolen instances are passed to such software."]
7863 pub unsafe fn steal() -> Self {
7864 Self {
7865 _marker: PhantomData,
7866 }
7867 }
7868}
7869impl Deref for Stimer4 {
7870 type Target = timer::RegisterBlock;
7871 #[inline(always)]
7872 fn deref(&self) -> &Self::Target {
7873 unsafe { &*Self::PTR }
7874 }
7875}
7876impl core::fmt::Debug for Stimer4 {
7877 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7878 f.debug_struct("Stimer4").finish()
7879 }
7880}
7881#[doc = "Secure Timer 4 Registers"]
7882pub use self::timer as stimer4;
7883#[doc = "Secure Timer 5 Registers"]
7884pub struct Stimer5 {
7885 _marker: PhantomData<*const ()>,
7886}
7887unsafe impl Send for Stimer5 {}
7888impl Stimer5 {
7889 #[doc = r"Pointer to the register block"]
7890 pub const PTR: *const timer::RegisterBlock = 0xff86_00a0 as *const _;
7891 #[doc = r"Return the pointer to the register block"]
7892 #[inline(always)]
7893 pub const fn ptr() -> *const timer::RegisterBlock {
7894 Self::PTR
7895 }
7896 #[doc = r" Steal an instance of this peripheral"]
7897 #[doc = r""]
7898 #[doc = r" # Safety"]
7899 #[doc = r""]
7900 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7901 #[doc = r" that may race with any existing instances, for example by only"]
7902 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7903 #[doc = r" original peripheral and using critical sections to coordinate"]
7904 #[doc = r" access between multiple new instances."]
7905 #[doc = r""]
7906 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7907 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7908 #[doc = r" no stolen instances are passed to such software."]
7909 pub unsafe fn steal() -> Self {
7910 Self {
7911 _marker: PhantomData,
7912 }
7913 }
7914}
7915impl Deref for Stimer5 {
7916 type Target = timer::RegisterBlock;
7917 #[inline(always)]
7918 fn deref(&self) -> &Self::Target {
7919 unsafe { &*Self::PTR }
7920 }
7921}
7922impl core::fmt::Debug for Stimer5 {
7923 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7924 f.debug_struct("Stimer5").finish()
7925 }
7926}
7927#[doc = "Secure Timer 5 Registers"]
7928pub use self::timer as stimer5;
7929#[doc = "Secure Timer 6 Registers"]
7930pub struct Stimer6 {
7931 _marker: PhantomData<*const ()>,
7932}
7933unsafe impl Send for Stimer6 {}
7934impl Stimer6 {
7935 #[doc = r"Pointer to the register block"]
7936 pub const PTR: *const timer::RegisterBlock = 0xff86_8000 as *const _;
7937 #[doc = r"Return the pointer to the register block"]
7938 #[inline(always)]
7939 pub const fn ptr() -> *const timer::RegisterBlock {
7940 Self::PTR
7941 }
7942 #[doc = r" Steal an instance of this peripheral"]
7943 #[doc = r""]
7944 #[doc = r" # Safety"]
7945 #[doc = r""]
7946 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7947 #[doc = r" that may race with any existing instances, for example by only"]
7948 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7949 #[doc = r" original peripheral and using critical sections to coordinate"]
7950 #[doc = r" access between multiple new instances."]
7951 #[doc = r""]
7952 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7953 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
7954 #[doc = r" no stolen instances are passed to such software."]
7955 pub unsafe fn steal() -> Self {
7956 Self {
7957 _marker: PhantomData,
7958 }
7959 }
7960}
7961impl Deref for Stimer6 {
7962 type Target = timer::RegisterBlock;
7963 #[inline(always)]
7964 fn deref(&self) -> &Self::Target {
7965 unsafe { &*Self::PTR }
7966 }
7967}
7968impl core::fmt::Debug for Stimer6 {
7969 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7970 f.debug_struct("Stimer6").finish()
7971 }
7972}
7973#[doc = "Secure Timer 6 Registers"]
7974pub use self::timer as stimer6;
7975#[doc = "Secure Timer 7 Registers"]
7976pub struct Stimer7 {
7977 _marker: PhantomData<*const ()>,
7978}
7979unsafe impl Send for Stimer7 {}
7980impl Stimer7 {
7981 #[doc = r"Pointer to the register block"]
7982 pub const PTR: *const timer::RegisterBlock = 0xff86_8020 as *const _;
7983 #[doc = r"Return the pointer to the register block"]
7984 #[inline(always)]
7985 pub const fn ptr() -> *const timer::RegisterBlock {
7986 Self::PTR
7987 }
7988 #[doc = r" Steal an instance of this peripheral"]
7989 #[doc = r""]
7990 #[doc = r" # Safety"]
7991 #[doc = r""]
7992 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
7993 #[doc = r" that may race with any existing instances, for example by only"]
7994 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
7995 #[doc = r" original peripheral and using critical sections to coordinate"]
7996 #[doc = r" access between multiple new instances."]
7997 #[doc = r""]
7998 #[doc = r" Additionally, other software such as HALs may rely on only one"]
7999 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
8000 #[doc = r" no stolen instances are passed to such software."]
8001 pub unsafe fn steal() -> Self {
8002 Self {
8003 _marker: PhantomData,
8004 }
8005 }
8006}
8007impl Deref for Stimer7 {
8008 type Target = timer::RegisterBlock;
8009 #[inline(always)]
8010 fn deref(&self) -> &Self::Target {
8011 unsafe { &*Self::PTR }
8012 }
8013}
8014impl core::fmt::Debug for Stimer7 {
8015 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
8016 f.debug_struct("Stimer7").finish()
8017 }
8018}
8019#[doc = "Secure Timer 7 Registers"]
8020pub use self::timer as stimer7;
8021#[doc = "Secure Timer 8 Registers"]
8022pub struct Stimer8 {
8023 _marker: PhantomData<*const ()>,
8024}
8025unsafe impl Send for Stimer8 {}
8026impl Stimer8 {
8027 #[doc = r"Pointer to the register block"]
8028 pub const PTR: *const timer::RegisterBlock = 0xff86_8040 as *const _;
8029 #[doc = r"Return the pointer to the register block"]
8030 #[inline(always)]
8031 pub const fn ptr() -> *const timer::RegisterBlock {
8032 Self::PTR
8033 }
8034 #[doc = r" Steal an instance of this peripheral"]
8035 #[doc = r""]
8036 #[doc = r" # Safety"]
8037 #[doc = r""]
8038 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
8039 #[doc = r" that may race with any existing instances, for example by only"]
8040 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
8041 #[doc = r" original peripheral and using critical sections to coordinate"]
8042 #[doc = r" access between multiple new instances."]
8043 #[doc = r""]
8044 #[doc = r" Additionally, other software such as HALs may rely on only one"]
8045 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
8046 #[doc = r" no stolen instances are passed to such software."]
8047 pub unsafe fn steal() -> Self {
8048 Self {
8049 _marker: PhantomData,
8050 }
8051 }
8052}
8053impl Deref for Stimer8 {
8054 type Target = timer::RegisterBlock;
8055 #[inline(always)]
8056 fn deref(&self) -> &Self::Target {
8057 unsafe { &*Self::PTR }
8058 }
8059}
8060impl core::fmt::Debug for Stimer8 {
8061 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
8062 f.debug_struct("Stimer8").finish()
8063 }
8064}
8065#[doc = "Secure Timer 8 Registers"]
8066pub use self::timer as stimer8;
8067#[doc = "Secure Timer 9 Registers"]
8068pub struct Stimer9 {
8069 _marker: PhantomData<*const ()>,
8070}
8071unsafe impl Send for Stimer9 {}
8072impl Stimer9 {
8073 #[doc = r"Pointer to the register block"]
8074 pub const PTR: *const timer::RegisterBlock = 0xff86_8060 as *const _;
8075 #[doc = r"Return the pointer to the register block"]
8076 #[inline(always)]
8077 pub const fn ptr() -> *const timer::RegisterBlock {
8078 Self::PTR
8079 }
8080 #[doc = r" Steal an instance of this peripheral"]
8081 #[doc = r""]
8082 #[doc = r" # Safety"]
8083 #[doc = r""]
8084 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
8085 #[doc = r" that may race with any existing instances, for example by only"]
8086 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
8087 #[doc = r" original peripheral and using critical sections to coordinate"]
8088 #[doc = r" access between multiple new instances."]
8089 #[doc = r""]
8090 #[doc = r" Additionally, other software such as HALs may rely on only one"]
8091 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
8092 #[doc = r" no stolen instances are passed to such software."]
8093 pub unsafe fn steal() -> Self {
8094 Self {
8095 _marker: PhantomData,
8096 }
8097 }
8098}
8099impl Deref for Stimer9 {
8100 type Target = timer::RegisterBlock;
8101 #[inline(always)]
8102 fn deref(&self) -> &Self::Target {
8103 unsafe { &*Self::PTR }
8104 }
8105}
8106impl core::fmt::Debug for Stimer9 {
8107 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
8108 f.debug_struct("Stimer9").finish()
8109 }
8110}
8111#[doc = "Secure Timer 9 Registers"]
8112pub use self::timer as stimer9;
8113#[doc = "Temperature Sensor Analog-to-Digital Converter (TSADC) Registers"]
8114pub struct Tsadc {
8115 _marker: PhantomData<*const ()>,
8116}
8117unsafe impl Send for Tsadc {}
8118impl Tsadc {
8119 #[doc = r"Pointer to the register block"]
8120 pub const PTR: *const tsadc::RegisterBlock = 0xff26_0000 as *const _;
8121 #[doc = r"Return the pointer to the register block"]
8122 #[inline(always)]
8123 pub const fn ptr() -> *const tsadc::RegisterBlock {
8124 Self::PTR
8125 }
8126 #[doc = r" Steal an instance of this peripheral"]
8127 #[doc = r""]
8128 #[doc = r" # Safety"]
8129 #[doc = r""]
8130 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
8131 #[doc = r" that may race with any existing instances, for example by only"]
8132 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
8133 #[doc = r" original peripheral and using critical sections to coordinate"]
8134 #[doc = r" access between multiple new instances."]
8135 #[doc = r""]
8136 #[doc = r" Additionally, other software such as HALs may rely on only one"]
8137 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
8138 #[doc = r" no stolen instances are passed to such software."]
8139 pub unsafe fn steal() -> Self {
8140 Self {
8141 _marker: PhantomData,
8142 }
8143 }
8144}
8145impl Deref for Tsadc {
8146 type Target = tsadc::RegisterBlock;
8147 #[inline(always)]
8148 fn deref(&self) -> &Self::Target {
8149 unsafe { &*Self::PTR }
8150 }
8151}
8152impl core::fmt::Debug for Tsadc {
8153 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
8154 f.debug_struct("Tsadc").finish()
8155 }
8156}
8157#[doc = "Temperature Sensor Analog-to-Digital Converter (TSADC) Registers"]
8158pub mod tsadc;
8159#[doc = "Type-C Power Delivery (TYPEC_PD) Registers"]
8160pub struct TypecPd {
8161 _marker: PhantomData<*const ()>,
8162}
8163unsafe impl Send for TypecPd {}
8164impl TypecPd {
8165 #[doc = r"Pointer to the register block"]
8166 pub const PTR: *const typec_pd::RegisterBlock = 0xff7a_0000 as *const _;
8167 #[doc = r"Return the pointer to the register block"]
8168 #[inline(always)]
8169 pub const fn ptr() -> *const typec_pd::RegisterBlock {
8170 Self::PTR
8171 }
8172 #[doc = r" Steal an instance of this peripheral"]
8173 #[doc = r""]
8174 #[doc = r" # Safety"]
8175 #[doc = r""]
8176 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
8177 #[doc = r" that may race with any existing instances, for example by only"]
8178 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
8179 #[doc = r" original peripheral and using critical sections to coordinate"]
8180 #[doc = r" access between multiple new instances."]
8181 #[doc = r""]
8182 #[doc = r" Additionally, other software such as HALs may rely on only one"]
8183 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
8184 #[doc = r" no stolen instances are passed to such software."]
8185 pub unsafe fn steal() -> Self {
8186 Self {
8187 _marker: PhantomData,
8188 }
8189 }
8190}
8191impl Deref for TypecPd {
8192 type Target = typec_pd::RegisterBlock;
8193 #[inline(always)]
8194 fn deref(&self) -> &Self::Target {
8195 unsafe { &*Self::PTR }
8196 }
8197}
8198impl core::fmt::Debug for TypecPd {
8199 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
8200 f.debug_struct("TypecPd").finish()
8201 }
8202}
8203#[doc = "Type-C Power Delivery (TYPEC_PD) Registers"]
8204pub mod typec_pd;
8205#[doc = "Type-C Power Delivery (TYPEC_PD) 0 Registers"]
8206pub struct TypecPd0 {
8207 _marker: PhantomData<*const ()>,
8208}
8209unsafe impl Send for TypecPd0 {}
8210impl TypecPd0 {
8211 #[doc = r"Pointer to the register block"]
8212 pub const PTR: *const typec_pd::RegisterBlock = 0xff7a_0000 as *const _;
8213 #[doc = r"Return the pointer to the register block"]
8214 #[inline(always)]
8215 pub const fn ptr() -> *const typec_pd::RegisterBlock {
8216 Self::PTR
8217 }
8218 #[doc = r" Steal an instance of this peripheral"]
8219 #[doc = r""]
8220 #[doc = r" # Safety"]
8221 #[doc = r""]
8222 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
8223 #[doc = r" that may race with any existing instances, for example by only"]
8224 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
8225 #[doc = r" original peripheral and using critical sections to coordinate"]
8226 #[doc = r" access between multiple new instances."]
8227 #[doc = r""]
8228 #[doc = r" Additionally, other software such as HALs may rely on only one"]
8229 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
8230 #[doc = r" no stolen instances are passed to such software."]
8231 pub unsafe fn steal() -> Self {
8232 Self {
8233 _marker: PhantomData,
8234 }
8235 }
8236}
8237impl Deref for TypecPd0 {
8238 type Target = typec_pd::RegisterBlock;
8239 #[inline(always)]
8240 fn deref(&self) -> &Self::Target {
8241 unsafe { &*Self::PTR }
8242 }
8243}
8244impl core::fmt::Debug for TypecPd0 {
8245 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
8246 f.debug_struct("TypecPd0").finish()
8247 }
8248}
8249#[doc = "Type-C Power Delivery (TYPEC_PD) 0 Registers"]
8250pub use self::typec_pd as typec_pd0;
8251#[doc = "Type-C Power Delivery (TYPEC_PD) 1 Registers"]
8252pub struct TypecPd1 {
8253 _marker: PhantomData<*const ()>,
8254}
8255unsafe impl Send for TypecPd1 {}
8256impl TypecPd1 {
8257 #[doc = r"Pointer to the register block"]
8258 pub const PTR: *const typec_pd::RegisterBlock = 0xff7b_0000 as *const _;
8259 #[doc = r"Return the pointer to the register block"]
8260 #[inline(always)]
8261 pub const fn ptr() -> *const typec_pd::RegisterBlock {
8262 Self::PTR
8263 }
8264 #[doc = r" Steal an instance of this peripheral"]
8265 #[doc = r""]
8266 #[doc = r" # Safety"]
8267 #[doc = r""]
8268 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
8269 #[doc = r" that may race with any existing instances, for example by only"]
8270 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
8271 #[doc = r" original peripheral and using critical sections to coordinate"]
8272 #[doc = r" access between multiple new instances."]
8273 #[doc = r""]
8274 #[doc = r" Additionally, other software such as HALs may rely on only one"]
8275 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
8276 #[doc = r" no stolen instances are passed to such software."]
8277 pub unsafe fn steal() -> Self {
8278 Self {
8279 _marker: PhantomData,
8280 }
8281 }
8282}
8283impl Deref for TypecPd1 {
8284 type Target = typec_pd::RegisterBlock;
8285 #[inline(always)]
8286 fn deref(&self) -> &Self::Target {
8287 unsafe { &*Self::PTR }
8288 }
8289}
8290impl core::fmt::Debug for TypecPd1 {
8291 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
8292 f.debug_struct("TypecPd1").finish()
8293 }
8294}
8295#[doc = "Type-C Power Delivery (TYPEC_PD) 1 Registers"]
8296pub use self::typec_pd as typec_pd1;
8297#[doc = "Type-C PHY Registers"]
8298pub struct TypecPhy {
8299 _marker: PhantomData<*const ()>,
8300}
8301unsafe impl Send for TypecPhy {}
8302impl TypecPhy {
8303 #[doc = r"Pointer to the register block"]
8304 pub const PTR: *const typec_phy::RegisterBlock = 0xff7c_0000 as *const _;
8305 #[doc = r"Return the pointer to the register block"]
8306 #[inline(always)]
8307 pub const fn ptr() -> *const typec_phy::RegisterBlock {
8308 Self::PTR
8309 }
8310 #[doc = r" Steal an instance of this peripheral"]
8311 #[doc = r""]
8312 #[doc = r" # Safety"]
8313 #[doc = r""]
8314 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
8315 #[doc = r" that may race with any existing instances, for example by only"]
8316 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
8317 #[doc = r" original peripheral and using critical sections to coordinate"]
8318 #[doc = r" access between multiple new instances."]
8319 #[doc = r""]
8320 #[doc = r" Additionally, other software such as HALs may rely on only one"]
8321 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
8322 #[doc = r" no stolen instances are passed to such software."]
8323 pub unsafe fn steal() -> Self {
8324 Self {
8325 _marker: PhantomData,
8326 }
8327 }
8328}
8329impl Deref for TypecPhy {
8330 type Target = typec_phy::RegisterBlock;
8331 #[inline(always)]
8332 fn deref(&self) -> &Self::Target {
8333 unsafe { &*Self::PTR }
8334 }
8335}
8336impl core::fmt::Debug for TypecPhy {
8337 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
8338 f.debug_struct("TypecPhy").finish()
8339 }
8340}
8341#[doc = "Type-C PHY Registers"]
8342pub mod typec_phy;
8343#[doc = "Type-C PHY 0 Registers"]
8344pub struct TypecPhy0 {
8345 _marker: PhantomData<*const ()>,
8346}
8347unsafe impl Send for TypecPhy0 {}
8348impl TypecPhy0 {
8349 #[doc = r"Pointer to the register block"]
8350 pub const PTR: *const typec_phy::RegisterBlock = 0xff7c_0000 as *const _;
8351 #[doc = r"Return the pointer to the register block"]
8352 #[inline(always)]
8353 pub const fn ptr() -> *const typec_phy::RegisterBlock {
8354 Self::PTR
8355 }
8356 #[doc = r" Steal an instance of this peripheral"]
8357 #[doc = r""]
8358 #[doc = r" # Safety"]
8359 #[doc = r""]
8360 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
8361 #[doc = r" that may race with any existing instances, for example by only"]
8362 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
8363 #[doc = r" original peripheral and using critical sections to coordinate"]
8364 #[doc = r" access between multiple new instances."]
8365 #[doc = r""]
8366 #[doc = r" Additionally, other software such as HALs may rely on only one"]
8367 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
8368 #[doc = r" no stolen instances are passed to such software."]
8369 pub unsafe fn steal() -> Self {
8370 Self {
8371 _marker: PhantomData,
8372 }
8373 }
8374}
8375impl Deref for TypecPhy0 {
8376 type Target = typec_phy::RegisterBlock;
8377 #[inline(always)]
8378 fn deref(&self) -> &Self::Target {
8379 unsafe { &*Self::PTR }
8380 }
8381}
8382impl core::fmt::Debug for TypecPhy0 {
8383 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
8384 f.debug_struct("TypecPhy0").finish()
8385 }
8386}
8387#[doc = "Type-C PHY 0 Registers"]
8388pub use self::typec_phy as typec_phy0;
8389#[doc = "Type-C PHY 1 Registers"]
8390pub struct TypecPhy1 {
8391 _marker: PhantomData<*const ()>,
8392}
8393unsafe impl Send for TypecPhy1 {}
8394impl TypecPhy1 {
8395 #[doc = r"Pointer to the register block"]
8396 pub const PTR: *const typec_phy::RegisterBlock = 0xff80_0000 as *const _;
8397 #[doc = r"Return the pointer to the register block"]
8398 #[inline(always)]
8399 pub const fn ptr() -> *const typec_phy::RegisterBlock {
8400 Self::PTR
8401 }
8402 #[doc = r" Steal an instance of this peripheral"]
8403 #[doc = r""]
8404 #[doc = r" # Safety"]
8405 #[doc = r""]
8406 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
8407 #[doc = r" that may race with any existing instances, for example by only"]
8408 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
8409 #[doc = r" original peripheral and using critical sections to coordinate"]
8410 #[doc = r" access between multiple new instances."]
8411 #[doc = r""]
8412 #[doc = r" Additionally, other software such as HALs may rely on only one"]
8413 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
8414 #[doc = r" no stolen instances are passed to such software."]
8415 pub unsafe fn steal() -> Self {
8416 Self {
8417 _marker: PhantomData,
8418 }
8419 }
8420}
8421impl Deref for TypecPhy1 {
8422 type Target = typec_phy::RegisterBlock;
8423 #[inline(always)]
8424 fn deref(&self) -> &Self::Target {
8425 unsafe { &*Self::PTR }
8426 }
8427}
8428impl core::fmt::Debug for TypecPhy1 {
8429 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
8430 f.debug_struct("TypecPhy1").finish()
8431 }
8432}
8433#[doc = "Type-C PHY 1 Registers"]
8434pub use self::typec_phy as typec_phy1;
8435#[doc = "Universal Asynchronous Receiver/Transmitter (UART) Registers"]
8436pub struct Uart {
8437 _marker: PhantomData<*const ()>,
8438}
8439unsafe impl Send for Uart {}
8440impl Uart {
8441 #[doc = r"Pointer to the register block"]
8442 pub const PTR: *const uart::RegisterBlock = 0xff18_0000 as *const _;
8443 #[doc = r"Return the pointer to the register block"]
8444 #[inline(always)]
8445 pub const fn ptr() -> *const uart::RegisterBlock {
8446 Self::PTR
8447 }
8448 #[doc = r" Steal an instance of this peripheral"]
8449 #[doc = r""]
8450 #[doc = r" # Safety"]
8451 #[doc = r""]
8452 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
8453 #[doc = r" that may race with any existing instances, for example by only"]
8454 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
8455 #[doc = r" original peripheral and using critical sections to coordinate"]
8456 #[doc = r" access between multiple new instances."]
8457 #[doc = r""]
8458 #[doc = r" Additionally, other software such as HALs may rely on only one"]
8459 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
8460 #[doc = r" no stolen instances are passed to such software."]
8461 pub unsafe fn steal() -> Self {
8462 Self {
8463 _marker: PhantomData,
8464 }
8465 }
8466}
8467impl Deref for Uart {
8468 type Target = uart::RegisterBlock;
8469 #[inline(always)]
8470 fn deref(&self) -> &Self::Target {
8471 unsafe { &*Self::PTR }
8472 }
8473}
8474impl core::fmt::Debug for Uart {
8475 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
8476 f.debug_struct("Uart").finish()
8477 }
8478}
8479#[doc = "Universal Asynchronous Receiver/Transmitter (UART) Registers"]
8480pub mod uart;
8481#[doc = "Universal Asynchronous Receiver/Transmitter 0 (UART0) Registers"]
8482pub struct Uart0 {
8483 _marker: PhantomData<*const ()>,
8484}
8485unsafe impl Send for Uart0 {}
8486impl Uart0 {
8487 #[doc = r"Pointer to the register block"]
8488 pub const PTR: *const uart::RegisterBlock = 0xff18_0000 as *const _;
8489 #[doc = r"Return the pointer to the register block"]
8490 #[inline(always)]
8491 pub const fn ptr() -> *const uart::RegisterBlock {
8492 Self::PTR
8493 }
8494 #[doc = r" Steal an instance of this peripheral"]
8495 #[doc = r""]
8496 #[doc = r" # Safety"]
8497 #[doc = r""]
8498 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
8499 #[doc = r" that may race with any existing instances, for example by only"]
8500 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
8501 #[doc = r" original peripheral and using critical sections to coordinate"]
8502 #[doc = r" access between multiple new instances."]
8503 #[doc = r""]
8504 #[doc = r" Additionally, other software such as HALs may rely on only one"]
8505 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
8506 #[doc = r" no stolen instances are passed to such software."]
8507 pub unsafe fn steal() -> Self {
8508 Self {
8509 _marker: PhantomData,
8510 }
8511 }
8512}
8513impl Deref for Uart0 {
8514 type Target = uart::RegisterBlock;
8515 #[inline(always)]
8516 fn deref(&self) -> &Self::Target {
8517 unsafe { &*Self::PTR }
8518 }
8519}
8520impl core::fmt::Debug for Uart0 {
8521 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
8522 f.debug_struct("Uart0").finish()
8523 }
8524}
8525#[doc = "Universal Asynchronous Receiver/Transmitter 0 (UART0) Registers"]
8526pub use self::uart as uart0;
8527#[doc = "Universal Asynchronous Receiver/Transmitter 1 (UART1) Registers"]
8528pub struct Uart1 {
8529 _marker: PhantomData<*const ()>,
8530}
8531unsafe impl Send for Uart1 {}
8532impl Uart1 {
8533 #[doc = r"Pointer to the register block"]
8534 pub const PTR: *const uart::RegisterBlock = 0xff19_0000 as *const _;
8535 #[doc = r"Return the pointer to the register block"]
8536 #[inline(always)]
8537 pub const fn ptr() -> *const uart::RegisterBlock {
8538 Self::PTR
8539 }
8540 #[doc = r" Steal an instance of this peripheral"]
8541 #[doc = r""]
8542 #[doc = r" # Safety"]
8543 #[doc = r""]
8544 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
8545 #[doc = r" that may race with any existing instances, for example by only"]
8546 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
8547 #[doc = r" original peripheral and using critical sections to coordinate"]
8548 #[doc = r" access between multiple new instances."]
8549 #[doc = r""]
8550 #[doc = r" Additionally, other software such as HALs may rely on only one"]
8551 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
8552 #[doc = r" no stolen instances are passed to such software."]
8553 pub unsafe fn steal() -> Self {
8554 Self {
8555 _marker: PhantomData,
8556 }
8557 }
8558}
8559impl Deref for Uart1 {
8560 type Target = uart::RegisterBlock;
8561 #[inline(always)]
8562 fn deref(&self) -> &Self::Target {
8563 unsafe { &*Self::PTR }
8564 }
8565}
8566impl core::fmt::Debug for Uart1 {
8567 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
8568 f.debug_struct("Uart1").finish()
8569 }
8570}
8571#[doc = "Universal Asynchronous Receiver/Transmitter 1 (UART1) Registers"]
8572pub use self::uart as uart1;
8573#[doc = "Universal Asynchronous Receiver/Transmitter 2 (UART2) Registers"]
8574pub struct Uart2 {
8575 _marker: PhantomData<*const ()>,
8576}
8577unsafe impl Send for Uart2 {}
8578impl Uart2 {
8579 #[doc = r"Pointer to the register block"]
8580 pub const PTR: *const uart::RegisterBlock = 0xff1a_0000 as *const _;
8581 #[doc = r"Return the pointer to the register block"]
8582 #[inline(always)]
8583 pub const fn ptr() -> *const uart::RegisterBlock {
8584 Self::PTR
8585 }
8586 #[doc = r" Steal an instance of this peripheral"]
8587 #[doc = r""]
8588 #[doc = r" # Safety"]
8589 #[doc = r""]
8590 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
8591 #[doc = r" that may race with any existing instances, for example by only"]
8592 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
8593 #[doc = r" original peripheral and using critical sections to coordinate"]
8594 #[doc = r" access between multiple new instances."]
8595 #[doc = r""]
8596 #[doc = r" Additionally, other software such as HALs may rely on only one"]
8597 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
8598 #[doc = r" no stolen instances are passed to such software."]
8599 pub unsafe fn steal() -> Self {
8600 Self {
8601 _marker: PhantomData,
8602 }
8603 }
8604}
8605impl Deref for Uart2 {
8606 type Target = uart::RegisterBlock;
8607 #[inline(always)]
8608 fn deref(&self) -> &Self::Target {
8609 unsafe { &*Self::PTR }
8610 }
8611}
8612impl core::fmt::Debug for Uart2 {
8613 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
8614 f.debug_struct("Uart2").finish()
8615 }
8616}
8617#[doc = "Universal Asynchronous Receiver/Transmitter 2 (UART2) Registers"]
8618pub use self::uart as uart2;
8619#[doc = "Universal Asynchronous Receiver/Transmitter 3 (UART3) Registers"]
8620pub struct Uart3 {
8621 _marker: PhantomData<*const ()>,
8622}
8623unsafe impl Send for Uart3 {}
8624impl Uart3 {
8625 #[doc = r"Pointer to the register block"]
8626 pub const PTR: *const uart::RegisterBlock = 0xff1b_0000 as *const _;
8627 #[doc = r"Return the pointer to the register block"]
8628 #[inline(always)]
8629 pub const fn ptr() -> *const uart::RegisterBlock {
8630 Self::PTR
8631 }
8632 #[doc = r" Steal an instance of this peripheral"]
8633 #[doc = r""]
8634 #[doc = r" # Safety"]
8635 #[doc = r""]
8636 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
8637 #[doc = r" that may race with any existing instances, for example by only"]
8638 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
8639 #[doc = r" original peripheral and using critical sections to coordinate"]
8640 #[doc = r" access between multiple new instances."]
8641 #[doc = r""]
8642 #[doc = r" Additionally, other software such as HALs may rely on only one"]
8643 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
8644 #[doc = r" no stolen instances are passed to such software."]
8645 pub unsafe fn steal() -> Self {
8646 Self {
8647 _marker: PhantomData,
8648 }
8649 }
8650}
8651impl Deref for Uart3 {
8652 type Target = uart::RegisterBlock;
8653 #[inline(always)]
8654 fn deref(&self) -> &Self::Target {
8655 unsafe { &*Self::PTR }
8656 }
8657}
8658impl core::fmt::Debug for Uart3 {
8659 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
8660 f.debug_struct("Uart3").finish()
8661 }
8662}
8663#[doc = "Universal Asynchronous Receiver/Transmitter 3 (UART3) Registers"]
8664pub use self::uart as uart3;
8665#[doc = "Universal Asynchronous Receiver/Transmitter 4 (UART4) Registers"]
8666pub struct Uart4 {
8667 _marker: PhantomData<*const ()>,
8668}
8669unsafe impl Send for Uart4 {}
8670impl Uart4 {
8671 #[doc = r"Pointer to the register block"]
8672 pub const PTR: *const uart::RegisterBlock = 0xff37_0000 as *const _;
8673 #[doc = r"Return the pointer to the register block"]
8674 #[inline(always)]
8675 pub const fn ptr() -> *const uart::RegisterBlock {
8676 Self::PTR
8677 }
8678 #[doc = r" Steal an instance of this peripheral"]
8679 #[doc = r""]
8680 #[doc = r" # Safety"]
8681 #[doc = r""]
8682 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
8683 #[doc = r" that may race with any existing instances, for example by only"]
8684 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
8685 #[doc = r" original peripheral and using critical sections to coordinate"]
8686 #[doc = r" access between multiple new instances."]
8687 #[doc = r""]
8688 #[doc = r" Additionally, other software such as HALs may rely on only one"]
8689 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
8690 #[doc = r" no stolen instances are passed to such software."]
8691 pub unsafe fn steal() -> Self {
8692 Self {
8693 _marker: PhantomData,
8694 }
8695 }
8696}
8697impl Deref for Uart4 {
8698 type Target = uart::RegisterBlock;
8699 #[inline(always)]
8700 fn deref(&self) -> &Self::Target {
8701 unsafe { &*Self::PTR }
8702 }
8703}
8704impl core::fmt::Debug for Uart4 {
8705 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
8706 f.debug_struct("Uart4").finish()
8707 }
8708}
8709#[doc = "Universal Asynchronous Receiver/Transmitter 4 (UART4) Registers"]
8710pub use self::uart as uart4;
8711#[doc = "USB 3.0/2.0 OTG (USB3) Registers"]
8712pub struct Usb3 {
8713 _marker: PhantomData<*const ()>,
8714}
8715unsafe impl Send for Usb3 {}
8716impl Usb3 {
8717 #[doc = r"Pointer to the register block"]
8718 pub const PTR: *const usb3::RegisterBlock = 0xfe80_0000 as *const _;
8719 #[doc = r"Return the pointer to the register block"]
8720 #[inline(always)]
8721 pub const fn ptr() -> *const usb3::RegisterBlock {
8722 Self::PTR
8723 }
8724 #[doc = r" Steal an instance of this peripheral"]
8725 #[doc = r""]
8726 #[doc = r" # Safety"]
8727 #[doc = r""]
8728 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
8729 #[doc = r" that may race with any existing instances, for example by only"]
8730 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
8731 #[doc = r" original peripheral and using critical sections to coordinate"]
8732 #[doc = r" access between multiple new instances."]
8733 #[doc = r""]
8734 #[doc = r" Additionally, other software such as HALs may rely on only one"]
8735 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
8736 #[doc = r" no stolen instances are passed to such software."]
8737 pub unsafe fn steal() -> Self {
8738 Self {
8739 _marker: PhantomData,
8740 }
8741 }
8742}
8743impl Deref for Usb3 {
8744 type Target = usb3::RegisterBlock;
8745 #[inline(always)]
8746 fn deref(&self) -> &Self::Target {
8747 unsafe { &*Self::PTR }
8748 }
8749}
8750impl core::fmt::Debug for Usb3 {
8751 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
8752 f.debug_struct("Usb3").finish()
8753 }
8754}
8755#[doc = "USB 3.0/2.0 OTG (USB3) Registers"]
8756pub mod usb3;
8757#[doc = "USB 3.0/2.0 OTG Register 0 (USB3_OTG0) Registers"]
8758pub struct Usb3Otg0 {
8759 _marker: PhantomData<*const ()>,
8760}
8761unsafe impl Send for Usb3Otg0 {}
8762impl Usb3Otg0 {
8763 #[doc = r"Pointer to the register block"]
8764 pub const PTR: *const usb3::RegisterBlock = 0xfe80_0000 as *const _;
8765 #[doc = r"Return the pointer to the register block"]
8766 #[inline(always)]
8767 pub const fn ptr() -> *const usb3::RegisterBlock {
8768 Self::PTR
8769 }
8770 #[doc = r" Steal an instance of this peripheral"]
8771 #[doc = r""]
8772 #[doc = r" # Safety"]
8773 #[doc = r""]
8774 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
8775 #[doc = r" that may race with any existing instances, for example by only"]
8776 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
8777 #[doc = r" original peripheral and using critical sections to coordinate"]
8778 #[doc = r" access between multiple new instances."]
8779 #[doc = r""]
8780 #[doc = r" Additionally, other software such as HALs may rely on only one"]
8781 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
8782 #[doc = r" no stolen instances are passed to such software."]
8783 pub unsafe fn steal() -> Self {
8784 Self {
8785 _marker: PhantomData,
8786 }
8787 }
8788}
8789impl Deref for Usb3Otg0 {
8790 type Target = usb3::RegisterBlock;
8791 #[inline(always)]
8792 fn deref(&self) -> &Self::Target {
8793 unsafe { &*Self::PTR }
8794 }
8795}
8796impl core::fmt::Debug for Usb3Otg0 {
8797 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
8798 f.debug_struct("Usb3Otg0").finish()
8799 }
8800}
8801#[doc = "USB 3.0/2.0 OTG Register 0 (USB3_OTG0) Registers"]
8802pub use self::usb3 as usb3_otg0;
8803#[doc = "USB 3.0/2.0 OTG Register 1 (USB3_OTG1) Registers"]
8804pub struct Usb3Otg1 {
8805 _marker: PhantomData<*const ()>,
8806}
8807unsafe impl Send for Usb3Otg1 {}
8808impl Usb3Otg1 {
8809 #[doc = r"Pointer to the register block"]
8810 pub const PTR: *const usb3::RegisterBlock = 0xfe90_0000 as *const _;
8811 #[doc = r"Return the pointer to the register block"]
8812 #[inline(always)]
8813 pub const fn ptr() -> *const usb3::RegisterBlock {
8814 Self::PTR
8815 }
8816 #[doc = r" Steal an instance of this peripheral"]
8817 #[doc = r""]
8818 #[doc = r" # Safety"]
8819 #[doc = r""]
8820 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
8821 #[doc = r" that may race with any existing instances, for example by only"]
8822 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
8823 #[doc = r" original peripheral and using critical sections to coordinate"]
8824 #[doc = r" access between multiple new instances."]
8825 #[doc = r""]
8826 #[doc = r" Additionally, other software such as HALs may rely on only one"]
8827 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
8828 #[doc = r" no stolen instances are passed to such software."]
8829 pub unsafe fn steal() -> Self {
8830 Self {
8831 _marker: PhantomData,
8832 }
8833 }
8834}
8835impl Deref for Usb3Otg1 {
8836 type Target = usb3::RegisterBlock;
8837 #[inline(always)]
8838 fn deref(&self) -> &Self::Target {
8839 unsafe { &*Self::PTR }
8840 }
8841}
8842impl core::fmt::Debug for Usb3Otg1 {
8843 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
8844 f.debug_struct("Usb3Otg1").finish()
8845 }
8846}
8847#[doc = "USB 3.0/2.0 OTG Register 1 (USB3_OTG1) Registers"]
8848pub use self::usb3 as usb3_otg1;
8849#[doc = "Video Processor Unit (VPU) Decoder Registers"]
8850pub struct Vdpu {
8851 _marker: PhantomData<*const ()>,
8852}
8853unsafe impl Send for Vdpu {}
8854impl Vdpu {
8855 #[doc = r"Pointer to the register block"]
8856 pub const PTR: *const vdpu::RegisterBlock = 0xff65_0400 as *const _;
8857 #[doc = r"Return the pointer to the register block"]
8858 #[inline(always)]
8859 pub const fn ptr() -> *const vdpu::RegisterBlock {
8860 Self::PTR
8861 }
8862 #[doc = r" Steal an instance of this peripheral"]
8863 #[doc = r""]
8864 #[doc = r" # Safety"]
8865 #[doc = r""]
8866 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
8867 #[doc = r" that may race with any existing instances, for example by only"]
8868 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
8869 #[doc = r" original peripheral and using critical sections to coordinate"]
8870 #[doc = r" access between multiple new instances."]
8871 #[doc = r""]
8872 #[doc = r" Additionally, other software such as HALs may rely on only one"]
8873 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
8874 #[doc = r" no stolen instances are passed to such software."]
8875 pub unsafe fn steal() -> Self {
8876 Self {
8877 _marker: PhantomData,
8878 }
8879 }
8880}
8881impl Deref for Vdpu {
8882 type Target = vdpu::RegisterBlock;
8883 #[inline(always)]
8884 fn deref(&self) -> &Self::Target {
8885 unsafe { &*Self::PTR }
8886 }
8887}
8888impl core::fmt::Debug for Vdpu {
8889 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
8890 f.debug_struct("Vdpu").finish()
8891 }
8892}
8893#[doc = "Video Processor Unit (VPU) Decoder Registers"]
8894pub mod vdpu;
8895#[doc = "Video Processor Unit (VPU) Encoder Registers"]
8896pub struct Vepu {
8897 _marker: PhantomData<*const ()>,
8898}
8899unsafe impl Send for Vepu {}
8900impl Vepu {
8901 #[doc = r"Pointer to the register block"]
8902 pub const PTR: *const vepu::RegisterBlock = 0xff65_0000 as *const _;
8903 #[doc = r"Return the pointer to the register block"]
8904 #[inline(always)]
8905 pub const fn ptr() -> *const vepu::RegisterBlock {
8906 Self::PTR
8907 }
8908 #[doc = r" Steal an instance of this peripheral"]
8909 #[doc = r""]
8910 #[doc = r" # Safety"]
8911 #[doc = r""]
8912 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
8913 #[doc = r" that may race with any existing instances, for example by only"]
8914 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
8915 #[doc = r" original peripheral and using critical sections to coordinate"]
8916 #[doc = r" access between multiple new instances."]
8917 #[doc = r""]
8918 #[doc = r" Additionally, other software such as HALs may rely on only one"]
8919 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
8920 #[doc = r" no stolen instances are passed to such software."]
8921 pub unsafe fn steal() -> Self {
8922 Self {
8923 _marker: PhantomData,
8924 }
8925 }
8926}
8927impl Deref for Vepu {
8928 type Target = vepu::RegisterBlock;
8929 #[inline(always)]
8930 fn deref(&self) -> &Self::Target {
8931 unsafe { &*Self::PTR }
8932 }
8933}
8934impl core::fmt::Debug for Vepu {
8935 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
8936 f.debug_struct("Vepu").finish()
8937 }
8938}
8939#[doc = "Video Processor Unit (VPU) Encoder Registers"]
8940pub mod vepu;
8941#[doc = "Visual Output Processor (Big) (VOPB) Registers"]
8942pub struct Vopb {
8943 _marker: PhantomData<*const ()>,
8944}
8945unsafe impl Send for Vopb {}
8946impl Vopb {
8947 #[doc = r"Pointer to the register block"]
8948 pub const PTR: *const vopb::RegisterBlock = 0xff90_0000 as *const _;
8949 #[doc = r"Return the pointer to the register block"]
8950 #[inline(always)]
8951 pub const fn ptr() -> *const vopb::RegisterBlock {
8952 Self::PTR
8953 }
8954 #[doc = r" Steal an instance of this peripheral"]
8955 #[doc = r""]
8956 #[doc = r" # Safety"]
8957 #[doc = r""]
8958 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
8959 #[doc = r" that may race with any existing instances, for example by only"]
8960 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
8961 #[doc = r" original peripheral and using critical sections to coordinate"]
8962 #[doc = r" access between multiple new instances."]
8963 #[doc = r""]
8964 #[doc = r" Additionally, other software such as HALs may rely on only one"]
8965 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
8966 #[doc = r" no stolen instances are passed to such software."]
8967 pub unsafe fn steal() -> Self {
8968 Self {
8969 _marker: PhantomData,
8970 }
8971 }
8972}
8973impl Deref for Vopb {
8974 type Target = vopb::RegisterBlock;
8975 #[inline(always)]
8976 fn deref(&self) -> &Self::Target {
8977 unsafe { &*Self::PTR }
8978 }
8979}
8980impl core::fmt::Debug for Vopb {
8981 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
8982 f.debug_struct("Vopb").finish()
8983 }
8984}
8985#[doc = "Visual Output Processor (Big) (VOPB) Registers"]
8986pub mod vopb;
8987#[doc = "Visual Output Processor (Little) (VOPL) Registers"]
8988pub struct Vopl {
8989 _marker: PhantomData<*const ()>,
8990}
8991unsafe impl Send for Vopl {}
8992impl Vopl {
8993 #[doc = r"Pointer to the register block"]
8994 pub const PTR: *const vopl::RegisterBlock = 0xff8f_0000 as *const _;
8995 #[doc = r"Return the pointer to the register block"]
8996 #[inline(always)]
8997 pub const fn ptr() -> *const vopl::RegisterBlock {
8998 Self::PTR
8999 }
9000 #[doc = r" Steal an instance of this peripheral"]
9001 #[doc = r""]
9002 #[doc = r" # Safety"]
9003 #[doc = r""]
9004 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
9005 #[doc = r" that may race with any existing instances, for example by only"]
9006 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
9007 #[doc = r" original peripheral and using critical sections to coordinate"]
9008 #[doc = r" access between multiple new instances."]
9009 #[doc = r""]
9010 #[doc = r" Additionally, other software such as HALs may rely on only one"]
9011 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
9012 #[doc = r" no stolen instances are passed to such software."]
9013 pub unsafe fn steal() -> Self {
9014 Self {
9015 _marker: PhantomData,
9016 }
9017 }
9018}
9019impl Deref for Vopl {
9020 type Target = vopl::RegisterBlock;
9021 #[inline(always)]
9022 fn deref(&self) -> &Self::Target {
9023 unsafe { &*Self::PTR }
9024 }
9025}
9026impl core::fmt::Debug for Vopl {
9027 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
9028 f.debug_struct("Vopl").finish()
9029 }
9030}
9031#[doc = "Visual Output Processor (Little) (VOPL) Registers"]
9032pub mod vopl;
9033#[doc = "Watchdog Timer (WDT) Registers"]
9034pub struct Wdt {
9035 _marker: PhantomData<*const ()>,
9036}
9037unsafe impl Send for Wdt {}
9038impl Wdt {
9039 #[doc = r"Pointer to the register block"]
9040 pub const PTR: *const wdt::RegisterBlock = 0xff84_8000 as *const _;
9041 #[doc = r"Return the pointer to the register block"]
9042 #[inline(always)]
9043 pub const fn ptr() -> *const wdt::RegisterBlock {
9044 Self::PTR
9045 }
9046 #[doc = r" Steal an instance of this peripheral"]
9047 #[doc = r""]
9048 #[doc = r" # Safety"]
9049 #[doc = r""]
9050 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
9051 #[doc = r" that may race with any existing instances, for example by only"]
9052 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
9053 #[doc = r" original peripheral and using critical sections to coordinate"]
9054 #[doc = r" access between multiple new instances."]
9055 #[doc = r""]
9056 #[doc = r" Additionally, other software such as HALs may rely on only one"]
9057 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
9058 #[doc = r" no stolen instances are passed to such software."]
9059 pub unsafe fn steal() -> Self {
9060 Self {
9061 _marker: PhantomData,
9062 }
9063 }
9064}
9065impl Deref for Wdt {
9066 type Target = wdt::RegisterBlock;
9067 #[inline(always)]
9068 fn deref(&self) -> &Self::Target {
9069 unsafe { &*Self::PTR }
9070 }
9071}
9072impl core::fmt::Debug for Wdt {
9073 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
9074 f.debug_struct("Wdt").finish()
9075 }
9076}
9077#[doc = "Watchdog Timer (WDT) Registers"]
9078pub mod wdt;
9079#[doc = "Watchdog Timer (WDT) 0 Registers"]
9080pub struct Wdt0 {
9081 _marker: PhantomData<*const ()>,
9082}
9083unsafe impl Send for Wdt0 {}
9084impl Wdt0 {
9085 #[doc = r"Pointer to the register block"]
9086 pub const PTR: *const wdt::RegisterBlock = 0xff84_8000 as *const _;
9087 #[doc = r"Return the pointer to the register block"]
9088 #[inline(always)]
9089 pub const fn ptr() -> *const wdt::RegisterBlock {
9090 Self::PTR
9091 }
9092 #[doc = r" Steal an instance of this peripheral"]
9093 #[doc = r""]
9094 #[doc = r" # Safety"]
9095 #[doc = r""]
9096 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
9097 #[doc = r" that may race with any existing instances, for example by only"]
9098 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
9099 #[doc = r" original peripheral and using critical sections to coordinate"]
9100 #[doc = r" access between multiple new instances."]
9101 #[doc = r""]
9102 #[doc = r" Additionally, other software such as HALs may rely on only one"]
9103 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
9104 #[doc = r" no stolen instances are passed to such software."]
9105 pub unsafe fn steal() -> Self {
9106 Self {
9107 _marker: PhantomData,
9108 }
9109 }
9110}
9111impl Deref for Wdt0 {
9112 type Target = wdt::RegisterBlock;
9113 #[inline(always)]
9114 fn deref(&self) -> &Self::Target {
9115 unsafe { &*Self::PTR }
9116 }
9117}
9118impl core::fmt::Debug for Wdt0 {
9119 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
9120 f.debug_struct("Wdt0").finish()
9121 }
9122}
9123#[doc = "Watchdog Timer (WDT) 0 Registers"]
9124pub use self::wdt as wdt0;
9125#[doc = "Watchdog Timer (WDT) 1 Registers"]
9126pub struct Wdt1 {
9127 _marker: PhantomData<*const ()>,
9128}
9129unsafe impl Send for Wdt1 {}
9130impl Wdt1 {
9131 #[doc = r"Pointer to the register block"]
9132 pub const PTR: *const wdt::RegisterBlock = 0xff84_0000 as *const _;
9133 #[doc = r"Return the pointer to the register block"]
9134 #[inline(always)]
9135 pub const fn ptr() -> *const wdt::RegisterBlock {
9136 Self::PTR
9137 }
9138 #[doc = r" Steal an instance of this peripheral"]
9139 #[doc = r""]
9140 #[doc = r" # Safety"]
9141 #[doc = r""]
9142 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
9143 #[doc = r" that may race with any existing instances, for example by only"]
9144 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
9145 #[doc = r" original peripheral and using critical sections to coordinate"]
9146 #[doc = r" access between multiple new instances."]
9147 #[doc = r""]
9148 #[doc = r" Additionally, other software such as HALs may rely on only one"]
9149 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
9150 #[doc = r" no stolen instances are passed to such software."]
9151 pub unsafe fn steal() -> Self {
9152 Self {
9153 _marker: PhantomData,
9154 }
9155 }
9156}
9157impl Deref for Wdt1 {
9158 type Target = wdt::RegisterBlock;
9159 #[inline(always)]
9160 fn deref(&self) -> &Self::Target {
9161 unsafe { &*Self::PTR }
9162 }
9163}
9164impl core::fmt::Debug for Wdt1 {
9165 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
9166 f.debug_struct("Wdt1").finish()
9167 }
9168}
9169#[doc = "Watchdog Timer (WDT) 1 Registers"]
9170pub use self::wdt as wdt1;
9171#[doc = "Watchdog Timer (WDT) 2 Registers"]
9172pub struct Wdt2 {
9173 _marker: PhantomData<*const ()>,
9174}
9175unsafe impl Send for Wdt2 {}
9176impl Wdt2 {
9177 #[doc = r"Pointer to the register block"]
9178 pub const PTR: *const wdt::RegisterBlock = 0xff38_0000 as *const _;
9179 #[doc = r"Return the pointer to the register block"]
9180 #[inline(always)]
9181 pub const fn ptr() -> *const wdt::RegisterBlock {
9182 Self::PTR
9183 }
9184 #[doc = r" Steal an instance of this peripheral"]
9185 #[doc = r""]
9186 #[doc = r" # Safety"]
9187 #[doc = r""]
9188 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
9189 #[doc = r" that may race with any existing instances, for example by only"]
9190 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
9191 #[doc = r" original peripheral and using critical sections to coordinate"]
9192 #[doc = r" access between multiple new instances."]
9193 #[doc = r""]
9194 #[doc = r" Additionally, other software such as HALs may rely on only one"]
9195 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
9196 #[doc = r" no stolen instances are passed to such software."]
9197 pub unsafe fn steal() -> Self {
9198 Self {
9199 _marker: PhantomData,
9200 }
9201 }
9202}
9203impl Deref for Wdt2 {
9204 type Target = wdt::RegisterBlock;
9205 #[inline(always)]
9206 fn deref(&self) -> &Self::Target {
9207 unsafe { &*Self::PTR }
9208 }
9209}
9210impl core::fmt::Debug for Wdt2 {
9211 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
9212 f.debug_struct("Wdt2").finish()
9213 }
9214}
9215#[doc = "Watchdog Timer (WDT) 2 Registers"]
9216pub use self::wdt as wdt2;
9217#[no_mangle]
9218static mut DEVICE_PERIPHERALS: bool = false;
9219#[doc = r" All the peripherals."]
9220#[allow(non_snake_case)]
9221pub struct Peripherals {
9222 #[doc = "CCI500"]
9223 pub cci500: Cci500,
9224 #[doc = "CRU"]
9225 pub cru: Cru,
9226 #[doc = "CRYPTO"]
9227 pub crypto: Crypto,
9228 #[doc = "CRYPTO0"]
9229 pub crypto0: Crypto0,
9230 #[doc = "CRYPTO1"]
9231 pub crypto1: Crypto1,
9232 #[doc = "DCF"]
9233 pub dcf: Dcf,
9234 #[doc = "DDRC"]
9235 pub ddrc: Ddrc,
9236 #[doc = "DDRC0"]
9237 pub ddrc0: Ddrc0,
9238 #[doc = "DDRC1"]
9239 pub ddrc1: Ddrc1,
9240 #[doc = "DDR_CIC"]
9241 pub ddr_cic: DdrCic,
9242 #[doc = "DDR_MON"]
9243 pub ddr_mon: DdrMon,
9244 #[doc = "DMAC"]
9245 pub dmac: Dmac,
9246 #[doc = "DMAC0"]
9247 pub dmac0: Dmac0,
9248 #[doc = "DMAC1"]
9249 pub dmac1: Dmac1,
9250 #[doc = "DP"]
9251 pub dp: Dp,
9252 #[doc = "EFUSE"]
9253 pub efuse: Efuse,
9254 #[doc = "EFUSE0"]
9255 pub efuse0: Efuse0,
9256 #[doc = "EFUSE1"]
9257 pub efuse1: Efuse1,
9258 #[doc = "EMMCCORE"]
9259 pub emmccore: Emmccore,
9260 #[doc = "ERR_LOGGER_MSCH"]
9261 pub err_logger_msch: ErrLoggerMsch,
9262 #[doc = "ERR_LOGGER_MSCH0"]
9263 pub err_logger_msch0: ErrLoggerMsch0,
9264 #[doc = "ERR_LOGGER_MSCH1"]
9265 pub err_logger_msch1: ErrLoggerMsch1,
9266 #[doc = "ERR_LOGGER_SLV"]
9267 pub err_logger_slv: ErrLoggerSlv,
9268 #[doc = "ERR_LOGGER_SLV0"]
9269 pub err_logger_slv0: ErrLoggerSlv0,
9270 #[doc = "ERR_LOGGER_SLV1"]
9271 pub err_logger_slv1: ErrLoggerSlv1,
9272 #[doc = "GMAC"]
9273 pub gmac: Gmac,
9274 #[doc = "GPIO"]
9275 pub gpio: Gpio,
9276 #[doc = "GPIO0"]
9277 pub gpio0: Gpio0,
9278 #[doc = "GPIO1"]
9279 pub gpio1: Gpio1,
9280 #[doc = "GPIO2"]
9281 pub gpio2: Gpio2,
9282 #[doc = "GPIO3"]
9283 pub gpio3: Gpio3,
9284 #[doc = "GPIO4"]
9285 pub gpio4: Gpio4,
9286 #[doc = "GRF"]
9287 pub grf: Grf,
9288 #[doc = "HDMI"]
9289 pub hdmi: Hdmi,
9290 #[doc = "I2S"]
9291 pub i2s: I2s,
9292 #[doc = "I2S0"]
9293 pub i2s0: I2s0,
9294 #[doc = "I2S1"]
9295 pub i2s1: I2s1,
9296 #[doc = "I2S2"]
9297 pub i2s2: I2s2,
9298 #[doc = "IEP"]
9299 pub iep: Iep,
9300 #[doc = "ISP"]
9301 pub isp: Isp,
9302 #[doc = "ISP0"]
9303 pub isp0: Isp0,
9304 #[doc = "ISP1"]
9305 pub isp1: Isp1,
9306 #[doc = "MAILBOX"]
9307 pub mailbox: Mailbox,
9308 #[doc = "MAILBOX0"]
9309 pub mailbox0: Mailbox0,
9310 #[doc = "MAILBOX1"]
9311 pub mailbox1: Mailbox1,
9312 #[doc = "MIPI_DSI_HOST"]
9313 pub mipi_dsi_host: MipiDsiHost,
9314 #[doc = "MIPI_DSI_HOST0"]
9315 pub mipi_dsi_host0: MipiDsiHost0,
9316 #[doc = "MIPI_DSI_HOST1"]
9317 pub mipi_dsi_host1: MipiDsiHost1,
9318 #[doc = "MMU"]
9319 pub mmu: Mmu,
9320 #[doc = "MMU0_ISP0"]
9321 pub mmu0_isp0: Mmu0Isp0,
9322 #[doc = "MMU0_ISP1"]
9323 pub mmu0_isp1: Mmu0Isp1,
9324 #[doc = "MMU1_ISP0"]
9325 pub mmu1_isp0: Mmu1Isp0,
9326 #[doc = "MMU1_ISP1"]
9327 pub mmu1_isp1: Mmu1Isp1,
9328 #[doc = "MMU_HDCP"]
9329 pub mmu_hdcp: MmuHdcp,
9330 #[doc = "MMU_IEP"]
9331 pub mmu_iep: MmuIep,
9332 #[doc = "MMU_RKVDEC_R"]
9333 pub mmu_rkvdec_r: MmuRkvdecR,
9334 #[doc = "MMU_RKVDEC_W"]
9335 pub mmu_rkvdec_w: MmuRkvdecW,
9336 #[doc = "MMU_VOPB"]
9337 pub mmu_vopb: MmuVopb,
9338 #[doc = "MMU_VOPL"]
9339 pub mmu_vopl: MmuVopl,
9340 #[doc = "MMU_VPU"]
9341 pub mmu_vpu: MmuVpu,
9342 #[doc = "MSCH"]
9343 pub msch: Msch,
9344 #[doc = "MSCH0"]
9345 pub msch0: Msch0,
9346 #[doc = "MSCH1"]
9347 pub msch1: Msch1,
9348 #[doc = "PCIE_CLIENT"]
9349 pub pcie_client: PcieClient,
9350 #[doc = "PCIE_CORE"]
9351 pub pcie_core: PcieCore,
9352 #[doc = "PMU"]
9353 pub pmu: Pmu,
9354 #[doc = "PMUCRU"]
9355 pub pmucru: Pmucru,
9356 #[doc = "PMUGRF"]
9357 pub pmugrf: Pmugrf,
9358 #[doc = "PREF_CACHE"]
9359 pub pref_cache: PrefCache,
9360 #[doc = "PREF_CACHE_RKVDEC_CHROMA"]
9361 pub pref_cache_rkvdec_chroma: PrefCacheRkvdecChroma,
9362 #[doc = "PREF_CACHE_RKVDEC_LUMA"]
9363 pub pref_cache_rkvdec_luma: PrefCacheRkvdecLuma,
9364 #[doc = "PREF_CACHE_VPU"]
9365 pub pref_cache_vpu: PrefCacheVpu,
9366 #[doc = "PROBE"]
9367 pub probe: Probe,
9368 #[doc = "PROBE_CCI_MSCH0"]
9369 pub probe_cci_msch0: ProbeCciMsch0,
9370 #[doc = "PROBE_CCI_MSCH1"]
9371 pub probe_cci_msch1: ProbeCciMsch1,
9372 #[doc = "PROBE_GPU_MSCH0"]
9373 pub probe_gpu_msch0: ProbeGpuMsch0,
9374 #[doc = "PROBE_GPU_MSCH1"]
9375 pub probe_gpu_msch1: ProbeGpuMsch1,
9376 #[doc = "PROBE_PERIHP_MSCH0"]
9377 pub probe_perihp_msch0: ProbePerihpMsch0,
9378 #[doc = "PROBE_PERIHP_MSCH1"]
9379 pub probe_perihp_msch1: ProbePerihpMsch1,
9380 #[doc = "PROBE_PERILP_MSCH0"]
9381 pub probe_perilp_msch0: ProbePerilpMsch0,
9382 #[doc = "PROBE_PERILP_MSCH1"]
9383 pub probe_perilp_msch1: ProbePerilpMsch1,
9384 #[doc = "PROBE_VIDEO_MSCH0"]
9385 pub probe_video_msch0: ProbeVideoMsch0,
9386 #[doc = "PROBE_VIDEO_MSCH1"]
9387 pub probe_video_msch1: ProbeVideoMsch1,
9388 #[doc = "PROBE_VIO0_MSCH0"]
9389 pub probe_vio0_msch0: ProbeVio0Msch0,
9390 #[doc = "PROBE_VIO0_MSCH1"]
9391 pub probe_vio0_msch1: ProbeVio0Msch1,
9392 #[doc = "PROBE_VIO1_MSCH0"]
9393 pub probe_vio1_msch0: ProbeVio1Msch0,
9394 #[doc = "PROBE_VIO1_MSCH1"]
9395 pub probe_vio1_msch1: ProbeVio1Msch1,
9396 #[doc = "PWM"]
9397 pub pwm: Pwm,
9398 #[doc = "QOS"]
9399 pub qos: Qos,
9400 #[doc = "QOS_CCI_M0"]
9401 pub qos_cci_m0: QosCciM0,
9402 #[doc = "QOS_CCI_M1"]
9403 pub qos_cci_m1: QosCciM1,
9404 #[doc = "QOS_CRYPTO0"]
9405 pub qos_crypto0: QosCrypto0,
9406 #[doc = "QOS_CRYPTO1"]
9407 pub qos_crypto1: QosCrypto1,
9408 #[doc = "QOS_DCF"]
9409 pub qos_dcf: QosDcf,
9410 #[doc = "QOS_DMAC0"]
9411 pub qos_dmac0: QosDmac0,
9412 #[doc = "QOS_DMAC1"]
9413 pub qos_dmac1: QosDmac1,
9414 #[doc = "QOS_EMMC"]
9415 pub qos_emmc: QosEmmc,
9416 #[doc = "QOS_GIC"]
9417 pub qos_gic: QosGic,
9418 #[doc = "QOS_GMAC"]
9419 pub qos_gmac: QosGmac,
9420 #[doc = "QOS_GPU"]
9421 pub qos_gpu: QosGpu,
9422 #[doc = "QOS_HDCP"]
9423 pub qos_hdcp: QosHdcp,
9424 #[doc = "QOS_HSIC"]
9425 pub qos_hsic: QosHsic,
9426 #[doc = "QOS_IEP"]
9427 pub qos_iep: QosIep,
9428 #[doc = "QOS_ISP0_M0"]
9429 pub qos_isp0_m0: QosIsp0M0,
9430 #[doc = "QOS_ISP0_M1"]
9431 pub qos_isp0_m1: QosIsp0M1,
9432 #[doc = "QOS_ISP1_M0"]
9433 pub qos_isp1_m0: QosIsp1M0,
9434 #[doc = "QOS_ISP1_M1"]
9435 pub qos_isp1_m1: QosIsp1M1,
9436 #[doc = "QOS_PCIE"]
9437 pub qos_pcie: QosPcie,
9438 #[doc = "QOS_PERIHP_NSP"]
9439 pub qos_perihp_nsp: QosPerihpNsp,
9440 #[doc = "QOS_PERILPSLV_NSP"]
9441 pub qos_perilpslv_nsp: QosPerilpslvNsp,
9442 #[doc = "QOS_PERILP_NSP"]
9443 pub qos_perilp_nsp: QosPerilpNsp,
9444 #[doc = "QOS_PERI_CM0"]
9445 pub qos_peri_cm0: QosPeriCm0,
9446 #[doc = "QOS_PMU_CM0"]
9447 pub qos_pmu_cm0: QosPmuCm0,
9448 #[doc = "QOS_RGA_R"]
9449 pub qos_rga_r: QosRgaR,
9450 #[doc = "QOS_RGA_W"]
9451 pub qos_rga_w: QosRgaW,
9452 #[doc = "QOS_SDIO"]
9453 pub qos_sdio: QosSdio,
9454 #[doc = "QOS_SDMMC"]
9455 pub qos_sdmmc: QosSdmmc,
9456 #[doc = "QOS_USB_HOST0"]
9457 pub qos_usb_host0: QosUsbHost0,
9458 #[doc = "QOS_USB_HOST1"]
9459 pub qos_usb_host1: QosUsbHost1,
9460 #[doc = "QOS_USB_OTG0"]
9461 pub qos_usb_otg0: QosUsbOtg0,
9462 #[doc = "QOS_USB_OTG1"]
9463 pub qos_usb_otg1: QosUsbOtg1,
9464 #[doc = "QOS_VIDEO_M0"]
9465 pub qos_video_m0: QosVideoM0,
9466 #[doc = "QOS_VIDEO_M1_R"]
9467 pub qos_video_m1_r: QosVideoM1R,
9468 #[doc = "QOS_VIDEO_M1_W"]
9469 pub qos_video_m1_w: QosVideoM1W,
9470 #[doc = "QOS_VOP_BIG_R"]
9471 pub qos_vop_big_r: QosVopBigR,
9472 #[doc = "QOS_VOP_BIG_W"]
9473 pub qos_vop_big_w: QosVopBigW,
9474 #[doc = "QOS_VOP_LITTLE"]
9475 pub qos_vop_little: QosVopLittle,
9476 #[doc = "RGA2"]
9477 pub rga2: Rga2,
9478 #[doc = "RKI2C"]
9479 pub rki2c: Rki2c,
9480 #[doc = "RKI2C0"]
9481 pub rki2c0: Rki2c0,
9482 #[doc = "RKI2C1"]
9483 pub rki2c1: Rki2c1,
9484 #[doc = "RKI2C2"]
9485 pub rki2c2: Rki2c2,
9486 #[doc = "RKI2C3"]
9487 pub rki2c3: Rki2c3,
9488 #[doc = "RKI2C4"]
9489 pub rki2c4: Rki2c4,
9490 #[doc = "RKI2C5"]
9491 pub rki2c5: Rki2c5,
9492 #[doc = "RKI2C6"]
9493 pub rki2c6: Rki2c6,
9494 #[doc = "RKI2C7"]
9495 pub rki2c7: Rki2c7,
9496 #[doc = "RKI2C8"]
9497 pub rki2c8: Rki2c8,
9498 #[doc = "RKVDEC"]
9499 pub rkvdec: Rkvdec,
9500 #[doc = "SARADC"]
9501 pub saradc: Saradc,
9502 #[doc = "SDMMC"]
9503 pub sdmmc: Sdmmc,
9504 #[doc = "SPDIF"]
9505 pub spdif: Spdif,
9506 #[doc = "SPI"]
9507 pub spi: Spi,
9508 #[doc = "SPI0"]
9509 pub spi0: Spi0,
9510 #[doc = "SPI1"]
9511 pub spi1: Spi1,
9512 #[doc = "SPI2"]
9513 pub spi2: Spi2,
9514 #[doc = "SPI3"]
9515 pub spi3: Spi3,
9516 #[doc = "SPI4"]
9517 pub spi4: Spi4,
9518 #[doc = "SPI5"]
9519 pub spi5: Spi5,
9520 #[doc = "TIMER"]
9521 pub timer: Timer,
9522 #[doc = "TIMER0"]
9523 pub timer0: Timer0,
9524 #[doc = "TIMER1"]
9525 pub timer1: Timer1,
9526 #[doc = "TIMER10"]
9527 pub timer10: Timer10,
9528 #[doc = "TIMER11"]
9529 pub timer11: Timer11,
9530 #[doc = "TIMER2"]
9531 pub timer2: Timer2,
9532 #[doc = "TIMER3"]
9533 pub timer3: Timer3,
9534 #[doc = "TIMER4"]
9535 pub timer4: Timer4,
9536 #[doc = "TIMER5"]
9537 pub timer5: Timer5,
9538 #[doc = "TIMER6"]
9539 pub timer6: Timer6,
9540 #[doc = "TIMER7"]
9541 pub timer7: Timer7,
9542 #[doc = "TIMER8"]
9543 pub timer8: Timer8,
9544 #[doc = "TIMER9"]
9545 pub timer9: Timer9,
9546 #[doc = "PMUTIMER0"]
9547 pub pmutimer0: Pmutimer0,
9548 #[doc = "PMUTIMER1"]
9549 pub pmutimer1: Pmutimer1,
9550 #[doc = "STIMER0"]
9551 pub stimer0: Stimer0,
9552 #[doc = "STIMER1"]
9553 pub stimer1: Stimer1,
9554 #[doc = "STIMER10"]
9555 pub stimer10: Stimer10,
9556 #[doc = "STIMER11"]
9557 pub stimer11: Stimer11,
9558 #[doc = "STIMER2"]
9559 pub stimer2: Stimer2,
9560 #[doc = "STIMER3"]
9561 pub stimer3: Stimer3,
9562 #[doc = "STIMER4"]
9563 pub stimer4: Stimer4,
9564 #[doc = "STIMER5"]
9565 pub stimer5: Stimer5,
9566 #[doc = "STIMER6"]
9567 pub stimer6: Stimer6,
9568 #[doc = "STIMER7"]
9569 pub stimer7: Stimer7,
9570 #[doc = "STIMER8"]
9571 pub stimer8: Stimer8,
9572 #[doc = "STIMER9"]
9573 pub stimer9: Stimer9,
9574 #[doc = "TSADC"]
9575 pub tsadc: Tsadc,
9576 #[doc = "TYPEC_PD"]
9577 pub typec_pd: TypecPd,
9578 #[doc = "TYPEC_PD0"]
9579 pub typec_pd0: TypecPd0,
9580 #[doc = "TYPEC_PD1"]
9581 pub typec_pd1: TypecPd1,
9582 #[doc = "TYPEC_PHY"]
9583 pub typec_phy: TypecPhy,
9584 #[doc = "TYPEC_PHY0"]
9585 pub typec_phy0: TypecPhy0,
9586 #[doc = "TYPEC_PHY1"]
9587 pub typec_phy1: TypecPhy1,
9588 #[doc = "UART"]
9589 pub uart: Uart,
9590 #[doc = "UART0"]
9591 pub uart0: Uart0,
9592 #[doc = "UART1"]
9593 pub uart1: Uart1,
9594 #[doc = "UART2"]
9595 pub uart2: Uart2,
9596 #[doc = "UART3"]
9597 pub uart3: Uart3,
9598 #[doc = "UART4"]
9599 pub uart4: Uart4,
9600 #[doc = "USB3"]
9601 pub usb3: Usb3,
9602 #[doc = "USB3_OTG0"]
9603 pub usb3_otg0: Usb3Otg0,
9604 #[doc = "USB3_OTG1"]
9605 pub usb3_otg1: Usb3Otg1,
9606 #[doc = "VDPU"]
9607 pub vdpu: Vdpu,
9608 #[doc = "VEPU"]
9609 pub vepu: Vepu,
9610 #[doc = "VOPB"]
9611 pub vopb: Vopb,
9612 #[doc = "VOPL"]
9613 pub vopl: Vopl,
9614 #[doc = "WDT"]
9615 pub wdt: Wdt,
9616 #[doc = "WDT0"]
9617 pub wdt0: Wdt0,
9618 #[doc = "WDT1"]
9619 pub wdt1: Wdt1,
9620 #[doc = "WDT2"]
9621 pub wdt2: Wdt2,
9622}
9623impl Peripherals {
9624 #[doc = r" Returns all the peripherals *once*."]
9625 #[cfg(feature = "critical-section")]
9626 #[inline]
9627 pub fn take() -> Option<Self> {
9628 critical_section::with(|_| {
9629 if unsafe { DEVICE_PERIPHERALS } {
9630 return None;
9631 }
9632 Some(unsafe { Peripherals::steal() })
9633 })
9634 }
9635 #[doc = r" Unchecked version of `Peripherals::take`."]
9636 #[doc = r""]
9637 #[doc = r" # Safety"]
9638 #[doc = r""]
9639 #[doc = r" Each of the returned peripherals must be used at most once."]
9640 #[inline]
9641 pub unsafe fn steal() -> Self {
9642 DEVICE_PERIPHERALS = true;
9643 Peripherals {
9644 cci500: Cci500 {
9645 _marker: PhantomData,
9646 },
9647 cru: Cru {
9648 _marker: PhantomData,
9649 },
9650 crypto: Crypto {
9651 _marker: PhantomData,
9652 },
9653 crypto0: Crypto0 {
9654 _marker: PhantomData,
9655 },
9656 crypto1: Crypto1 {
9657 _marker: PhantomData,
9658 },
9659 dcf: Dcf {
9660 _marker: PhantomData,
9661 },
9662 ddrc: Ddrc {
9663 _marker: PhantomData,
9664 },
9665 ddrc0: Ddrc0 {
9666 _marker: PhantomData,
9667 },
9668 ddrc1: Ddrc1 {
9669 _marker: PhantomData,
9670 },
9671 ddr_cic: DdrCic {
9672 _marker: PhantomData,
9673 },
9674 ddr_mon: DdrMon {
9675 _marker: PhantomData,
9676 },
9677 dmac: Dmac {
9678 _marker: PhantomData,
9679 },
9680 dmac0: Dmac0 {
9681 _marker: PhantomData,
9682 },
9683 dmac1: Dmac1 {
9684 _marker: PhantomData,
9685 },
9686 dp: Dp {
9687 _marker: PhantomData,
9688 },
9689 efuse: Efuse {
9690 _marker: PhantomData,
9691 },
9692 efuse0: Efuse0 {
9693 _marker: PhantomData,
9694 },
9695 efuse1: Efuse1 {
9696 _marker: PhantomData,
9697 },
9698 emmccore: Emmccore {
9699 _marker: PhantomData,
9700 },
9701 err_logger_msch: ErrLoggerMsch {
9702 _marker: PhantomData,
9703 },
9704 err_logger_msch0: ErrLoggerMsch0 {
9705 _marker: PhantomData,
9706 },
9707 err_logger_msch1: ErrLoggerMsch1 {
9708 _marker: PhantomData,
9709 },
9710 err_logger_slv: ErrLoggerSlv {
9711 _marker: PhantomData,
9712 },
9713 err_logger_slv0: ErrLoggerSlv0 {
9714 _marker: PhantomData,
9715 },
9716 err_logger_slv1: ErrLoggerSlv1 {
9717 _marker: PhantomData,
9718 },
9719 gmac: Gmac {
9720 _marker: PhantomData,
9721 },
9722 gpio: Gpio {
9723 _marker: PhantomData,
9724 },
9725 gpio0: Gpio0 {
9726 _marker: PhantomData,
9727 },
9728 gpio1: Gpio1 {
9729 _marker: PhantomData,
9730 },
9731 gpio2: Gpio2 {
9732 _marker: PhantomData,
9733 },
9734 gpio3: Gpio3 {
9735 _marker: PhantomData,
9736 },
9737 gpio4: Gpio4 {
9738 _marker: PhantomData,
9739 },
9740 grf: Grf {
9741 _marker: PhantomData,
9742 },
9743 hdmi: Hdmi {
9744 _marker: PhantomData,
9745 },
9746 i2s: I2s {
9747 _marker: PhantomData,
9748 },
9749 i2s0: I2s0 {
9750 _marker: PhantomData,
9751 },
9752 i2s1: I2s1 {
9753 _marker: PhantomData,
9754 },
9755 i2s2: I2s2 {
9756 _marker: PhantomData,
9757 },
9758 iep: Iep {
9759 _marker: PhantomData,
9760 },
9761 isp: Isp {
9762 _marker: PhantomData,
9763 },
9764 isp0: Isp0 {
9765 _marker: PhantomData,
9766 },
9767 isp1: Isp1 {
9768 _marker: PhantomData,
9769 },
9770 mailbox: Mailbox {
9771 _marker: PhantomData,
9772 },
9773 mailbox0: Mailbox0 {
9774 _marker: PhantomData,
9775 },
9776 mailbox1: Mailbox1 {
9777 _marker: PhantomData,
9778 },
9779 mipi_dsi_host: MipiDsiHost {
9780 _marker: PhantomData,
9781 },
9782 mipi_dsi_host0: MipiDsiHost0 {
9783 _marker: PhantomData,
9784 },
9785 mipi_dsi_host1: MipiDsiHost1 {
9786 _marker: PhantomData,
9787 },
9788 mmu: Mmu {
9789 _marker: PhantomData,
9790 },
9791 mmu0_isp0: Mmu0Isp0 {
9792 _marker: PhantomData,
9793 },
9794 mmu0_isp1: Mmu0Isp1 {
9795 _marker: PhantomData,
9796 },
9797 mmu1_isp0: Mmu1Isp0 {
9798 _marker: PhantomData,
9799 },
9800 mmu1_isp1: Mmu1Isp1 {
9801 _marker: PhantomData,
9802 },
9803 mmu_hdcp: MmuHdcp {
9804 _marker: PhantomData,
9805 },
9806 mmu_iep: MmuIep {
9807 _marker: PhantomData,
9808 },
9809 mmu_rkvdec_r: MmuRkvdecR {
9810 _marker: PhantomData,
9811 },
9812 mmu_rkvdec_w: MmuRkvdecW {
9813 _marker: PhantomData,
9814 },
9815 mmu_vopb: MmuVopb {
9816 _marker: PhantomData,
9817 },
9818 mmu_vopl: MmuVopl {
9819 _marker: PhantomData,
9820 },
9821 mmu_vpu: MmuVpu {
9822 _marker: PhantomData,
9823 },
9824 msch: Msch {
9825 _marker: PhantomData,
9826 },
9827 msch0: Msch0 {
9828 _marker: PhantomData,
9829 },
9830 msch1: Msch1 {
9831 _marker: PhantomData,
9832 },
9833 pcie_client: PcieClient {
9834 _marker: PhantomData,
9835 },
9836 pcie_core: PcieCore {
9837 _marker: PhantomData,
9838 },
9839 pmu: Pmu {
9840 _marker: PhantomData,
9841 },
9842 pmucru: Pmucru {
9843 _marker: PhantomData,
9844 },
9845 pmugrf: Pmugrf {
9846 _marker: PhantomData,
9847 },
9848 pref_cache: PrefCache {
9849 _marker: PhantomData,
9850 },
9851 pref_cache_rkvdec_chroma: PrefCacheRkvdecChroma {
9852 _marker: PhantomData,
9853 },
9854 pref_cache_rkvdec_luma: PrefCacheRkvdecLuma {
9855 _marker: PhantomData,
9856 },
9857 pref_cache_vpu: PrefCacheVpu {
9858 _marker: PhantomData,
9859 },
9860 probe: Probe {
9861 _marker: PhantomData,
9862 },
9863 probe_cci_msch0: ProbeCciMsch0 {
9864 _marker: PhantomData,
9865 },
9866 probe_cci_msch1: ProbeCciMsch1 {
9867 _marker: PhantomData,
9868 },
9869 probe_gpu_msch0: ProbeGpuMsch0 {
9870 _marker: PhantomData,
9871 },
9872 probe_gpu_msch1: ProbeGpuMsch1 {
9873 _marker: PhantomData,
9874 },
9875 probe_perihp_msch0: ProbePerihpMsch0 {
9876 _marker: PhantomData,
9877 },
9878 probe_perihp_msch1: ProbePerihpMsch1 {
9879 _marker: PhantomData,
9880 },
9881 probe_perilp_msch0: ProbePerilpMsch0 {
9882 _marker: PhantomData,
9883 },
9884 probe_perilp_msch1: ProbePerilpMsch1 {
9885 _marker: PhantomData,
9886 },
9887 probe_video_msch0: ProbeVideoMsch0 {
9888 _marker: PhantomData,
9889 },
9890 probe_video_msch1: ProbeVideoMsch1 {
9891 _marker: PhantomData,
9892 },
9893 probe_vio0_msch0: ProbeVio0Msch0 {
9894 _marker: PhantomData,
9895 },
9896 probe_vio0_msch1: ProbeVio0Msch1 {
9897 _marker: PhantomData,
9898 },
9899 probe_vio1_msch0: ProbeVio1Msch0 {
9900 _marker: PhantomData,
9901 },
9902 probe_vio1_msch1: ProbeVio1Msch1 {
9903 _marker: PhantomData,
9904 },
9905 pwm: Pwm {
9906 _marker: PhantomData,
9907 },
9908 qos: Qos {
9909 _marker: PhantomData,
9910 },
9911 qos_cci_m0: QosCciM0 {
9912 _marker: PhantomData,
9913 },
9914 qos_cci_m1: QosCciM1 {
9915 _marker: PhantomData,
9916 },
9917 qos_crypto0: QosCrypto0 {
9918 _marker: PhantomData,
9919 },
9920 qos_crypto1: QosCrypto1 {
9921 _marker: PhantomData,
9922 },
9923 qos_dcf: QosDcf {
9924 _marker: PhantomData,
9925 },
9926 qos_dmac0: QosDmac0 {
9927 _marker: PhantomData,
9928 },
9929 qos_dmac1: QosDmac1 {
9930 _marker: PhantomData,
9931 },
9932 qos_emmc: QosEmmc {
9933 _marker: PhantomData,
9934 },
9935 qos_gic: QosGic {
9936 _marker: PhantomData,
9937 },
9938 qos_gmac: QosGmac {
9939 _marker: PhantomData,
9940 },
9941 qos_gpu: QosGpu {
9942 _marker: PhantomData,
9943 },
9944 qos_hdcp: QosHdcp {
9945 _marker: PhantomData,
9946 },
9947 qos_hsic: QosHsic {
9948 _marker: PhantomData,
9949 },
9950 qos_iep: QosIep {
9951 _marker: PhantomData,
9952 },
9953 qos_isp0_m0: QosIsp0M0 {
9954 _marker: PhantomData,
9955 },
9956 qos_isp0_m1: QosIsp0M1 {
9957 _marker: PhantomData,
9958 },
9959 qos_isp1_m0: QosIsp1M0 {
9960 _marker: PhantomData,
9961 },
9962 qos_isp1_m1: QosIsp1M1 {
9963 _marker: PhantomData,
9964 },
9965 qos_pcie: QosPcie {
9966 _marker: PhantomData,
9967 },
9968 qos_perihp_nsp: QosPerihpNsp {
9969 _marker: PhantomData,
9970 },
9971 qos_perilpslv_nsp: QosPerilpslvNsp {
9972 _marker: PhantomData,
9973 },
9974 qos_perilp_nsp: QosPerilpNsp {
9975 _marker: PhantomData,
9976 },
9977 qos_peri_cm0: QosPeriCm0 {
9978 _marker: PhantomData,
9979 },
9980 qos_pmu_cm0: QosPmuCm0 {
9981 _marker: PhantomData,
9982 },
9983 qos_rga_r: QosRgaR {
9984 _marker: PhantomData,
9985 },
9986 qos_rga_w: QosRgaW {
9987 _marker: PhantomData,
9988 },
9989 qos_sdio: QosSdio {
9990 _marker: PhantomData,
9991 },
9992 qos_sdmmc: QosSdmmc {
9993 _marker: PhantomData,
9994 },
9995 qos_usb_host0: QosUsbHost0 {
9996 _marker: PhantomData,
9997 },
9998 qos_usb_host1: QosUsbHost1 {
9999 _marker: PhantomData,
10000 },
10001 qos_usb_otg0: QosUsbOtg0 {
10002 _marker: PhantomData,
10003 },
10004 qos_usb_otg1: QosUsbOtg1 {
10005 _marker: PhantomData,
10006 },
10007 qos_video_m0: QosVideoM0 {
10008 _marker: PhantomData,
10009 },
10010 qos_video_m1_r: QosVideoM1R {
10011 _marker: PhantomData,
10012 },
10013 qos_video_m1_w: QosVideoM1W {
10014 _marker: PhantomData,
10015 },
10016 qos_vop_big_r: QosVopBigR {
10017 _marker: PhantomData,
10018 },
10019 qos_vop_big_w: QosVopBigW {
10020 _marker: PhantomData,
10021 },
10022 qos_vop_little: QosVopLittle {
10023 _marker: PhantomData,
10024 },
10025 rga2: Rga2 {
10026 _marker: PhantomData,
10027 },
10028 rki2c: Rki2c {
10029 _marker: PhantomData,
10030 },
10031 rki2c0: Rki2c0 {
10032 _marker: PhantomData,
10033 },
10034 rki2c1: Rki2c1 {
10035 _marker: PhantomData,
10036 },
10037 rki2c2: Rki2c2 {
10038 _marker: PhantomData,
10039 },
10040 rki2c3: Rki2c3 {
10041 _marker: PhantomData,
10042 },
10043 rki2c4: Rki2c4 {
10044 _marker: PhantomData,
10045 },
10046 rki2c5: Rki2c5 {
10047 _marker: PhantomData,
10048 },
10049 rki2c6: Rki2c6 {
10050 _marker: PhantomData,
10051 },
10052 rki2c7: Rki2c7 {
10053 _marker: PhantomData,
10054 },
10055 rki2c8: Rki2c8 {
10056 _marker: PhantomData,
10057 },
10058 rkvdec: Rkvdec {
10059 _marker: PhantomData,
10060 },
10061 saradc: Saradc {
10062 _marker: PhantomData,
10063 },
10064 sdmmc: Sdmmc {
10065 _marker: PhantomData,
10066 },
10067 spdif: Spdif {
10068 _marker: PhantomData,
10069 },
10070 spi: Spi {
10071 _marker: PhantomData,
10072 },
10073 spi0: Spi0 {
10074 _marker: PhantomData,
10075 },
10076 spi1: Spi1 {
10077 _marker: PhantomData,
10078 },
10079 spi2: Spi2 {
10080 _marker: PhantomData,
10081 },
10082 spi3: Spi3 {
10083 _marker: PhantomData,
10084 },
10085 spi4: Spi4 {
10086 _marker: PhantomData,
10087 },
10088 spi5: Spi5 {
10089 _marker: PhantomData,
10090 },
10091 timer: Timer {
10092 _marker: PhantomData,
10093 },
10094 timer0: Timer0 {
10095 _marker: PhantomData,
10096 },
10097 timer1: Timer1 {
10098 _marker: PhantomData,
10099 },
10100 timer10: Timer10 {
10101 _marker: PhantomData,
10102 },
10103 timer11: Timer11 {
10104 _marker: PhantomData,
10105 },
10106 timer2: Timer2 {
10107 _marker: PhantomData,
10108 },
10109 timer3: Timer3 {
10110 _marker: PhantomData,
10111 },
10112 timer4: Timer4 {
10113 _marker: PhantomData,
10114 },
10115 timer5: Timer5 {
10116 _marker: PhantomData,
10117 },
10118 timer6: Timer6 {
10119 _marker: PhantomData,
10120 },
10121 timer7: Timer7 {
10122 _marker: PhantomData,
10123 },
10124 timer8: Timer8 {
10125 _marker: PhantomData,
10126 },
10127 timer9: Timer9 {
10128 _marker: PhantomData,
10129 },
10130 pmutimer0: Pmutimer0 {
10131 _marker: PhantomData,
10132 },
10133 pmutimer1: Pmutimer1 {
10134 _marker: PhantomData,
10135 },
10136 stimer0: Stimer0 {
10137 _marker: PhantomData,
10138 },
10139 stimer1: Stimer1 {
10140 _marker: PhantomData,
10141 },
10142 stimer10: Stimer10 {
10143 _marker: PhantomData,
10144 },
10145 stimer11: Stimer11 {
10146 _marker: PhantomData,
10147 },
10148 stimer2: Stimer2 {
10149 _marker: PhantomData,
10150 },
10151 stimer3: Stimer3 {
10152 _marker: PhantomData,
10153 },
10154 stimer4: Stimer4 {
10155 _marker: PhantomData,
10156 },
10157 stimer5: Stimer5 {
10158 _marker: PhantomData,
10159 },
10160 stimer6: Stimer6 {
10161 _marker: PhantomData,
10162 },
10163 stimer7: Stimer7 {
10164 _marker: PhantomData,
10165 },
10166 stimer8: Stimer8 {
10167 _marker: PhantomData,
10168 },
10169 stimer9: Stimer9 {
10170 _marker: PhantomData,
10171 },
10172 tsadc: Tsadc {
10173 _marker: PhantomData,
10174 },
10175 typec_pd: TypecPd {
10176 _marker: PhantomData,
10177 },
10178 typec_pd0: TypecPd0 {
10179 _marker: PhantomData,
10180 },
10181 typec_pd1: TypecPd1 {
10182 _marker: PhantomData,
10183 },
10184 typec_phy: TypecPhy {
10185 _marker: PhantomData,
10186 },
10187 typec_phy0: TypecPhy0 {
10188 _marker: PhantomData,
10189 },
10190 typec_phy1: TypecPhy1 {
10191 _marker: PhantomData,
10192 },
10193 uart: Uart {
10194 _marker: PhantomData,
10195 },
10196 uart0: Uart0 {
10197 _marker: PhantomData,
10198 },
10199 uart1: Uart1 {
10200 _marker: PhantomData,
10201 },
10202 uart2: Uart2 {
10203 _marker: PhantomData,
10204 },
10205 uart3: Uart3 {
10206 _marker: PhantomData,
10207 },
10208 uart4: Uart4 {
10209 _marker: PhantomData,
10210 },
10211 usb3: Usb3 {
10212 _marker: PhantomData,
10213 },
10214 usb3_otg0: Usb3Otg0 {
10215 _marker: PhantomData,
10216 },
10217 usb3_otg1: Usb3Otg1 {
10218 _marker: PhantomData,
10219 },
10220 vdpu: Vdpu {
10221 _marker: PhantomData,
10222 },
10223 vepu: Vepu {
10224 _marker: PhantomData,
10225 },
10226 vopb: Vopb {
10227 _marker: PhantomData,
10228 },
10229 vopl: Vopl {
10230 _marker: PhantomData,
10231 },
10232 wdt: Wdt {
10233 _marker: PhantomData,
10234 },
10235 wdt0: Wdt0 {
10236 _marker: PhantomData,
10237 },
10238 wdt1: Wdt1 {
10239 _marker: PhantomData,
10240 },
10241 wdt2: Wdt2 {
10242 _marker: PhantomData,
10243 },
10244 }
10245 }
10246}