1#![doc = "Peripheral access API for BCM2711_LPA microcontrollers (generated using svd2rust v0.31.5 ( ))\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.31.5/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 = 2;
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 = "Mailboxes for talking to/from VideoCore"]
18pub struct VCMAILBOX {
19 _marker: PhantomData<*const ()>,
20}
21unsafe impl Send for VCMAILBOX {}
22impl VCMAILBOX {
23 #[doc = r"Pointer to the register block"]
24 pub const PTR: *const vcmailbox::RegisterBlock = 0xfe00_b880 as *const _;
25 #[doc = r"Return the pointer to the register block"]
26 #[inline(always)]
27 pub const fn ptr() -> *const vcmailbox::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 VCMAILBOX {
50 type Target = vcmailbox::RegisterBlock;
51 #[inline(always)]
52 fn deref(&self) -> &Self::Target {
53 unsafe { &*Self::PTR }
54 }
55}
56impl core::fmt::Debug for VCMAILBOX {
57 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
58 f.debug_struct("VCMAILBOX").finish()
59 }
60}
61#[doc = "Mailboxes for talking to/from VideoCore"]
62pub mod vcmailbox;
63#[doc = "Broadcom Clock Manager"]
64pub struct CM_PCM {
65 _marker: PhantomData<*const ()>,
66}
67unsafe impl Send for CM_PCM {}
68impl CM_PCM {
69 #[doc = r"Pointer to the register block"]
70 pub const PTR: *const cm_pcm::RegisterBlock = 0xfe10_1098 as *const _;
71 #[doc = r"Return the pointer to the register block"]
72 #[inline(always)]
73 pub const fn ptr() -> *const cm_pcm::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 CM_PCM {
96 type Target = cm_pcm::RegisterBlock;
97 #[inline(always)]
98 fn deref(&self) -> &Self::Target {
99 unsafe { &*Self::PTR }
100 }
101}
102impl core::fmt::Debug for CM_PCM {
103 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
104 f.debug_struct("CM_PCM").finish()
105 }
106}
107#[doc = "Broadcom Clock Manager"]
108pub mod cm_pcm;
109#[doc = "Broadcom Clock Manager"]
110pub struct CM_PWM {
111 _marker: PhantomData<*const ()>,
112}
113unsafe impl Send for CM_PWM {}
114impl CM_PWM {
115 #[doc = r"Pointer to the register block"]
116 pub const PTR: *const cm_pcm::RegisterBlock = 0xfe10_10a0 as *const _;
117 #[doc = r"Return the pointer to the register block"]
118 #[inline(always)]
119 pub const fn ptr() -> *const cm_pcm::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 CM_PWM {
142 type Target = cm_pcm::RegisterBlock;
143 #[inline(always)]
144 fn deref(&self) -> &Self::Target {
145 unsafe { &*Self::PTR }
146 }
147}
148impl core::fmt::Debug for CM_PWM {
149 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
150 f.debug_struct("CM_PWM").finish()
151 }
152}
153#[doc = "Broadcom Clock Manager"]
154pub use self::cm_pcm as cm_pwm;
155#[doc = "Pin level and mux control"]
156pub struct GPIO {
157 _marker: PhantomData<*const ()>,
158}
159unsafe impl Send for GPIO {}
160impl GPIO {
161 #[doc = r"Pointer to the register block"]
162 pub const PTR: *const gpio::RegisterBlock = 0xfe20_0000 as *const _;
163 #[doc = r"Return the pointer to the register block"]
164 #[inline(always)]
165 pub const fn ptr() -> *const gpio::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 GPIO {
188 type Target = gpio::RegisterBlock;
189 #[inline(always)]
190 fn deref(&self) -> &Self::Target {
191 unsafe { &*Self::PTR }
192 }
193}
194impl core::fmt::Debug for GPIO {
195 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
196 f.debug_struct("GPIO").finish()
197 }
198}
199#[doc = "Pin level and mux control"]
200pub mod gpio;
201#[doc = "Broadcom System Timer"]
202pub struct SYSTMR {
203 _marker: PhantomData<*const ()>,
204}
205unsafe impl Send for SYSTMR {}
206impl SYSTMR {
207 #[doc = r"Pointer to the register block"]
208 pub const PTR: *const systmr::RegisterBlock = 0xfe00_3000 as *const _;
209 #[doc = r"Return the pointer to the register block"]
210 #[inline(always)]
211 pub const fn ptr() -> *const systmr::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 SYSTMR {
234 type Target = systmr::RegisterBlock;
235 #[inline(always)]
236 fn deref(&self) -> &Self::Target {
237 unsafe { &*Self::PTR }
238 }
239}
240impl core::fmt::Debug for SYSTMR {
241 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
242 f.debug_struct("SYSTMR").finish()
243 }
244}
245#[doc = "Broadcom System Timer"]
246pub mod systmr;
247#[doc = "ARM Prime Cell PL011"]
248pub struct UART0 {
249 _marker: PhantomData<*const ()>,
250}
251unsafe impl Send for UART0 {}
252impl UART0 {
253 #[doc = r"Pointer to the register block"]
254 pub const PTR: *const uart0::RegisterBlock = 0xfe20_1000 as *const _;
255 #[doc = r"Return the pointer to the register block"]
256 #[inline(always)]
257 pub const fn ptr() -> *const uart0::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 UART0 {
280 type Target = uart0::RegisterBlock;
281 #[inline(always)]
282 fn deref(&self) -> &Self::Target {
283 unsafe { &*Self::PTR }
284 }
285}
286impl core::fmt::Debug for UART0 {
287 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
288 f.debug_struct("UART0").finish()
289 }
290}
291#[doc = "ARM Prime Cell PL011"]
292pub mod uart0;
293#[doc = "ARM Prime Cell PL011"]
294pub struct UART2 {
295 _marker: PhantomData<*const ()>,
296}
297unsafe impl Send for UART2 {}
298impl UART2 {
299 #[doc = r"Pointer to the register block"]
300 pub const PTR: *const uart0::RegisterBlock = 0xfe20_1400 as *const _;
301 #[doc = r"Return the pointer to the register block"]
302 #[inline(always)]
303 pub const fn ptr() -> *const uart0::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 UART2 {
326 type Target = uart0::RegisterBlock;
327 #[inline(always)]
328 fn deref(&self) -> &Self::Target {
329 unsafe { &*Self::PTR }
330 }
331}
332impl core::fmt::Debug for UART2 {
333 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
334 f.debug_struct("UART2").finish()
335 }
336}
337#[doc = "ARM Prime Cell PL011"]
338pub use self::uart0 as uart2;
339#[doc = "ARM Prime Cell PL011"]
340pub struct UART3 {
341 _marker: PhantomData<*const ()>,
342}
343unsafe impl Send for UART3 {}
344impl UART3 {
345 #[doc = r"Pointer to the register block"]
346 pub const PTR: *const uart0::RegisterBlock = 0xfe20_1600 as *const _;
347 #[doc = r"Return the pointer to the register block"]
348 #[inline(always)]
349 pub const fn ptr() -> *const uart0::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 UART3 {
372 type Target = uart0::RegisterBlock;
373 #[inline(always)]
374 fn deref(&self) -> &Self::Target {
375 unsafe { &*Self::PTR }
376 }
377}
378impl core::fmt::Debug for UART3 {
379 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
380 f.debug_struct("UART3").finish()
381 }
382}
383#[doc = "ARM Prime Cell PL011"]
384pub use self::uart0 as uart3;
385#[doc = "ARM Prime Cell PL011"]
386pub struct UART4 {
387 _marker: PhantomData<*const ()>,
388}
389unsafe impl Send for UART4 {}
390impl UART4 {
391 #[doc = r"Pointer to the register block"]
392 pub const PTR: *const uart0::RegisterBlock = 0xfe20_1800 as *const _;
393 #[doc = r"Return the pointer to the register block"]
394 #[inline(always)]
395 pub const fn ptr() -> *const uart0::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 UART4 {
418 type Target = uart0::RegisterBlock;
419 #[inline(always)]
420 fn deref(&self) -> &Self::Target {
421 unsafe { &*Self::PTR }
422 }
423}
424impl core::fmt::Debug for UART4 {
425 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
426 f.debug_struct("UART4").finish()
427 }
428}
429#[doc = "ARM Prime Cell PL011"]
430pub use self::uart0 as uart4;
431#[doc = "ARM Prime Cell PL011"]
432pub struct UART5 {
433 _marker: PhantomData<*const ()>,
434}
435unsafe impl Send for UART5 {}
436impl UART5 {
437 #[doc = r"Pointer to the register block"]
438 pub const PTR: *const uart0::RegisterBlock = 0xfe20_1a00 as *const _;
439 #[doc = r"Return the pointer to the register block"]
440 #[inline(always)]
441 pub const fn ptr() -> *const uart0::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 UART5 {
464 type Target = uart0::RegisterBlock;
465 #[inline(always)]
466 fn deref(&self) -> &Self::Target {
467 unsafe { &*Self::PTR }
468 }
469}
470impl core::fmt::Debug for UART5 {
471 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
472 f.debug_struct("UART5").finish()
473 }
474}
475#[doc = "ARM Prime Cell PL011"]
476pub use self::uart0 as uart5;
477#[doc = "Broadcom SPI Controller"]
478pub struct SPI0 {
479 _marker: PhantomData<*const ()>,
480}
481unsafe impl Send for SPI0 {}
482impl SPI0 {
483 #[doc = r"Pointer to the register block"]
484 pub const PTR: *const spi0::RegisterBlock = 0xfe20_4000 as *const _;
485 #[doc = r"Return the pointer to the register block"]
486 #[inline(always)]
487 pub const fn ptr() -> *const spi0::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 SPI0 {
510 type Target = spi0::RegisterBlock;
511 #[inline(always)]
512 fn deref(&self) -> &Self::Target {
513 unsafe { &*Self::PTR }
514 }
515}
516impl core::fmt::Debug for SPI0 {
517 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
518 f.debug_struct("SPI0").finish()
519 }
520}
521#[doc = "Broadcom SPI Controller"]
522pub mod spi0;
523#[doc = "Broadcom SPI Controller"]
524pub struct SPI3 {
525 _marker: PhantomData<*const ()>,
526}
527unsafe impl Send for SPI3 {}
528impl SPI3 {
529 #[doc = r"Pointer to the register block"]
530 pub const PTR: *const spi0::RegisterBlock = 0xfe20_4600 as *const _;
531 #[doc = r"Return the pointer to the register block"]
532 #[inline(always)]
533 pub const fn ptr() -> *const spi0::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 SPI3 {
556 type Target = spi0::RegisterBlock;
557 #[inline(always)]
558 fn deref(&self) -> &Self::Target {
559 unsafe { &*Self::PTR }
560 }
561}
562impl core::fmt::Debug for SPI3 {
563 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
564 f.debug_struct("SPI3").finish()
565 }
566}
567#[doc = "Broadcom SPI Controller"]
568pub use self::spi0 as spi3;
569#[doc = "Broadcom SPI Controller"]
570pub struct SPI4 {
571 _marker: PhantomData<*const ()>,
572}
573unsafe impl Send for SPI4 {}
574impl SPI4 {
575 #[doc = r"Pointer to the register block"]
576 pub const PTR: *const spi0::RegisterBlock = 0xfe20_4800 as *const _;
577 #[doc = r"Return the pointer to the register block"]
578 #[inline(always)]
579 pub const fn ptr() -> *const spi0::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 SPI4 {
602 type Target = spi0::RegisterBlock;
603 #[inline(always)]
604 fn deref(&self) -> &Self::Target {
605 unsafe { &*Self::PTR }
606 }
607}
608impl core::fmt::Debug for SPI4 {
609 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
610 f.debug_struct("SPI4").finish()
611 }
612}
613#[doc = "Broadcom SPI Controller"]
614pub use self::spi0 as spi4;
615#[doc = "Broadcom SPI Controller"]
616pub struct SPI5 {
617 _marker: PhantomData<*const ()>,
618}
619unsafe impl Send for SPI5 {}
620impl SPI5 {
621 #[doc = r"Pointer to the register block"]
622 pub const PTR: *const spi0::RegisterBlock = 0xfe20_4a00 as *const _;
623 #[doc = r"Return the pointer to the register block"]
624 #[inline(always)]
625 pub const fn ptr() -> *const spi0::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 SPI5 {
648 type Target = spi0::RegisterBlock;
649 #[inline(always)]
650 fn deref(&self) -> &Self::Target {
651 unsafe { &*Self::PTR }
652 }
653}
654impl core::fmt::Debug for SPI5 {
655 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
656 f.debug_struct("SPI5").finish()
657 }
658}
659#[doc = "Broadcom SPI Controller"]
660pub use self::spi0 as spi5;
661#[doc = "Broadcom SPI Controller"]
662pub struct SPI6 {
663 _marker: PhantomData<*const ()>,
664}
665unsafe impl Send for SPI6 {}
666impl SPI6 {
667 #[doc = r"Pointer to the register block"]
668 pub const PTR: *const spi0::RegisterBlock = 0xfe20_4c00 as *const _;
669 #[doc = r"Return the pointer to the register block"]
670 #[inline(always)]
671 pub const fn ptr() -> *const spi0::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 SPI6 {
694 type Target = spi0::RegisterBlock;
695 #[inline(always)]
696 fn deref(&self) -> &Self::Target {
697 unsafe { &*Self::PTR }
698 }
699}
700impl core::fmt::Debug for SPI6 {
701 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
702 f.debug_struct("SPI6").finish()
703 }
704}
705#[doc = "Broadcom SPI Controller"]
706pub use self::spi0 as spi6;
707#[doc = "Interrupt status of new peripherals"]
708pub struct PACTL {
709 _marker: PhantomData<*const ()>,
710}
711unsafe impl Send for PACTL {}
712impl PACTL {
713 #[doc = r"Pointer to the register block"]
714 pub const PTR: *const pactl::RegisterBlock = 0xfe20_4e00 as *const _;
715 #[doc = r"Return the pointer to the register block"]
716 #[inline(always)]
717 pub const fn ptr() -> *const pactl::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 PACTL {
740 type Target = pactl::RegisterBlock;
741 #[inline(always)]
742 fn deref(&self) -> &Self::Target {
743 unsafe { &*Self::PTR }
744 }
745}
746impl core::fmt::Debug for PACTL {
747 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
748 f.debug_struct("PACTL").finish()
749 }
750}
751#[doc = "Interrupt status of new peripherals"]
752pub mod pactl;
753#[doc = "Broadcom Serial Controller (I2C compatible)"]
754pub struct BSC0 {
755 _marker: PhantomData<*const ()>,
756}
757unsafe impl Send for BSC0 {}
758impl BSC0 {
759 #[doc = r"Pointer to the register block"]
760 pub const PTR: *const bsc0::RegisterBlock = 0xfe20_5000 as *const _;
761 #[doc = r"Return the pointer to the register block"]
762 #[inline(always)]
763 pub const fn ptr() -> *const bsc0::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 BSC0 {
786 type Target = bsc0::RegisterBlock;
787 #[inline(always)]
788 fn deref(&self) -> &Self::Target {
789 unsafe { &*Self::PTR }
790 }
791}
792impl core::fmt::Debug for BSC0 {
793 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
794 f.debug_struct("BSC0").finish()
795 }
796}
797#[doc = "Broadcom Serial Controller (I2C compatible)"]
798pub mod bsc0;
799#[doc = "Broadcom Serial Controller (I2C compatible)"]
800pub struct BSC1 {
801 _marker: PhantomData<*const ()>,
802}
803unsafe impl Send for BSC1 {}
804impl BSC1 {
805 #[doc = r"Pointer to the register block"]
806 pub const PTR: *const bsc0::RegisterBlock = 0xfe80_4000 as *const _;
807 #[doc = r"Return the pointer to the register block"]
808 #[inline(always)]
809 pub const fn ptr() -> *const bsc0::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 BSC1 {
832 type Target = bsc0::RegisterBlock;
833 #[inline(always)]
834 fn deref(&self) -> &Self::Target {
835 unsafe { &*Self::PTR }
836 }
837}
838impl core::fmt::Debug for BSC1 {
839 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
840 f.debug_struct("BSC1").finish()
841 }
842}
843#[doc = "Broadcom Serial Controller (I2C compatible)"]
844pub use self::bsc0 as bsc1;
845#[doc = "Broadcom Serial Controller (I2C compatible)"]
846pub struct BSC3 {
847 _marker: PhantomData<*const ()>,
848}
849unsafe impl Send for BSC3 {}
850impl BSC3 {
851 #[doc = r"Pointer to the register block"]
852 pub const PTR: *const bsc0::RegisterBlock = 0xfe20_5600 as *const _;
853 #[doc = r"Return the pointer to the register block"]
854 #[inline(always)]
855 pub const fn ptr() -> *const bsc0::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 BSC3 {
878 type Target = bsc0::RegisterBlock;
879 #[inline(always)]
880 fn deref(&self) -> &Self::Target {
881 unsafe { &*Self::PTR }
882 }
883}
884impl core::fmt::Debug for BSC3 {
885 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
886 f.debug_struct("BSC3").finish()
887 }
888}
889#[doc = "Broadcom Serial Controller (I2C compatible)"]
890pub use self::bsc0 as bsc3;
891#[doc = "Broadcom Serial Controller (I2C compatible)"]
892pub struct BSC4 {
893 _marker: PhantomData<*const ()>,
894}
895unsafe impl Send for BSC4 {}
896impl BSC4 {
897 #[doc = r"Pointer to the register block"]
898 pub const PTR: *const bsc0::RegisterBlock = 0xfe20_5800 as *const _;
899 #[doc = r"Return the pointer to the register block"]
900 #[inline(always)]
901 pub const fn ptr() -> *const bsc0::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 BSC4 {
924 type Target = bsc0::RegisterBlock;
925 #[inline(always)]
926 fn deref(&self) -> &Self::Target {
927 unsafe { &*Self::PTR }
928 }
929}
930impl core::fmt::Debug for BSC4 {
931 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
932 f.debug_struct("BSC4").finish()
933 }
934}
935#[doc = "Broadcom Serial Controller (I2C compatible)"]
936pub use self::bsc0 as bsc4;
937#[doc = "Broadcom Serial Controller (I2C compatible)"]
938pub struct BSC5 {
939 _marker: PhantomData<*const ()>,
940}
941unsafe impl Send for BSC5 {}
942impl BSC5 {
943 #[doc = r"Pointer to the register block"]
944 pub const PTR: *const bsc0::RegisterBlock = 0xfe20_5a00 as *const _;
945 #[doc = r"Return the pointer to the register block"]
946 #[inline(always)]
947 pub const fn ptr() -> *const bsc0::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 BSC5 {
970 type Target = bsc0::RegisterBlock;
971 #[inline(always)]
972 fn deref(&self) -> &Self::Target {
973 unsafe { &*Self::PTR }
974 }
975}
976impl core::fmt::Debug for BSC5 {
977 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
978 f.debug_struct("BSC5").finish()
979 }
980}
981#[doc = "Broadcom Serial Controller (I2C compatible)"]
982pub use self::bsc0 as bsc5;
983#[doc = "Broadcom Serial Controller (I2C compatible)"]
984pub struct BSC6 {
985 _marker: PhantomData<*const ()>,
986}
987unsafe impl Send for BSC6 {}
988impl BSC6 {
989 #[doc = r"Pointer to the register block"]
990 pub const PTR: *const bsc0::RegisterBlock = 0xfe20_5c00 as *const _;
991 #[doc = r"Return the pointer to the register block"]
992 #[inline(always)]
993 pub const fn ptr() -> *const bsc0::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 BSC6 {
1016 type Target = bsc0::RegisterBlock;
1017 #[inline(always)]
1018 fn deref(&self) -> &Self::Target {
1019 unsafe { &*Self::PTR }
1020 }
1021}
1022impl core::fmt::Debug for BSC6 {
1023 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1024 f.debug_struct("BSC6").finish()
1025 }
1026}
1027#[doc = "Broadcom Serial Controller (I2C compatible)"]
1028pub use self::bsc0 as bsc6;
1029#[doc = "Broadcom PWM"]
1030pub struct PWM0 {
1031 _marker: PhantomData<*const ()>,
1032}
1033unsafe impl Send for PWM0 {}
1034impl PWM0 {
1035 #[doc = r"Pointer to the register block"]
1036 pub const PTR: *const pwm0::RegisterBlock = 0xfe20_c000 as *const _;
1037 #[doc = r"Return the pointer to the register block"]
1038 #[inline(always)]
1039 pub const fn ptr() -> *const pwm0::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 PWM0 {
1062 type Target = pwm0::RegisterBlock;
1063 #[inline(always)]
1064 fn deref(&self) -> &Self::Target {
1065 unsafe { &*Self::PTR }
1066 }
1067}
1068impl core::fmt::Debug for PWM0 {
1069 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1070 f.debug_struct("PWM0").finish()
1071 }
1072}
1073#[doc = "Broadcom PWM"]
1074pub mod pwm0;
1075#[doc = "Broadcom PWM"]
1076pub struct PWM1 {
1077 _marker: PhantomData<*const ()>,
1078}
1079unsafe impl Send for PWM1 {}
1080impl PWM1 {
1081 #[doc = r"Pointer to the register block"]
1082 pub const PTR: *const pwm0::RegisterBlock = 0xfe20_c800 as *const _;
1083 #[doc = r"Return the pointer to the register block"]
1084 #[inline(always)]
1085 pub const fn ptr() -> *const pwm0::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 PWM1 {
1108 type Target = pwm0::RegisterBlock;
1109 #[inline(always)]
1110 fn deref(&self) -> &Self::Target {
1111 unsafe { &*Self::PTR }
1112 }
1113}
1114impl core::fmt::Debug for PWM1 {
1115 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1116 f.debug_struct("PWM1").finish()
1117 }
1118}
1119#[doc = "Broadcom PWM"]
1120pub use self::pwm0 as pwm1;
1121#[doc = "Three auxiliary peripherals"]
1122pub struct AUX {
1123 _marker: PhantomData<*const ()>,
1124}
1125unsafe impl Send for AUX {}
1126impl AUX {
1127 #[doc = r"Pointer to the register block"]
1128 pub const PTR: *const aux::RegisterBlock = 0xfe21_5000 as *const _;
1129 #[doc = r"Return the pointer to the register block"]
1130 #[inline(always)]
1131 pub const fn ptr() -> *const aux::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 AUX {
1154 type Target = aux::RegisterBlock;
1155 #[inline(always)]
1156 fn deref(&self) -> &Self::Target {
1157 unsafe { &*Self::PTR }
1158 }
1159}
1160impl core::fmt::Debug for AUX {
1161 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1162 f.debug_struct("AUX").finish()
1163 }
1164}
1165#[doc = "Three auxiliary peripherals"]
1166#[path = "aux_.rs"]
1167pub mod aux;
1168#[doc = "Mini UART"]
1169pub struct UART1 {
1170 _marker: PhantomData<*const ()>,
1171}
1172unsafe impl Send for UART1 {}
1173impl UART1 {
1174 #[doc = r"Pointer to the register block"]
1175 pub const PTR: *const uart1::RegisterBlock = 0xfe21_5040 as *const _;
1176 #[doc = r"Return the pointer to the register block"]
1177 #[inline(always)]
1178 pub const fn ptr() -> *const uart1::RegisterBlock {
1179 Self::PTR
1180 }
1181 #[doc = r" Steal an instance of this peripheral"]
1182 #[doc = r""]
1183 #[doc = r" # Safety"]
1184 #[doc = r""]
1185 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1186 #[doc = r" that may race with any existing instances, for example by only"]
1187 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1188 #[doc = r" original peripheral and using critical sections to coordinate"]
1189 #[doc = r" access between multiple new instances."]
1190 #[doc = r""]
1191 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1192 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1193 #[doc = r" no stolen instances are passed to such software."]
1194 pub unsafe fn steal() -> Self {
1195 Self {
1196 _marker: PhantomData,
1197 }
1198 }
1199}
1200impl Deref for UART1 {
1201 type Target = uart1::RegisterBlock;
1202 #[inline(always)]
1203 fn deref(&self) -> &Self::Target {
1204 unsafe { &*Self::PTR }
1205 }
1206}
1207impl core::fmt::Debug for UART1 {
1208 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1209 f.debug_struct("UART1").finish()
1210 }
1211}
1212#[doc = "Mini UART"]
1213pub mod uart1;
1214#[doc = "Aux SPI"]
1215pub struct SPI1 {
1216 _marker: PhantomData<*const ()>,
1217}
1218unsafe impl Send for SPI1 {}
1219impl SPI1 {
1220 #[doc = r"Pointer to the register block"]
1221 pub const PTR: *const spi1::RegisterBlock = 0xfe21_5080 as *const _;
1222 #[doc = r"Return the pointer to the register block"]
1223 #[inline(always)]
1224 pub const fn ptr() -> *const spi1::RegisterBlock {
1225 Self::PTR
1226 }
1227 #[doc = r" Steal an instance of this peripheral"]
1228 #[doc = r""]
1229 #[doc = r" # Safety"]
1230 #[doc = r""]
1231 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1232 #[doc = r" that may race with any existing instances, for example by only"]
1233 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1234 #[doc = r" original peripheral and using critical sections to coordinate"]
1235 #[doc = r" access between multiple new instances."]
1236 #[doc = r""]
1237 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1238 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1239 #[doc = r" no stolen instances are passed to such software."]
1240 pub unsafe fn steal() -> Self {
1241 Self {
1242 _marker: PhantomData,
1243 }
1244 }
1245}
1246impl Deref for SPI1 {
1247 type Target = spi1::RegisterBlock;
1248 #[inline(always)]
1249 fn deref(&self) -> &Self::Target {
1250 unsafe { &*Self::PTR }
1251 }
1252}
1253impl core::fmt::Debug for SPI1 {
1254 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1255 f.debug_struct("SPI1").finish()
1256 }
1257}
1258#[doc = "Aux SPI"]
1259pub mod spi1;
1260#[doc = "Aux SPI"]
1261pub struct SPI2 {
1262 _marker: PhantomData<*const ()>,
1263}
1264unsafe impl Send for SPI2 {}
1265impl SPI2 {
1266 #[doc = r"Pointer to the register block"]
1267 pub const PTR: *const spi1::RegisterBlock = 0xfe21_50c0 as *const _;
1268 #[doc = r"Return the pointer to the register block"]
1269 #[inline(always)]
1270 pub const fn ptr() -> *const spi1::RegisterBlock {
1271 Self::PTR
1272 }
1273 #[doc = r" Steal an instance of this peripheral"]
1274 #[doc = r""]
1275 #[doc = r" # Safety"]
1276 #[doc = r""]
1277 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1278 #[doc = r" that may race with any existing instances, for example by only"]
1279 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1280 #[doc = r" original peripheral and using critical sections to coordinate"]
1281 #[doc = r" access between multiple new instances."]
1282 #[doc = r""]
1283 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1284 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1285 #[doc = r" no stolen instances are passed to such software."]
1286 pub unsafe fn steal() -> Self {
1287 Self {
1288 _marker: PhantomData,
1289 }
1290 }
1291}
1292impl Deref for SPI2 {
1293 type Target = spi1::RegisterBlock;
1294 #[inline(always)]
1295 fn deref(&self) -> &Self::Target {
1296 unsafe { &*Self::PTR }
1297 }
1298}
1299impl core::fmt::Debug for SPI2 {
1300 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1301 f.debug_struct("SPI2").finish()
1302 }
1303}
1304#[doc = "Aux SPI"]
1305pub use self::spi1 as spi2;
1306#[doc = "Broadcom Legacy Interrupt Controller"]
1307pub struct LIC {
1308 _marker: PhantomData<*const ()>,
1309}
1310unsafe impl Send for LIC {}
1311impl LIC {
1312 #[doc = r"Pointer to the register block"]
1313 pub const PTR: *const lic::RegisterBlock = 0xff80_0000 as *const _;
1314 #[doc = r"Return the pointer to the register block"]
1315 #[inline(always)]
1316 pub const fn ptr() -> *const lic::RegisterBlock {
1317 Self::PTR
1318 }
1319 #[doc = r" Steal an instance of this peripheral"]
1320 #[doc = r""]
1321 #[doc = r" # Safety"]
1322 #[doc = r""]
1323 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1324 #[doc = r" that may race with any existing instances, for example by only"]
1325 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1326 #[doc = r" original peripheral and using critical sections to coordinate"]
1327 #[doc = r" access between multiple new instances."]
1328 #[doc = r""]
1329 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1330 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1331 #[doc = r" no stolen instances are passed to such software."]
1332 pub unsafe fn steal() -> Self {
1333 Self {
1334 _marker: PhantomData,
1335 }
1336 }
1337}
1338impl Deref for LIC {
1339 type Target = lic::RegisterBlock;
1340 #[inline(always)]
1341 fn deref(&self) -> &Self::Target {
1342 unsafe { &*Self::PTR }
1343 }
1344}
1345impl core::fmt::Debug for LIC {
1346 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1347 f.debug_struct("LIC").finish()
1348 }
1349}
1350#[doc = "Broadcom Legacy Interrupt Controller"]
1351pub mod lic;
1352#[doc = "ARM GIC-400 Generic Interrupt Controller Distributor"]
1353pub struct GIC_DIST {
1354 _marker: PhantomData<*const ()>,
1355}
1356unsafe impl Send for GIC_DIST {}
1357impl GIC_DIST {
1358 #[doc = r"Pointer to the register block"]
1359 pub const PTR: *const gic_dist::RegisterBlock = 0xff84_1000 as *const _;
1360 #[doc = r"Return the pointer to the register block"]
1361 #[inline(always)]
1362 pub const fn ptr() -> *const gic_dist::RegisterBlock {
1363 Self::PTR
1364 }
1365 #[doc = r" Steal an instance of this peripheral"]
1366 #[doc = r""]
1367 #[doc = r" # Safety"]
1368 #[doc = r""]
1369 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1370 #[doc = r" that may race with any existing instances, for example by only"]
1371 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1372 #[doc = r" original peripheral and using critical sections to coordinate"]
1373 #[doc = r" access between multiple new instances."]
1374 #[doc = r""]
1375 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1376 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1377 #[doc = r" no stolen instances are passed to such software."]
1378 pub unsafe fn steal() -> Self {
1379 Self {
1380 _marker: PhantomData,
1381 }
1382 }
1383}
1384impl Deref for GIC_DIST {
1385 type Target = gic_dist::RegisterBlock;
1386 #[inline(always)]
1387 fn deref(&self) -> &Self::Target {
1388 unsafe { &*Self::PTR }
1389 }
1390}
1391impl core::fmt::Debug for GIC_DIST {
1392 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1393 f.debug_struct("GIC_DIST").finish()
1394 }
1395}
1396#[doc = "ARM GIC-400 Generic Interrupt Controller Distributor"]
1397pub mod gic_dist;
1398#[doc = "ARM GIC-400 Generic Interrupt Controller CPU Interface"]
1399pub struct GIC_CPU {
1400 _marker: PhantomData<*const ()>,
1401}
1402unsafe impl Send for GIC_CPU {}
1403impl GIC_CPU {
1404 #[doc = r"Pointer to the register block"]
1405 pub const PTR: *const gic_cpu::RegisterBlock = 0xff84_2000 as *const _;
1406 #[doc = r"Return the pointer to the register block"]
1407 #[inline(always)]
1408 pub const fn ptr() -> *const gic_cpu::RegisterBlock {
1409 Self::PTR
1410 }
1411 #[doc = r" Steal an instance of this peripheral"]
1412 #[doc = r""]
1413 #[doc = r" # Safety"]
1414 #[doc = r""]
1415 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1416 #[doc = r" that may race with any existing instances, for example by only"]
1417 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1418 #[doc = r" original peripheral and using critical sections to coordinate"]
1419 #[doc = r" access between multiple new instances."]
1420 #[doc = r""]
1421 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1422 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1423 #[doc = r" no stolen instances are passed to such software."]
1424 pub unsafe fn steal() -> Self {
1425 Self {
1426 _marker: PhantomData,
1427 }
1428 }
1429}
1430impl Deref for GIC_CPU {
1431 type Target = gic_cpu::RegisterBlock;
1432 #[inline(always)]
1433 fn deref(&self) -> &Self::Target {
1434 unsafe { &*Self::PTR }
1435 }
1436}
1437impl core::fmt::Debug for GIC_CPU {
1438 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1439 f.debug_struct("GIC_CPU").finish()
1440 }
1441}
1442#[doc = "ARM GIC-400 Generic Interrupt Controller CPU Interface"]
1443pub mod gic_cpu;
1444#[doc = "USB on the go high speed"]
1445pub struct USB_OTG_GLOBAL {
1446 _marker: PhantomData<*const ()>,
1447}
1448unsafe impl Send for USB_OTG_GLOBAL {}
1449impl USB_OTG_GLOBAL {
1450 #[doc = r"Pointer to the register block"]
1451 pub const PTR: *const usb_otg_global::RegisterBlock = 0xfe98_0000 as *const _;
1452 #[doc = r"Return the pointer to the register block"]
1453 #[inline(always)]
1454 pub const fn ptr() -> *const usb_otg_global::RegisterBlock {
1455 Self::PTR
1456 }
1457 #[doc = r" Steal an instance of this peripheral"]
1458 #[doc = r""]
1459 #[doc = r" # Safety"]
1460 #[doc = r""]
1461 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1462 #[doc = r" that may race with any existing instances, for example by only"]
1463 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1464 #[doc = r" original peripheral and using critical sections to coordinate"]
1465 #[doc = r" access between multiple new instances."]
1466 #[doc = r""]
1467 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1468 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1469 #[doc = r" no stolen instances are passed to such software."]
1470 pub unsafe fn steal() -> Self {
1471 Self {
1472 _marker: PhantomData,
1473 }
1474 }
1475}
1476impl Deref for USB_OTG_GLOBAL {
1477 type Target = usb_otg_global::RegisterBlock;
1478 #[inline(always)]
1479 fn deref(&self) -> &Self::Target {
1480 unsafe { &*Self::PTR }
1481 }
1482}
1483impl core::fmt::Debug for USB_OTG_GLOBAL {
1484 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1485 f.debug_struct("USB_OTG_GLOBAL").finish()
1486 }
1487}
1488#[doc = "USB on the go high speed"]
1489pub mod usb_otg_global;
1490#[doc = "USB on the go high speed"]
1491pub struct USB_OTG_HOST {
1492 _marker: PhantomData<*const ()>,
1493}
1494unsafe impl Send for USB_OTG_HOST {}
1495impl USB_OTG_HOST {
1496 #[doc = r"Pointer to the register block"]
1497 pub const PTR: *const usb_otg_host::RegisterBlock = 0xfe98_0400 as *const _;
1498 #[doc = r"Return the pointer to the register block"]
1499 #[inline(always)]
1500 pub const fn ptr() -> *const usb_otg_host::RegisterBlock {
1501 Self::PTR
1502 }
1503 #[doc = r" Steal an instance of this peripheral"]
1504 #[doc = r""]
1505 #[doc = r" # Safety"]
1506 #[doc = r""]
1507 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1508 #[doc = r" that may race with any existing instances, for example by only"]
1509 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1510 #[doc = r" original peripheral and using critical sections to coordinate"]
1511 #[doc = r" access between multiple new instances."]
1512 #[doc = r""]
1513 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1514 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1515 #[doc = r" no stolen instances are passed to such software."]
1516 pub unsafe fn steal() -> Self {
1517 Self {
1518 _marker: PhantomData,
1519 }
1520 }
1521}
1522impl Deref for USB_OTG_HOST {
1523 type Target = usb_otg_host::RegisterBlock;
1524 #[inline(always)]
1525 fn deref(&self) -> &Self::Target {
1526 unsafe { &*Self::PTR }
1527 }
1528}
1529impl core::fmt::Debug for USB_OTG_HOST {
1530 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1531 f.debug_struct("USB_OTG_HOST").finish()
1532 }
1533}
1534#[doc = "USB on the go high speed"]
1535pub mod usb_otg_host;
1536#[doc = "USB on the go high speed"]
1537pub struct USB_OTG_DEVICE {
1538 _marker: PhantomData<*const ()>,
1539}
1540unsafe impl Send for USB_OTG_DEVICE {}
1541impl USB_OTG_DEVICE {
1542 #[doc = r"Pointer to the register block"]
1543 pub const PTR: *const usb_otg_device::RegisterBlock = 0xfe98_0800 as *const _;
1544 #[doc = r"Return the pointer to the register block"]
1545 #[inline(always)]
1546 pub const fn ptr() -> *const usb_otg_device::RegisterBlock {
1547 Self::PTR
1548 }
1549 #[doc = r" Steal an instance of this peripheral"]
1550 #[doc = r""]
1551 #[doc = r" # Safety"]
1552 #[doc = r""]
1553 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1554 #[doc = r" that may race with any existing instances, for example by only"]
1555 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1556 #[doc = r" original peripheral and using critical sections to coordinate"]
1557 #[doc = r" access between multiple new instances."]
1558 #[doc = r""]
1559 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1560 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1561 #[doc = r" no stolen instances are passed to such software."]
1562 pub unsafe fn steal() -> Self {
1563 Self {
1564 _marker: PhantomData,
1565 }
1566 }
1567}
1568impl Deref for USB_OTG_DEVICE {
1569 type Target = usb_otg_device::RegisterBlock;
1570 #[inline(always)]
1571 fn deref(&self) -> &Self::Target {
1572 unsafe { &*Self::PTR }
1573 }
1574}
1575impl core::fmt::Debug for USB_OTG_DEVICE {
1576 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1577 f.debug_struct("USB_OTG_DEVICE").finish()
1578 }
1579}
1580#[doc = "USB on the go high speed"]
1581pub mod usb_otg_device;
1582#[doc = "USB on the go high speed power control"]
1583pub struct USB_OTG_PWRCLK {
1584 _marker: PhantomData<*const ()>,
1585}
1586unsafe impl Send for USB_OTG_PWRCLK {}
1587impl USB_OTG_PWRCLK {
1588 #[doc = r"Pointer to the register block"]
1589 pub const PTR: *const usb_otg_pwrclk::RegisterBlock = 0xfe98_0e00 as *const _;
1590 #[doc = r"Return the pointer to the register block"]
1591 #[inline(always)]
1592 pub const fn ptr() -> *const usb_otg_pwrclk::RegisterBlock {
1593 Self::PTR
1594 }
1595 #[doc = r" Steal an instance of this peripheral"]
1596 #[doc = r""]
1597 #[doc = r" # Safety"]
1598 #[doc = r""]
1599 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1600 #[doc = r" that may race with any existing instances, for example by only"]
1601 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1602 #[doc = r" original peripheral and using critical sections to coordinate"]
1603 #[doc = r" access between multiple new instances."]
1604 #[doc = r""]
1605 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1606 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1607 #[doc = r" no stolen instances are passed to such software."]
1608 pub unsafe fn steal() -> Self {
1609 Self {
1610 _marker: PhantomData,
1611 }
1612 }
1613}
1614impl Deref for USB_OTG_PWRCLK {
1615 type Target = usb_otg_pwrclk::RegisterBlock;
1616 #[inline(always)]
1617 fn deref(&self) -> &Self::Target {
1618 unsafe { &*Self::PTR }
1619 }
1620}
1621impl core::fmt::Debug for USB_OTG_PWRCLK {
1622 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1623 f.debug_struct("USB_OTG_PWRCLK").finish()
1624 }
1625}
1626#[doc = "USB on the go high speed power control"]
1627pub mod usb_otg_pwrclk;
1628#[doc = "Arasan SD3.0 Host AHB eMMC 4.4"]
1629pub struct EMMC {
1630 _marker: PhantomData<*const ()>,
1631}
1632unsafe impl Send for EMMC {}
1633impl EMMC {
1634 #[doc = r"Pointer to the register block"]
1635 pub const PTR: *const emmc::RegisterBlock = 0xfe30_0000 as *const _;
1636 #[doc = r"Return the pointer to the register block"]
1637 #[inline(always)]
1638 pub const fn ptr() -> *const emmc::RegisterBlock {
1639 Self::PTR
1640 }
1641 #[doc = r" Steal an instance of this peripheral"]
1642 #[doc = r""]
1643 #[doc = r" # Safety"]
1644 #[doc = r""]
1645 #[doc = r" Ensure that the new instance of the peripheral cannot be used in a way"]
1646 #[doc = r" that may race with any existing instances, for example by only"]
1647 #[doc = r" accessing read-only or write-only registers, or by consuming the"]
1648 #[doc = r" original peripheral and using critical sections to coordinate"]
1649 #[doc = r" access between multiple new instances."]
1650 #[doc = r""]
1651 #[doc = r" Additionally, other software such as HALs may rely on only one"]
1652 #[doc = r" peripheral instance existing to ensure memory safety; ensure"]
1653 #[doc = r" no stolen instances are passed to such software."]
1654 pub unsafe fn steal() -> Self {
1655 Self {
1656 _marker: PhantomData,
1657 }
1658 }
1659}
1660impl Deref for EMMC {
1661 type Target = emmc::RegisterBlock;
1662 #[inline(always)]
1663 fn deref(&self) -> &Self::Target {
1664 unsafe { &*Self::PTR }
1665 }
1666}
1667impl core::fmt::Debug for EMMC {
1668 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1669 f.debug_struct("EMMC").finish()
1670 }
1671}
1672#[doc = "Arasan SD3.0 Host AHB eMMC 4.4"]
1673pub mod emmc;
1674#[no_mangle]
1675static mut DEVICE_PERIPHERALS: bool = false;
1676#[doc = r" All the peripherals."]
1677#[allow(non_snake_case)]
1678pub struct Peripherals {
1679 #[doc = "VCMAILBOX"]
1680 pub VCMAILBOX: VCMAILBOX,
1681 #[doc = "CM_PCM"]
1682 pub CM_PCM: CM_PCM,
1683 #[doc = "CM_PWM"]
1684 pub CM_PWM: CM_PWM,
1685 #[doc = "GPIO"]
1686 pub GPIO: GPIO,
1687 #[doc = "SYSTMR"]
1688 pub SYSTMR: SYSTMR,
1689 #[doc = "UART0"]
1690 pub UART0: UART0,
1691 #[doc = "UART2"]
1692 pub UART2: UART2,
1693 #[doc = "UART3"]
1694 pub UART3: UART3,
1695 #[doc = "UART4"]
1696 pub UART4: UART4,
1697 #[doc = "UART5"]
1698 pub UART5: UART5,
1699 #[doc = "SPI0"]
1700 pub SPI0: SPI0,
1701 #[doc = "SPI3"]
1702 pub SPI3: SPI3,
1703 #[doc = "SPI4"]
1704 pub SPI4: SPI4,
1705 #[doc = "SPI5"]
1706 pub SPI5: SPI5,
1707 #[doc = "SPI6"]
1708 pub SPI6: SPI6,
1709 #[doc = "PACTL"]
1710 pub PACTL: PACTL,
1711 #[doc = "BSC0"]
1712 pub BSC0: BSC0,
1713 #[doc = "BSC1"]
1714 pub BSC1: BSC1,
1715 #[doc = "BSC3"]
1716 pub BSC3: BSC3,
1717 #[doc = "BSC4"]
1718 pub BSC4: BSC4,
1719 #[doc = "BSC5"]
1720 pub BSC5: BSC5,
1721 #[doc = "BSC6"]
1722 pub BSC6: BSC6,
1723 #[doc = "PWM0"]
1724 pub PWM0: PWM0,
1725 #[doc = "PWM1"]
1726 pub PWM1: PWM1,
1727 #[doc = "AUX"]
1728 pub AUX: AUX,
1729 #[doc = "UART1"]
1730 pub UART1: UART1,
1731 #[doc = "SPI1"]
1732 pub SPI1: SPI1,
1733 #[doc = "SPI2"]
1734 pub SPI2: SPI2,
1735 #[doc = "LIC"]
1736 pub LIC: LIC,
1737 #[doc = "GIC_DIST"]
1738 pub GIC_DIST: GIC_DIST,
1739 #[doc = "GIC_CPU"]
1740 pub GIC_CPU: GIC_CPU,
1741 #[doc = "USB_OTG_GLOBAL"]
1742 pub USB_OTG_GLOBAL: USB_OTG_GLOBAL,
1743 #[doc = "USB_OTG_HOST"]
1744 pub USB_OTG_HOST: USB_OTG_HOST,
1745 #[doc = "USB_OTG_DEVICE"]
1746 pub USB_OTG_DEVICE: USB_OTG_DEVICE,
1747 #[doc = "USB_OTG_PWRCLK"]
1748 pub USB_OTG_PWRCLK: USB_OTG_PWRCLK,
1749 #[doc = "EMMC"]
1750 pub EMMC: EMMC,
1751}
1752impl Peripherals {
1753 #[doc = r" Returns all the peripherals *once*."]
1754 #[cfg(feature = "critical-section")]
1755 #[inline]
1756 pub fn take() -> Option<Self> {
1757 critical_section::with(|_| {
1758 if unsafe { DEVICE_PERIPHERALS } {
1759 return None;
1760 }
1761 Some(unsafe { Peripherals::steal() })
1762 })
1763 }
1764 #[doc = r" Unchecked version of `Peripherals::take`."]
1765 #[doc = r""]
1766 #[doc = r" # Safety"]
1767 #[doc = r""]
1768 #[doc = r" Each of the returned peripherals must be used at most once."]
1769 #[inline]
1770 pub unsafe fn steal() -> Self {
1771 DEVICE_PERIPHERALS = true;
1772 Peripherals {
1773 VCMAILBOX: VCMAILBOX {
1774 _marker: PhantomData,
1775 },
1776 CM_PCM: CM_PCM {
1777 _marker: PhantomData,
1778 },
1779 CM_PWM: CM_PWM {
1780 _marker: PhantomData,
1781 },
1782 GPIO: GPIO {
1783 _marker: PhantomData,
1784 },
1785 SYSTMR: SYSTMR {
1786 _marker: PhantomData,
1787 },
1788 UART0: UART0 {
1789 _marker: PhantomData,
1790 },
1791 UART2: UART2 {
1792 _marker: PhantomData,
1793 },
1794 UART3: UART3 {
1795 _marker: PhantomData,
1796 },
1797 UART4: UART4 {
1798 _marker: PhantomData,
1799 },
1800 UART5: UART5 {
1801 _marker: PhantomData,
1802 },
1803 SPI0: SPI0 {
1804 _marker: PhantomData,
1805 },
1806 SPI3: SPI3 {
1807 _marker: PhantomData,
1808 },
1809 SPI4: SPI4 {
1810 _marker: PhantomData,
1811 },
1812 SPI5: SPI5 {
1813 _marker: PhantomData,
1814 },
1815 SPI6: SPI6 {
1816 _marker: PhantomData,
1817 },
1818 PACTL: PACTL {
1819 _marker: PhantomData,
1820 },
1821 BSC0: BSC0 {
1822 _marker: PhantomData,
1823 },
1824 BSC1: BSC1 {
1825 _marker: PhantomData,
1826 },
1827 BSC3: BSC3 {
1828 _marker: PhantomData,
1829 },
1830 BSC4: BSC4 {
1831 _marker: PhantomData,
1832 },
1833 BSC5: BSC5 {
1834 _marker: PhantomData,
1835 },
1836 BSC6: BSC6 {
1837 _marker: PhantomData,
1838 },
1839 PWM0: PWM0 {
1840 _marker: PhantomData,
1841 },
1842 PWM1: PWM1 {
1843 _marker: PhantomData,
1844 },
1845 AUX: AUX {
1846 _marker: PhantomData,
1847 },
1848 UART1: UART1 {
1849 _marker: PhantomData,
1850 },
1851 SPI1: SPI1 {
1852 _marker: PhantomData,
1853 },
1854 SPI2: SPI2 {
1855 _marker: PhantomData,
1856 },
1857 LIC: LIC {
1858 _marker: PhantomData,
1859 },
1860 GIC_DIST: GIC_DIST {
1861 _marker: PhantomData,
1862 },
1863 GIC_CPU: GIC_CPU {
1864 _marker: PhantomData,
1865 },
1866 USB_OTG_GLOBAL: USB_OTG_GLOBAL {
1867 _marker: PhantomData,
1868 },
1869 USB_OTG_HOST: USB_OTG_HOST {
1870 _marker: PhantomData,
1871 },
1872 USB_OTG_DEVICE: USB_OTG_DEVICE {
1873 _marker: PhantomData,
1874 },
1875 USB_OTG_PWRCLK: USB_OTG_PWRCLK {
1876 _marker: PhantomData,
1877 },
1878 EMMC: EMMC {
1879 _marker: PhantomData,
1880 },
1881 }
1882 }
1883}