1#![doc = "Peripheral access API for ATSAM4LC8B microcontrollers (generated using svd2rust v0.27.2 ( ))\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.27.2/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#![deny(dead_code)]
4#![deny(improper_ctypes)]
5#![deny(missing_docs)]
6#![deny(no_mangle_generic_items)]
7#![deny(non_shorthand_field_patterns)]
8#![deny(overflowing_literals)]
9#![deny(path_statements)]
10#![deny(patterns_in_fns_without_body)]
11#![deny(private_in_public)]
12#![deny(unconditional_recursion)]
13#![deny(unused_allocation)]
14#![deny(unused_comparisons)]
15#![deny(unused_parens)]
16#![deny(while_true)]
17#![allow(non_camel_case_types)]
18#![allow(non_snake_case)]
19#![no_std]
20use core::marker::PhantomData;
21use core::ops::Deref;
22#[doc = r"Number available in the NVIC for configuring priority"]
23pub const NVIC_PRIO_BITS: u8 = 4;
24#[cfg(feature = "rt")]
25pub use self::Interrupt as interrupt;
26pub use cortex_m::peripheral::Peripherals as CorePeripherals;
27pub use cortex_m::peripheral::{CBP, CPUID, DCB, DWT, FPB, ITM, MPU, NVIC, SCB, SYST, TPIU};
28#[cfg(feature = "rt")]
29pub use cortex_m_rt::interrupt;
30#[allow(unused_imports)]
31use generic::*;
32#[doc = r"Common register and bit access and modify traits"]
33pub mod generic;
34#[cfg(feature = "rt")]
35extern "C" {
36 fn HFLASHC();
37 fn PDCA_0();
38 fn PDCA_1();
39 fn PDCA_2();
40 fn PDCA_3();
41 fn PDCA_4();
42 fn PDCA_5();
43 fn PDCA_6();
44 fn PDCA_7();
45 fn PDCA_8();
46 fn PDCA_9();
47 fn PDCA_10();
48 fn PDCA_11();
49 fn PDCA_12();
50 fn PDCA_13();
51 fn PDCA_14();
52 fn PDCA_15();
53 fn CRCCU();
54 fn USBC();
55 fn PEVC_TR();
56 fn PEVC_OV();
57 fn AESA();
58 fn PM();
59 fn SCIF();
60 fn FREQM();
61 fn GPIO_0();
62 fn GPIO_1();
63 fn GPIO_2();
64 fn GPIO_3();
65 fn GPIO_4();
66 fn GPIO_5();
67 fn GPIO_6();
68 fn GPIO_7();
69 fn GPIO_8();
70 fn GPIO_9();
71 fn GPIO_10();
72 fn GPIO_11();
73 fn BPM();
74 fn BSCIF();
75 fn AST_ALARM();
76 fn AST_PER();
77 fn AST_OVF();
78 fn AST_READY();
79 fn AST_CLKREADY();
80 fn WDT();
81 fn EIC_1();
82 fn EIC_2();
83 fn EIC_3();
84 fn EIC_4();
85 fn EIC_5();
86 fn EIC_6();
87 fn EIC_7();
88 fn EIC_8();
89 fn IISC();
90 fn SPI();
91 fn TC00();
92 fn TC01();
93 fn TC02();
94 fn TC10();
95 fn TC11();
96 fn TC12();
97 fn TWIM0();
98 fn TWIS0();
99 fn TWIM1();
100 fn TWIS1();
101 fn USART0();
102 fn USART1();
103 fn USART2();
104 fn USART3();
105 fn ADCIFE();
106 fn DACC();
107 fn ACIFC();
108 fn ABDACB();
109 fn TRNG();
110 fn PARC();
111 fn CATB();
112 fn TWIM2();
113 fn TWIM3();
114 fn LCDCA();
115}
116#[doc(hidden)]
117pub union Vector {
118 _handler: unsafe extern "C" fn(),
119 _reserved: u32,
120}
121#[cfg(feature = "rt")]
122#[doc(hidden)]
123#[link_section = ".vector_table.interrupts"]
124#[no_mangle]
125pub static __INTERRUPTS: [Vector; 80] = [
126 Vector { _handler: HFLASHC },
127 Vector { _handler: PDCA_0 },
128 Vector { _handler: PDCA_1 },
129 Vector { _handler: PDCA_2 },
130 Vector { _handler: PDCA_3 },
131 Vector { _handler: PDCA_4 },
132 Vector { _handler: PDCA_5 },
133 Vector { _handler: PDCA_6 },
134 Vector { _handler: PDCA_7 },
135 Vector { _handler: PDCA_8 },
136 Vector { _handler: PDCA_9 },
137 Vector { _handler: PDCA_10 },
138 Vector { _handler: PDCA_11 },
139 Vector { _handler: PDCA_12 },
140 Vector { _handler: PDCA_13 },
141 Vector { _handler: PDCA_14 },
142 Vector { _handler: PDCA_15 },
143 Vector { _handler: CRCCU },
144 Vector { _handler: USBC },
145 Vector { _handler: PEVC_TR },
146 Vector { _handler: PEVC_OV },
147 Vector { _handler: AESA },
148 Vector { _handler: PM },
149 Vector { _handler: SCIF },
150 Vector { _handler: FREQM },
151 Vector { _handler: GPIO_0 },
152 Vector { _handler: GPIO_1 },
153 Vector { _handler: GPIO_2 },
154 Vector { _handler: GPIO_3 },
155 Vector { _handler: GPIO_4 },
156 Vector { _handler: GPIO_5 },
157 Vector { _handler: GPIO_6 },
158 Vector { _handler: GPIO_7 },
159 Vector { _handler: GPIO_8 },
160 Vector { _handler: GPIO_9 },
161 Vector { _handler: GPIO_10 },
162 Vector { _handler: GPIO_11 },
163 Vector { _handler: BPM },
164 Vector { _handler: BSCIF },
165 Vector {
166 _handler: AST_ALARM,
167 },
168 Vector { _handler: AST_PER },
169 Vector { _handler: AST_OVF },
170 Vector {
171 _handler: AST_READY,
172 },
173 Vector {
174 _handler: AST_CLKREADY,
175 },
176 Vector { _handler: WDT },
177 Vector { _handler: EIC_1 },
178 Vector { _handler: EIC_2 },
179 Vector { _handler: EIC_3 },
180 Vector { _handler: EIC_4 },
181 Vector { _handler: EIC_5 },
182 Vector { _handler: EIC_6 },
183 Vector { _handler: EIC_7 },
184 Vector { _handler: EIC_8 },
185 Vector { _handler: IISC },
186 Vector { _handler: SPI },
187 Vector { _handler: TC00 },
188 Vector { _handler: TC01 },
189 Vector { _handler: TC02 },
190 Vector { _handler: TC10 },
191 Vector { _handler: TC11 },
192 Vector { _handler: TC12 },
193 Vector { _handler: TWIM0 },
194 Vector { _handler: TWIS0 },
195 Vector { _handler: TWIM1 },
196 Vector { _handler: TWIS1 },
197 Vector { _handler: USART0 },
198 Vector { _handler: USART1 },
199 Vector { _handler: USART2 },
200 Vector { _handler: USART3 },
201 Vector { _handler: ADCIFE },
202 Vector { _handler: DACC },
203 Vector { _handler: ACIFC },
204 Vector { _handler: ABDACB },
205 Vector { _handler: TRNG },
206 Vector { _handler: PARC },
207 Vector { _handler: CATB },
208 Vector { _reserved: 0 },
209 Vector { _handler: TWIM2 },
210 Vector { _handler: TWIM3 },
211 Vector { _handler: LCDCA },
212];
213#[doc = r"Enumeration of all the interrupts."]
214#[derive(Copy, Clone, Debug, PartialEq, Eq)]
215#[repr(u16)]
216pub enum Interrupt {
217 #[doc = "0 - HFLASHC"]
218 HFLASHC = 0,
219 #[doc = "1 - PDCA_0"]
220 PDCA_0 = 1,
221 #[doc = "2 - PDCA_1"]
222 PDCA_1 = 2,
223 #[doc = "3 - PDCA_2"]
224 PDCA_2 = 3,
225 #[doc = "4 - PDCA_3"]
226 PDCA_3 = 4,
227 #[doc = "5 - PDCA_4"]
228 PDCA_4 = 5,
229 #[doc = "6 - PDCA_5"]
230 PDCA_5 = 6,
231 #[doc = "7 - PDCA_6"]
232 PDCA_6 = 7,
233 #[doc = "8 - PDCA_7"]
234 PDCA_7 = 8,
235 #[doc = "9 - PDCA_8"]
236 PDCA_8 = 9,
237 #[doc = "10 - PDCA_9"]
238 PDCA_9 = 10,
239 #[doc = "11 - PDCA_10"]
240 PDCA_10 = 11,
241 #[doc = "12 - PDCA_11"]
242 PDCA_11 = 12,
243 #[doc = "13 - PDCA_12"]
244 PDCA_12 = 13,
245 #[doc = "14 - PDCA_13"]
246 PDCA_13 = 14,
247 #[doc = "15 - PDCA_14"]
248 PDCA_14 = 15,
249 #[doc = "16 - PDCA_15"]
250 PDCA_15 = 16,
251 #[doc = "17 - CRCCU"]
252 CRCCU = 17,
253 #[doc = "18 - USBC"]
254 USBC = 18,
255 #[doc = "19 - PEVC_TR"]
256 PEVC_TR = 19,
257 #[doc = "20 - PEVC_OV"]
258 PEVC_OV = 20,
259 #[doc = "21 - AESA"]
260 AESA = 21,
261 #[doc = "22 - PM"]
262 PM = 22,
263 #[doc = "23 - SCIF"]
264 SCIF = 23,
265 #[doc = "24 - FREQM"]
266 FREQM = 24,
267 #[doc = "25 - GPIO_0"]
268 GPIO_0 = 25,
269 #[doc = "26 - GPIO_1"]
270 GPIO_1 = 26,
271 #[doc = "27 - GPIO_2"]
272 GPIO_2 = 27,
273 #[doc = "28 - GPIO_3"]
274 GPIO_3 = 28,
275 #[doc = "29 - GPIO_4"]
276 GPIO_4 = 29,
277 #[doc = "30 - GPIO_5"]
278 GPIO_5 = 30,
279 #[doc = "31 - GPIO_6"]
280 GPIO_6 = 31,
281 #[doc = "32 - GPIO_7"]
282 GPIO_7 = 32,
283 #[doc = "33 - GPIO_8"]
284 GPIO_8 = 33,
285 #[doc = "34 - GPIO_9"]
286 GPIO_9 = 34,
287 #[doc = "35 - GPIO_10"]
288 GPIO_10 = 35,
289 #[doc = "36 - GPIO_11"]
290 GPIO_11 = 36,
291 #[doc = "37 - BPM"]
292 BPM = 37,
293 #[doc = "38 - BSCIF"]
294 BSCIF = 38,
295 #[doc = "39 - AST_ALARM"]
296 AST_ALARM = 39,
297 #[doc = "40 - AST_PER"]
298 AST_PER = 40,
299 #[doc = "41 - AST_OVF"]
300 AST_OVF = 41,
301 #[doc = "42 - AST_READY"]
302 AST_READY = 42,
303 #[doc = "43 - AST_CLKREADY"]
304 AST_CLKREADY = 43,
305 #[doc = "44 - WDT"]
306 WDT = 44,
307 #[doc = "45 - EIC_1"]
308 EIC_1 = 45,
309 #[doc = "46 - EIC_2"]
310 EIC_2 = 46,
311 #[doc = "47 - EIC_3"]
312 EIC_3 = 47,
313 #[doc = "48 - EIC_4"]
314 EIC_4 = 48,
315 #[doc = "49 - EIC_5"]
316 EIC_5 = 49,
317 #[doc = "50 - EIC_6"]
318 EIC_6 = 50,
319 #[doc = "51 - EIC_7"]
320 EIC_7 = 51,
321 #[doc = "52 - EIC_8"]
322 EIC_8 = 52,
323 #[doc = "53 - IISC"]
324 IISC = 53,
325 #[doc = "54 - SPI"]
326 SPI = 54,
327 #[doc = "55 - TC00"]
328 TC00 = 55,
329 #[doc = "56 - TC01"]
330 TC01 = 56,
331 #[doc = "57 - TC02"]
332 TC02 = 57,
333 #[doc = "58 - TC10"]
334 TC10 = 58,
335 #[doc = "59 - TC11"]
336 TC11 = 59,
337 #[doc = "60 - TC12"]
338 TC12 = 60,
339 #[doc = "61 - TWIM0"]
340 TWIM0 = 61,
341 #[doc = "62 - TWIS0"]
342 TWIS0 = 62,
343 #[doc = "63 - TWIM1"]
344 TWIM1 = 63,
345 #[doc = "64 - TWIS1"]
346 TWIS1 = 64,
347 #[doc = "65 - USART0"]
348 USART0 = 65,
349 #[doc = "66 - USART1"]
350 USART1 = 66,
351 #[doc = "67 - USART2"]
352 USART2 = 67,
353 #[doc = "68 - USART3"]
354 USART3 = 68,
355 #[doc = "69 - ADCIFE"]
356 ADCIFE = 69,
357 #[doc = "70 - DACC"]
358 DACC = 70,
359 #[doc = "71 - ACIFC"]
360 ACIFC = 71,
361 #[doc = "72 - ABDACB"]
362 ABDACB = 72,
363 #[doc = "73 - TRNG"]
364 TRNG = 73,
365 #[doc = "74 - PARC"]
366 PARC = 74,
367 #[doc = "75 - CATB"]
368 CATB = 75,
369 #[doc = "77 - TWIM2"]
370 TWIM2 = 77,
371 #[doc = "78 - TWIM3"]
372 TWIM3 = 78,
373 #[doc = "79 - LCDCA"]
374 LCDCA = 79,
375}
376unsafe impl cortex_m::interrupt::InterruptNumber for Interrupt {
377 #[inline(always)]
378 fn number(self) -> u16 {
379 self as u16
380 }
381}
382#[doc = "Audio Bitstream DAC"]
383pub struct ABDACB {
384 _marker: PhantomData<*const ()>,
385}
386unsafe impl Send for ABDACB {}
387impl ABDACB {
388 #[doc = r"Pointer to the register block"]
389 pub const PTR: *const abdacb::RegisterBlock = 0x4006_4000 as *const _;
390 #[doc = r"Return the pointer to the register block"]
391 #[inline(always)]
392 pub const fn ptr() -> *const abdacb::RegisterBlock {
393 Self::PTR
394 }
395}
396impl Deref for ABDACB {
397 type Target = abdacb::RegisterBlock;
398 #[inline(always)]
399 fn deref(&self) -> &Self::Target {
400 unsafe { &*Self::PTR }
401 }
402}
403impl core::fmt::Debug for ABDACB {
404 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
405 f.debug_struct("ABDACB").finish()
406 }
407}
408#[doc = "Audio Bitstream DAC"]
409pub mod abdacb;
410#[doc = "Analog Comparator Interface"]
411pub struct ACIFC {
412 _marker: PhantomData<*const ()>,
413}
414unsafe impl Send for ACIFC {}
415impl ACIFC {
416 #[doc = r"Pointer to the register block"]
417 pub const PTR: *const acifc::RegisterBlock = 0x4004_0000 as *const _;
418 #[doc = r"Return the pointer to the register block"]
419 #[inline(always)]
420 pub const fn ptr() -> *const acifc::RegisterBlock {
421 Self::PTR
422 }
423}
424impl Deref for ACIFC {
425 type Target = acifc::RegisterBlock;
426 #[inline(always)]
427 fn deref(&self) -> &Self::Target {
428 unsafe { &*Self::PTR }
429 }
430}
431impl core::fmt::Debug for ACIFC {
432 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
433 f.debug_struct("ACIFC").finish()
434 }
435}
436#[doc = "Analog Comparator Interface"]
437pub mod acifc;
438#[doc = "ADC controller interface"]
439pub struct ADCIFE {
440 _marker: PhantomData<*const ()>,
441}
442unsafe impl Send for ADCIFE {}
443impl ADCIFE {
444 #[doc = r"Pointer to the register block"]
445 pub const PTR: *const adcife::RegisterBlock = 0x4003_8000 as *const _;
446 #[doc = r"Return the pointer to the register block"]
447 #[inline(always)]
448 pub const fn ptr() -> *const adcife::RegisterBlock {
449 Self::PTR
450 }
451}
452impl Deref for ADCIFE {
453 type Target = adcife::RegisterBlock;
454 #[inline(always)]
455 fn deref(&self) -> &Self::Target {
456 unsafe { &*Self::PTR }
457 }
458}
459impl core::fmt::Debug for ADCIFE {
460 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
461 f.debug_struct("ADCIFE").finish()
462 }
463}
464#[doc = "ADC controller interface"]
465pub mod adcife;
466#[doc = "Advanced Encryption Standard"]
467pub struct AESA {
468 _marker: PhantomData<*const ()>,
469}
470unsafe impl Send for AESA {}
471impl AESA {
472 #[doc = r"Pointer to the register block"]
473 pub const PTR: *const aesa::RegisterBlock = 0x400b_0000 as *const _;
474 #[doc = r"Return the pointer to the register block"]
475 #[inline(always)]
476 pub const fn ptr() -> *const aesa::RegisterBlock {
477 Self::PTR
478 }
479}
480impl Deref for AESA {
481 type Target = aesa::RegisterBlock;
482 #[inline(always)]
483 fn deref(&self) -> &Self::Target {
484 unsafe { &*Self::PTR }
485 }
486}
487impl core::fmt::Debug for AESA {
488 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
489 f.debug_struct("AESA").finish()
490 }
491}
492#[doc = "Advanced Encryption Standard"]
493pub mod aesa;
494#[doc = "Asynchronous Timer"]
495pub struct AST {
496 _marker: PhantomData<*const ()>,
497}
498unsafe impl Send for AST {}
499impl AST {
500 #[doc = r"Pointer to the register block"]
501 pub const PTR: *const ast::RegisterBlock = 0x400f_0800 as *const _;
502 #[doc = r"Return the pointer to the register block"]
503 #[inline(always)]
504 pub const fn ptr() -> *const ast::RegisterBlock {
505 Self::PTR
506 }
507}
508impl Deref for AST {
509 type Target = ast::RegisterBlock;
510 #[inline(always)]
511 fn deref(&self) -> &Self::Target {
512 unsafe { &*Self::PTR }
513 }
514}
515impl core::fmt::Debug for AST {
516 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
517 f.debug_struct("AST").finish()
518 }
519}
520#[doc = "Asynchronous Timer"]
521pub mod ast;
522#[doc = "Backup Power Manager"]
523pub struct BPM {
524 _marker: PhantomData<*const ()>,
525}
526unsafe impl Send for BPM {}
527impl BPM {
528 #[doc = r"Pointer to the register block"]
529 pub const PTR: *const bpm::RegisterBlock = 0x400f_0000 as *const _;
530 #[doc = r"Return the pointer to the register block"]
531 #[inline(always)]
532 pub const fn ptr() -> *const bpm::RegisterBlock {
533 Self::PTR
534 }
535}
536impl Deref for BPM {
537 type Target = bpm::RegisterBlock;
538 #[inline(always)]
539 fn deref(&self) -> &Self::Target {
540 unsafe { &*Self::PTR }
541 }
542}
543impl core::fmt::Debug for BPM {
544 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
545 f.debug_struct("BPM").finish()
546 }
547}
548#[doc = "Backup Power Manager"]
549pub mod bpm;
550#[doc = "Backup System Control Interface"]
551pub struct BSCIF {
552 _marker: PhantomData<*const ()>,
553}
554unsafe impl Send for BSCIF {}
555impl BSCIF {
556 #[doc = r"Pointer to the register block"]
557 pub const PTR: *const bscif::RegisterBlock = 0x400f_0400 as *const _;
558 #[doc = r"Return the pointer to the register block"]
559 #[inline(always)]
560 pub const fn ptr() -> *const bscif::RegisterBlock {
561 Self::PTR
562 }
563}
564impl Deref for BSCIF {
565 type Target = bscif::RegisterBlock;
566 #[inline(always)]
567 fn deref(&self) -> &Self::Target {
568 unsafe { &*Self::PTR }
569 }
570}
571impl core::fmt::Debug for BSCIF {
572 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
573 f.debug_struct("BSCIF").finish()
574 }
575}
576#[doc = "Backup System Control Interface"]
577pub mod bscif;
578#[doc = "Capacitive Touch Module B"]
579pub struct CATB {
580 _marker: PhantomData<*const ()>,
581}
582unsafe impl Send for CATB {}
583impl CATB {
584 #[doc = r"Pointer to the register block"]
585 pub const PTR: *const catb::RegisterBlock = 0x4007_0000 as *const _;
586 #[doc = r"Return the pointer to the register block"]
587 #[inline(always)]
588 pub const fn ptr() -> *const catb::RegisterBlock {
589 Self::PTR
590 }
591}
592impl Deref for CATB {
593 type Target = catb::RegisterBlock;
594 #[inline(always)]
595 fn deref(&self) -> &Self::Target {
596 unsafe { &*Self::PTR }
597 }
598}
599impl core::fmt::Debug for CATB {
600 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
601 f.debug_struct("CATB").finish()
602 }
603}
604#[doc = "Capacitive Touch Module B"]
605pub mod catb;
606#[doc = "Chip ID Registers"]
607pub struct CHIPID {
608 _marker: PhantomData<*const ()>,
609}
610unsafe impl Send for CHIPID {}
611impl CHIPID {
612 #[doc = r"Pointer to the register block"]
613 pub const PTR: *const chipid::RegisterBlock = 0x400e_0400 as *const _;
614 #[doc = r"Return the pointer to the register block"]
615 #[inline(always)]
616 pub const fn ptr() -> *const chipid::RegisterBlock {
617 Self::PTR
618 }
619}
620impl Deref for CHIPID {
621 type Target = chipid::RegisterBlock;
622 #[inline(always)]
623 fn deref(&self) -> &Self::Target {
624 unsafe { &*Self::PTR }
625 }
626}
627impl core::fmt::Debug for CHIPID {
628 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
629 f.debug_struct("CHIPID").finish()
630 }
631}
632#[doc = "Chip ID Registers"]
633pub mod chipid;
634#[doc = "CRC Calculation Unit"]
635pub struct CRCCU {
636 _marker: PhantomData<*const ()>,
637}
638unsafe impl Send for CRCCU {}
639impl CRCCU {
640 #[doc = r"Pointer to the register block"]
641 pub const PTR: *const crccu::RegisterBlock = 0x400a_4000 as *const _;
642 #[doc = r"Return the pointer to the register block"]
643 #[inline(always)]
644 pub const fn ptr() -> *const crccu::RegisterBlock {
645 Self::PTR
646 }
647}
648impl Deref for CRCCU {
649 type Target = crccu::RegisterBlock;
650 #[inline(always)]
651 fn deref(&self) -> &Self::Target {
652 unsafe { &*Self::PTR }
653 }
654}
655impl core::fmt::Debug for CRCCU {
656 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
657 f.debug_struct("CRCCU").finish()
658 }
659}
660#[doc = "CRC Calculation Unit"]
661pub mod crccu;
662#[doc = "DAC Controller"]
663pub struct DACC {
664 _marker: PhantomData<*const ()>,
665}
666unsafe impl Send for DACC {}
667impl DACC {
668 #[doc = r"Pointer to the register block"]
669 pub const PTR: *const dacc::RegisterBlock = 0x4003_c000 as *const _;
670 #[doc = r"Return the pointer to the register block"]
671 #[inline(always)]
672 pub const fn ptr() -> *const dacc::RegisterBlock {
673 Self::PTR
674 }
675}
676impl Deref for DACC {
677 type Target = dacc::RegisterBlock;
678 #[inline(always)]
679 fn deref(&self) -> &Self::Target {
680 unsafe { &*Self::PTR }
681 }
682}
683impl core::fmt::Debug for DACC {
684 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
685 f.debug_struct("DACC").finish()
686 }
687}
688#[doc = "DAC Controller"]
689pub mod dacc;
690#[doc = "External Interrupt Controller"]
691pub struct EIC {
692 _marker: PhantomData<*const ()>,
693}
694unsafe impl Send for EIC {}
695impl EIC {
696 #[doc = r"Pointer to the register block"]
697 pub const PTR: *const eic::RegisterBlock = 0x400f_1000 as *const _;
698 #[doc = r"Return the pointer to the register block"]
699 #[inline(always)]
700 pub const fn ptr() -> *const eic::RegisterBlock {
701 Self::PTR
702 }
703}
704impl Deref for EIC {
705 type Target = eic::RegisterBlock;
706 #[inline(always)]
707 fn deref(&self) -> &Self::Target {
708 unsafe { &*Self::PTR }
709 }
710}
711impl core::fmt::Debug for EIC {
712 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
713 f.debug_struct("EIC").finish()
714 }
715}
716#[doc = "External Interrupt Controller"]
717pub mod eic;
718#[doc = "Flash Controller"]
719pub struct HFLASHC {
720 _marker: PhantomData<*const ()>,
721}
722unsafe impl Send for HFLASHC {}
723impl HFLASHC {
724 #[doc = r"Pointer to the register block"]
725 pub const PTR: *const hflashc::RegisterBlock = 0x400a_0000 as *const _;
726 #[doc = r"Return the pointer to the register block"]
727 #[inline(always)]
728 pub const fn ptr() -> *const hflashc::RegisterBlock {
729 Self::PTR
730 }
731}
732impl Deref for HFLASHC {
733 type Target = hflashc::RegisterBlock;
734 #[inline(always)]
735 fn deref(&self) -> &Self::Target {
736 unsafe { &*Self::PTR }
737 }
738}
739impl core::fmt::Debug for HFLASHC {
740 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
741 f.debug_struct("HFLASHC").finish()
742 }
743}
744#[doc = "Flash Controller"]
745pub mod hflashc;
746#[doc = "Frequency Meter"]
747pub struct FREQM {
748 _marker: PhantomData<*const ()>,
749}
750unsafe impl Send for FREQM {}
751impl FREQM {
752 #[doc = r"Pointer to the register block"]
753 pub const PTR: *const freqm::RegisterBlock = 0x400e_0c00 as *const _;
754 #[doc = r"Return the pointer to the register block"]
755 #[inline(always)]
756 pub const fn ptr() -> *const freqm::RegisterBlock {
757 Self::PTR
758 }
759}
760impl Deref for FREQM {
761 type Target = freqm::RegisterBlock;
762 #[inline(always)]
763 fn deref(&self) -> &Self::Target {
764 unsafe { &*Self::PTR }
765 }
766}
767impl core::fmt::Debug for FREQM {
768 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
769 f.debug_struct("FREQM").finish()
770 }
771}
772#[doc = "Frequency Meter"]
773pub mod freqm;
774#[doc = "Glue Logic Controller"]
775pub struct GLOC {
776 _marker: PhantomData<*const ()>,
777}
778unsafe impl Send for GLOC {}
779impl GLOC {
780 #[doc = r"Pointer to the register block"]
781 pub const PTR: *const gloc::RegisterBlock = 0x4006_0000 as *const _;
782 #[doc = r"Return the pointer to the register block"]
783 #[inline(always)]
784 pub const fn ptr() -> *const gloc::RegisterBlock {
785 Self::PTR
786 }
787}
788impl Deref for GLOC {
789 type Target = gloc::RegisterBlock;
790 #[inline(always)]
791 fn deref(&self) -> &Self::Target {
792 unsafe { &*Self::PTR }
793 }
794}
795impl core::fmt::Debug for GLOC {
796 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
797 f.debug_struct("GLOC").finish()
798 }
799}
800#[doc = "Glue Logic Controller"]
801pub mod gloc;
802#[doc = "General-Purpose Input/Output Controller"]
803pub struct GPIO {
804 _marker: PhantomData<*const ()>,
805}
806unsafe impl Send for GPIO {}
807impl GPIO {
808 #[doc = r"Pointer to the register block"]
809 pub const PTR: *const gpio::RegisterBlock = 0x400e_1000 as *const _;
810 #[doc = r"Return the pointer to the register block"]
811 #[inline(always)]
812 pub const fn ptr() -> *const gpio::RegisterBlock {
813 Self::PTR
814 }
815}
816impl Deref for GPIO {
817 type Target = gpio::RegisterBlock;
818 #[inline(always)]
819 fn deref(&self) -> &Self::Target {
820 unsafe { &*Self::PTR }
821 }
822}
823impl core::fmt::Debug for GPIO {
824 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
825 f.debug_struct("GPIO").finish()
826 }
827}
828#[doc = "General-Purpose Input/Output Controller"]
829pub mod gpio;
830#[doc = "Cortex M I&D Cache Controller"]
831pub struct HCACHE {
832 _marker: PhantomData<*const ()>,
833}
834unsafe impl Send for HCACHE {}
835impl HCACHE {
836 #[doc = r"Pointer to the register block"]
837 pub const PTR: *const hcache::RegisterBlock = 0x400a_0400 as *const _;
838 #[doc = r"Return the pointer to the register block"]
839 #[inline(always)]
840 pub const fn ptr() -> *const hcache::RegisterBlock {
841 Self::PTR
842 }
843}
844impl Deref for HCACHE {
845 type Target = hcache::RegisterBlock;
846 #[inline(always)]
847 fn deref(&self) -> &Self::Target {
848 unsafe { &*Self::PTR }
849 }
850}
851impl core::fmt::Debug for HCACHE {
852 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
853 f.debug_struct("HCACHE").finish()
854 }
855}
856#[doc = "Cortex M I&D Cache Controller"]
857pub mod hcache;
858#[doc = "HSB Matrix"]
859pub struct HMATRIX {
860 _marker: PhantomData<*const ()>,
861}
862unsafe impl Send for HMATRIX {}
863impl HMATRIX {
864 #[doc = r"Pointer to the register block"]
865 pub const PTR: *const hmatrix::RegisterBlock = 0x400a_1000 as *const _;
866 #[doc = r"Return the pointer to the register block"]
867 #[inline(always)]
868 pub const fn ptr() -> *const hmatrix::RegisterBlock {
869 Self::PTR
870 }
871}
872impl Deref for HMATRIX {
873 type Target = hmatrix::RegisterBlock;
874 #[inline(always)]
875 fn deref(&self) -> &Self::Target {
876 unsafe { &*Self::PTR }
877 }
878}
879impl core::fmt::Debug for HMATRIX {
880 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
881 f.debug_struct("HMATRIX").finish()
882 }
883}
884#[doc = "HSB Matrix"]
885pub mod hmatrix;
886#[doc = "Inter-IC Sound (I2S) Controller"]
887pub struct IISC {
888 _marker: PhantomData<*const ()>,
889}
890unsafe impl Send for IISC {}
891impl IISC {
892 #[doc = r"Pointer to the register block"]
893 pub const PTR: *const iisc::RegisterBlock = 0x4000_4000 as *const _;
894 #[doc = r"Return the pointer to the register block"]
895 #[inline(always)]
896 pub const fn ptr() -> *const iisc::RegisterBlock {
897 Self::PTR
898 }
899}
900impl Deref for IISC {
901 type Target = iisc::RegisterBlock;
902 #[inline(always)]
903 fn deref(&self) -> &Self::Target {
904 unsafe { &*Self::PTR }
905 }
906}
907impl core::fmt::Debug for IISC {
908 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
909 f.debug_struct("IISC").finish()
910 }
911}
912#[doc = "Inter-IC Sound (I2S) Controller"]
913pub mod iisc;
914#[doc = "LCD Controller"]
915pub struct LCDCA {
916 _marker: PhantomData<*const ()>,
917}
918unsafe impl Send for LCDCA {}
919impl LCDCA {
920 #[doc = r"Pointer to the register block"]
921 pub const PTR: *const lcdca::RegisterBlock = 0x4008_0000 as *const _;
922 #[doc = r"Return the pointer to the register block"]
923 #[inline(always)]
924 pub const fn ptr() -> *const lcdca::RegisterBlock {
925 Self::PTR
926 }
927}
928impl Deref for LCDCA {
929 type Target = lcdca::RegisterBlock;
930 #[inline(always)]
931 fn deref(&self) -> &Self::Target {
932 unsafe { &*Self::PTR }
933 }
934}
935impl core::fmt::Debug for LCDCA {
936 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
937 f.debug_struct("LCDCA").finish()
938 }
939}
940#[doc = "LCD Controller"]
941pub mod lcdca;
942#[doc = "Parallel Capture"]
943pub struct PARC {
944 _marker: PhantomData<*const ()>,
945}
946unsafe impl Send for PARC {}
947impl PARC {
948 #[doc = r"Pointer to the register block"]
949 pub const PTR: *const parc::RegisterBlock = 0x4006_c000 as *const _;
950 #[doc = r"Return the pointer to the register block"]
951 #[inline(always)]
952 pub const fn ptr() -> *const parc::RegisterBlock {
953 Self::PTR
954 }
955}
956impl Deref for PARC {
957 type Target = parc::RegisterBlock;
958 #[inline(always)]
959 fn deref(&self) -> &Self::Target {
960 unsafe { &*Self::PTR }
961 }
962}
963impl core::fmt::Debug for PARC {
964 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
965 f.debug_struct("PARC").finish()
966 }
967}
968#[doc = "Parallel Capture"]
969pub mod parc;
970#[doc = "Peripheral DMA Controller"]
971pub struct PDCA {
972 _marker: PhantomData<*const ()>,
973}
974unsafe impl Send for PDCA {}
975impl PDCA {
976 #[doc = r"Pointer to the register block"]
977 pub const PTR: *const pdca::RegisterBlock = 0x400a_2000 as *const _;
978 #[doc = r"Return the pointer to the register block"]
979 #[inline(always)]
980 pub const fn ptr() -> *const pdca::RegisterBlock {
981 Self::PTR
982 }
983}
984impl Deref for PDCA {
985 type Target = pdca::RegisterBlock;
986 #[inline(always)]
987 fn deref(&self) -> &Self::Target {
988 unsafe { &*Self::PTR }
989 }
990}
991impl core::fmt::Debug for PDCA {
992 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
993 f.debug_struct("PDCA").finish()
994 }
995}
996#[doc = "Peripheral DMA Controller"]
997pub mod pdca;
998#[doc = "Peripheral Event Controller"]
999pub struct PEVC {
1000 _marker: PhantomData<*const ()>,
1001}
1002unsafe impl Send for PEVC {}
1003impl PEVC {
1004 #[doc = r"Pointer to the register block"]
1005 pub const PTR: *const pevc::RegisterBlock = 0x400a_6000 as *const _;
1006 #[doc = r"Return the pointer to the register block"]
1007 #[inline(always)]
1008 pub const fn ptr() -> *const pevc::RegisterBlock {
1009 Self::PTR
1010 }
1011}
1012impl Deref for PEVC {
1013 type Target = pevc::RegisterBlock;
1014 #[inline(always)]
1015 fn deref(&self) -> &Self::Target {
1016 unsafe { &*Self::PTR }
1017 }
1018}
1019impl core::fmt::Debug for PEVC {
1020 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1021 f.debug_struct("PEVC").finish()
1022 }
1023}
1024#[doc = "Peripheral Event Controller"]
1025pub mod pevc;
1026#[doc = "Pico UART"]
1027pub struct PICOUART {
1028 _marker: PhantomData<*const ()>,
1029}
1030unsafe impl Send for PICOUART {}
1031impl PICOUART {
1032 #[doc = r"Pointer to the register block"]
1033 pub const PTR: *const picouart::RegisterBlock = 0x400f_1400 as *const _;
1034 #[doc = r"Return the pointer to the register block"]
1035 #[inline(always)]
1036 pub const fn ptr() -> *const picouart::RegisterBlock {
1037 Self::PTR
1038 }
1039}
1040impl Deref for PICOUART {
1041 type Target = picouart::RegisterBlock;
1042 #[inline(always)]
1043 fn deref(&self) -> &Self::Target {
1044 unsafe { &*Self::PTR }
1045 }
1046}
1047impl core::fmt::Debug for PICOUART {
1048 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1049 f.debug_struct("PICOUART").finish()
1050 }
1051}
1052#[doc = "Pico UART"]
1053pub mod picouart;
1054#[doc = "Power Manager"]
1055pub struct PM {
1056 _marker: PhantomData<*const ()>,
1057}
1058unsafe impl Send for PM {}
1059impl PM {
1060 #[doc = r"Pointer to the register block"]
1061 pub const PTR: *const pm::RegisterBlock = 0x400e_0000 as *const _;
1062 #[doc = r"Return the pointer to the register block"]
1063 #[inline(always)]
1064 pub const fn ptr() -> *const pm::RegisterBlock {
1065 Self::PTR
1066 }
1067}
1068impl Deref for PM {
1069 type Target = pm::RegisterBlock;
1070 #[inline(always)]
1071 fn deref(&self) -> &Self::Target {
1072 unsafe { &*Self::PTR }
1073 }
1074}
1075impl core::fmt::Debug for PM {
1076 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1077 f.debug_struct("PM").finish()
1078 }
1079}
1080#[doc = "Power Manager"]
1081pub mod pm;
1082#[doc = "System Control Interface"]
1083pub struct SCIF {
1084 _marker: PhantomData<*const ()>,
1085}
1086unsafe impl Send for SCIF {}
1087impl SCIF {
1088 #[doc = r"Pointer to the register block"]
1089 pub const PTR: *const scif::RegisterBlock = 0x400e_0800 as *const _;
1090 #[doc = r"Return the pointer to the register block"]
1091 #[inline(always)]
1092 pub const fn ptr() -> *const scif::RegisterBlock {
1093 Self::PTR
1094 }
1095}
1096impl Deref for SCIF {
1097 type Target = scif::RegisterBlock;
1098 #[inline(always)]
1099 fn deref(&self) -> &Self::Target {
1100 unsafe { &*Self::PTR }
1101 }
1102}
1103impl core::fmt::Debug for SCIF {
1104 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1105 f.debug_struct("SCIF").finish()
1106 }
1107}
1108#[doc = "System Control Interface"]
1109pub mod scif;
1110#[doc = "System Manager Access Port"]
1111pub struct SMAP {
1112 _marker: PhantomData<*const ()>,
1113}
1114unsafe impl Send for SMAP {}
1115impl SMAP {
1116 #[doc = r"Pointer to the register block"]
1117 pub const PTR: *const smap::RegisterBlock = 0x400a_3000 as *const _;
1118 #[doc = r"Return the pointer to the register block"]
1119 #[inline(always)]
1120 pub const fn ptr() -> *const smap::RegisterBlock {
1121 Self::PTR
1122 }
1123}
1124impl Deref for SMAP {
1125 type Target = smap::RegisterBlock;
1126 #[inline(always)]
1127 fn deref(&self) -> &Self::Target {
1128 unsafe { &*Self::PTR }
1129 }
1130}
1131impl core::fmt::Debug for SMAP {
1132 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1133 f.debug_struct("SMAP").finish()
1134 }
1135}
1136#[doc = "System Manager Access Port"]
1137pub mod smap;
1138#[doc = "Serial Peripheral Interface"]
1139pub struct SPI {
1140 _marker: PhantomData<*const ()>,
1141}
1142unsafe impl Send for SPI {}
1143impl SPI {
1144 #[doc = r"Pointer to the register block"]
1145 pub const PTR: *const spi::RegisterBlock = 0x4000_8000 as *const _;
1146 #[doc = r"Return the pointer to the register block"]
1147 #[inline(always)]
1148 pub const fn ptr() -> *const spi::RegisterBlock {
1149 Self::PTR
1150 }
1151}
1152impl Deref for SPI {
1153 type Target = spi::RegisterBlock;
1154 #[inline(always)]
1155 fn deref(&self) -> &Self::Target {
1156 unsafe { &*Self::PTR }
1157 }
1158}
1159impl core::fmt::Debug for SPI {
1160 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1161 f.debug_struct("SPI").finish()
1162 }
1163}
1164#[doc = "Serial Peripheral Interface"]
1165pub mod spi;
1166#[doc = "Timer/Counter 0"]
1167pub struct TC0 {
1168 _marker: PhantomData<*const ()>,
1169}
1170unsafe impl Send for TC0 {}
1171impl TC0 {
1172 #[doc = r"Pointer to the register block"]
1173 pub const PTR: *const tc0::RegisterBlock = 0x4001_0000 as *const _;
1174 #[doc = r"Return the pointer to the register block"]
1175 #[inline(always)]
1176 pub const fn ptr() -> *const tc0::RegisterBlock {
1177 Self::PTR
1178 }
1179}
1180impl Deref for TC0 {
1181 type Target = tc0::RegisterBlock;
1182 #[inline(always)]
1183 fn deref(&self) -> &Self::Target {
1184 unsafe { &*Self::PTR }
1185 }
1186}
1187impl core::fmt::Debug for TC0 {
1188 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1189 f.debug_struct("TC0").finish()
1190 }
1191}
1192#[doc = "Timer/Counter 0"]
1193pub mod tc0;
1194#[doc = "Timer/Counter 1"]
1195pub struct TC1 {
1196 _marker: PhantomData<*const ()>,
1197}
1198unsafe impl Send for TC1 {}
1199impl TC1 {
1200 #[doc = r"Pointer to the register block"]
1201 pub const PTR: *const tc0::RegisterBlock = 0x4001_4000 as *const _;
1202 #[doc = r"Return the pointer to the register block"]
1203 #[inline(always)]
1204 pub const fn ptr() -> *const tc0::RegisterBlock {
1205 Self::PTR
1206 }
1207}
1208impl Deref for TC1 {
1209 type Target = tc0::RegisterBlock;
1210 #[inline(always)]
1211 fn deref(&self) -> &Self::Target {
1212 unsafe { &*Self::PTR }
1213 }
1214}
1215impl core::fmt::Debug for TC1 {
1216 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1217 f.debug_struct("TC1").finish()
1218 }
1219}
1220#[doc = "Timer/Counter 1"]
1221pub use self::tc0 as tc1;
1222#[doc = "True Random Number Generator"]
1223pub struct TRNG {
1224 _marker: PhantomData<*const ()>,
1225}
1226unsafe impl Send for TRNG {}
1227impl TRNG {
1228 #[doc = r"Pointer to the register block"]
1229 pub const PTR: *const trng::RegisterBlock = 0x4006_8000 as *const _;
1230 #[doc = r"Return the pointer to the register block"]
1231 #[inline(always)]
1232 pub const fn ptr() -> *const trng::RegisterBlock {
1233 Self::PTR
1234 }
1235}
1236impl Deref for TRNG {
1237 type Target = trng::RegisterBlock;
1238 #[inline(always)]
1239 fn deref(&self) -> &Self::Target {
1240 unsafe { &*Self::PTR }
1241 }
1242}
1243impl core::fmt::Debug for TRNG {
1244 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1245 f.debug_struct("TRNG").finish()
1246 }
1247}
1248#[doc = "True Random Number Generator"]
1249pub mod trng;
1250#[doc = "Two-wire Master Interface 0"]
1251pub struct TWIM0 {
1252 _marker: PhantomData<*const ()>,
1253}
1254unsafe impl Send for TWIM0 {}
1255impl TWIM0 {
1256 #[doc = r"Pointer to the register block"]
1257 pub const PTR: *const twim0::RegisterBlock = 0x4001_8000 as *const _;
1258 #[doc = r"Return the pointer to the register block"]
1259 #[inline(always)]
1260 pub const fn ptr() -> *const twim0::RegisterBlock {
1261 Self::PTR
1262 }
1263}
1264impl Deref for TWIM0 {
1265 type Target = twim0::RegisterBlock;
1266 #[inline(always)]
1267 fn deref(&self) -> &Self::Target {
1268 unsafe { &*Self::PTR }
1269 }
1270}
1271impl core::fmt::Debug for TWIM0 {
1272 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1273 f.debug_struct("TWIM0").finish()
1274 }
1275}
1276#[doc = "Two-wire Master Interface 0"]
1277pub mod twim0;
1278#[doc = "Two-wire Master Interface 1"]
1279pub struct TWIM1 {
1280 _marker: PhantomData<*const ()>,
1281}
1282unsafe impl Send for TWIM1 {}
1283impl TWIM1 {
1284 #[doc = r"Pointer to the register block"]
1285 pub const PTR: *const twim0::RegisterBlock = 0x4001_c000 as *const _;
1286 #[doc = r"Return the pointer to the register block"]
1287 #[inline(always)]
1288 pub const fn ptr() -> *const twim0::RegisterBlock {
1289 Self::PTR
1290 }
1291}
1292impl Deref for TWIM1 {
1293 type Target = twim0::RegisterBlock;
1294 #[inline(always)]
1295 fn deref(&self) -> &Self::Target {
1296 unsafe { &*Self::PTR }
1297 }
1298}
1299impl core::fmt::Debug for TWIM1 {
1300 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1301 f.debug_struct("TWIM1").finish()
1302 }
1303}
1304#[doc = "Two-wire Master Interface 1"]
1305pub use self::twim0 as twim1;
1306#[doc = "Two-wire Master Interface 2"]
1307pub struct TWIM2 {
1308 _marker: PhantomData<*const ()>,
1309}
1310unsafe impl Send for TWIM2 {}
1311impl TWIM2 {
1312 #[doc = r"Pointer to the register block"]
1313 pub const PTR: *const twim0::RegisterBlock = 0x4007_8000 as *const _;
1314 #[doc = r"Return the pointer to the register block"]
1315 #[inline(always)]
1316 pub const fn ptr() -> *const twim0::RegisterBlock {
1317 Self::PTR
1318 }
1319}
1320impl Deref for TWIM2 {
1321 type Target = twim0::RegisterBlock;
1322 #[inline(always)]
1323 fn deref(&self) -> &Self::Target {
1324 unsafe { &*Self::PTR }
1325 }
1326}
1327impl core::fmt::Debug for TWIM2 {
1328 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1329 f.debug_struct("TWIM2").finish()
1330 }
1331}
1332#[doc = "Two-wire Master Interface 2"]
1333pub use self::twim0 as twim2;
1334#[doc = "Two-wire Master Interface 3"]
1335pub struct TWIM3 {
1336 _marker: PhantomData<*const ()>,
1337}
1338unsafe impl Send for TWIM3 {}
1339impl TWIM3 {
1340 #[doc = r"Pointer to the register block"]
1341 pub const PTR: *const twim0::RegisterBlock = 0x4007_c000 as *const _;
1342 #[doc = r"Return the pointer to the register block"]
1343 #[inline(always)]
1344 pub const fn ptr() -> *const twim0::RegisterBlock {
1345 Self::PTR
1346 }
1347}
1348impl Deref for TWIM3 {
1349 type Target = twim0::RegisterBlock;
1350 #[inline(always)]
1351 fn deref(&self) -> &Self::Target {
1352 unsafe { &*Self::PTR }
1353 }
1354}
1355impl core::fmt::Debug for TWIM3 {
1356 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1357 f.debug_struct("TWIM3").finish()
1358 }
1359}
1360#[doc = "Two-wire Master Interface 3"]
1361pub use self::twim0 as twim3;
1362#[doc = "Two-wire Slave Interface 0"]
1363pub struct TWIS0 {
1364 _marker: PhantomData<*const ()>,
1365}
1366unsafe impl Send for TWIS0 {}
1367impl TWIS0 {
1368 #[doc = r"Pointer to the register block"]
1369 pub const PTR: *const twis0::RegisterBlock = 0x4001_8400 as *const _;
1370 #[doc = r"Return the pointer to the register block"]
1371 #[inline(always)]
1372 pub const fn ptr() -> *const twis0::RegisterBlock {
1373 Self::PTR
1374 }
1375}
1376impl Deref for TWIS0 {
1377 type Target = twis0::RegisterBlock;
1378 #[inline(always)]
1379 fn deref(&self) -> &Self::Target {
1380 unsafe { &*Self::PTR }
1381 }
1382}
1383impl core::fmt::Debug for TWIS0 {
1384 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1385 f.debug_struct("TWIS0").finish()
1386 }
1387}
1388#[doc = "Two-wire Slave Interface 0"]
1389pub mod twis0;
1390#[doc = "Two-wire Slave Interface 1"]
1391pub struct TWIS1 {
1392 _marker: PhantomData<*const ()>,
1393}
1394unsafe impl Send for TWIS1 {}
1395impl TWIS1 {
1396 #[doc = r"Pointer to the register block"]
1397 pub const PTR: *const twis0::RegisterBlock = 0x4001_c400 as *const _;
1398 #[doc = r"Return the pointer to the register block"]
1399 #[inline(always)]
1400 pub const fn ptr() -> *const twis0::RegisterBlock {
1401 Self::PTR
1402 }
1403}
1404impl Deref for TWIS1 {
1405 type Target = twis0::RegisterBlock;
1406 #[inline(always)]
1407 fn deref(&self) -> &Self::Target {
1408 unsafe { &*Self::PTR }
1409 }
1410}
1411impl core::fmt::Debug for TWIS1 {
1412 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1413 f.debug_struct("TWIS1").finish()
1414 }
1415}
1416#[doc = "Two-wire Slave Interface 1"]
1417pub use self::twis0 as twis1;
1418#[doc = "Universal Synchronous Asynchronous Receiver Transmitter 0"]
1419pub struct USART0 {
1420 _marker: PhantomData<*const ()>,
1421}
1422unsafe impl Send for USART0 {}
1423impl USART0 {
1424 #[doc = r"Pointer to the register block"]
1425 pub const PTR: *const usart0::RegisterBlock = 0x4002_4000 as *const _;
1426 #[doc = r"Return the pointer to the register block"]
1427 #[inline(always)]
1428 pub const fn ptr() -> *const usart0::RegisterBlock {
1429 Self::PTR
1430 }
1431}
1432impl Deref for USART0 {
1433 type Target = usart0::RegisterBlock;
1434 #[inline(always)]
1435 fn deref(&self) -> &Self::Target {
1436 unsafe { &*Self::PTR }
1437 }
1438}
1439impl core::fmt::Debug for USART0 {
1440 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1441 f.debug_struct("USART0").finish()
1442 }
1443}
1444#[doc = "Universal Synchronous Asynchronous Receiver Transmitter 0"]
1445pub mod usart0;
1446#[doc = "Universal Synchronous Asynchronous Receiver Transmitter 1"]
1447pub struct USART1 {
1448 _marker: PhantomData<*const ()>,
1449}
1450unsafe impl Send for USART1 {}
1451impl USART1 {
1452 #[doc = r"Pointer to the register block"]
1453 pub const PTR: *const usart0::RegisterBlock = 0x4002_8000 as *const _;
1454 #[doc = r"Return the pointer to the register block"]
1455 #[inline(always)]
1456 pub const fn ptr() -> *const usart0::RegisterBlock {
1457 Self::PTR
1458 }
1459}
1460impl Deref for USART1 {
1461 type Target = usart0::RegisterBlock;
1462 #[inline(always)]
1463 fn deref(&self) -> &Self::Target {
1464 unsafe { &*Self::PTR }
1465 }
1466}
1467impl core::fmt::Debug for USART1 {
1468 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1469 f.debug_struct("USART1").finish()
1470 }
1471}
1472#[doc = "Universal Synchronous Asynchronous Receiver Transmitter 1"]
1473pub use self::usart0 as usart1;
1474#[doc = "Universal Synchronous Asynchronous Receiver Transmitter 2"]
1475pub struct USART2 {
1476 _marker: PhantomData<*const ()>,
1477}
1478unsafe impl Send for USART2 {}
1479impl USART2 {
1480 #[doc = r"Pointer to the register block"]
1481 pub const PTR: *const usart0::RegisterBlock = 0x4002_c000 as *const _;
1482 #[doc = r"Return the pointer to the register block"]
1483 #[inline(always)]
1484 pub const fn ptr() -> *const usart0::RegisterBlock {
1485 Self::PTR
1486 }
1487}
1488impl Deref for USART2 {
1489 type Target = usart0::RegisterBlock;
1490 #[inline(always)]
1491 fn deref(&self) -> &Self::Target {
1492 unsafe { &*Self::PTR }
1493 }
1494}
1495impl core::fmt::Debug for USART2 {
1496 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1497 f.debug_struct("USART2").finish()
1498 }
1499}
1500#[doc = "Universal Synchronous Asynchronous Receiver Transmitter 2"]
1501pub use self::usart0 as usart2;
1502#[doc = "Universal Synchronous Asynchronous Receiver Transmitter 3"]
1503pub struct USART3 {
1504 _marker: PhantomData<*const ()>,
1505}
1506unsafe impl Send for USART3 {}
1507impl USART3 {
1508 #[doc = r"Pointer to the register block"]
1509 pub const PTR: *const usart0::RegisterBlock = 0x4003_0000 as *const _;
1510 #[doc = r"Return the pointer to the register block"]
1511 #[inline(always)]
1512 pub const fn ptr() -> *const usart0::RegisterBlock {
1513 Self::PTR
1514 }
1515}
1516impl Deref for USART3 {
1517 type Target = usart0::RegisterBlock;
1518 #[inline(always)]
1519 fn deref(&self) -> &Self::Target {
1520 unsafe { &*Self::PTR }
1521 }
1522}
1523impl core::fmt::Debug for USART3 {
1524 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1525 f.debug_struct("USART3").finish()
1526 }
1527}
1528#[doc = "Universal Synchronous Asynchronous Receiver Transmitter 3"]
1529pub use self::usart0 as usart3;
1530#[doc = "USB 2.0 Interface"]
1531pub struct USBC {
1532 _marker: PhantomData<*const ()>,
1533}
1534unsafe impl Send for USBC {}
1535impl USBC {
1536 #[doc = r"Pointer to the register block"]
1537 pub const PTR: *const usbc::RegisterBlock = 0x400a_5000 as *const _;
1538 #[doc = r"Return the pointer to the register block"]
1539 #[inline(always)]
1540 pub const fn ptr() -> *const usbc::RegisterBlock {
1541 Self::PTR
1542 }
1543}
1544impl Deref for USBC {
1545 type Target = usbc::RegisterBlock;
1546 #[inline(always)]
1547 fn deref(&self) -> &Self::Target {
1548 unsafe { &*Self::PTR }
1549 }
1550}
1551impl core::fmt::Debug for USBC {
1552 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1553 f.debug_struct("USBC").finish()
1554 }
1555}
1556#[doc = "USB 2.0 Interface"]
1557pub mod usbc;
1558#[doc = "Watchdog Timer"]
1559pub struct WDT {
1560 _marker: PhantomData<*const ()>,
1561}
1562unsafe impl Send for WDT {}
1563impl WDT {
1564 #[doc = r"Pointer to the register block"]
1565 pub const PTR: *const wdt::RegisterBlock = 0x400f_0c00 as *const _;
1566 #[doc = r"Return the pointer to the register block"]
1567 #[inline(always)]
1568 pub const fn ptr() -> *const wdt::RegisterBlock {
1569 Self::PTR
1570 }
1571}
1572impl Deref for WDT {
1573 type Target = wdt::RegisterBlock;
1574 #[inline(always)]
1575 fn deref(&self) -> &Self::Target {
1576 unsafe { &*Self::PTR }
1577 }
1578}
1579impl core::fmt::Debug for WDT {
1580 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1581 f.debug_struct("WDT").finish()
1582 }
1583}
1584#[doc = "Watchdog Timer"]
1585pub mod wdt;
1586#[no_mangle]
1587static mut DEVICE_PERIPHERALS: bool = false;
1588#[doc = r" All the peripherals."]
1589#[allow(non_snake_case)]
1590pub struct Peripherals {
1591 #[doc = "ABDACB"]
1592 pub ABDACB: ABDACB,
1593 #[doc = "ACIFC"]
1594 pub ACIFC: ACIFC,
1595 #[doc = "ADCIFE"]
1596 pub ADCIFE: ADCIFE,
1597 #[doc = "AESA"]
1598 pub AESA: AESA,
1599 #[doc = "AST"]
1600 pub AST: AST,
1601 #[doc = "BPM"]
1602 pub BPM: BPM,
1603 #[doc = "BSCIF"]
1604 pub BSCIF: BSCIF,
1605 #[doc = "CATB"]
1606 pub CATB: CATB,
1607 #[doc = "CHIPID"]
1608 pub CHIPID: CHIPID,
1609 #[doc = "CRCCU"]
1610 pub CRCCU: CRCCU,
1611 #[doc = "DACC"]
1612 pub DACC: DACC,
1613 #[doc = "EIC"]
1614 pub EIC: EIC,
1615 #[doc = "HFLASHC"]
1616 pub HFLASHC: HFLASHC,
1617 #[doc = "FREQM"]
1618 pub FREQM: FREQM,
1619 #[doc = "GLOC"]
1620 pub GLOC: GLOC,
1621 #[doc = "GPIO"]
1622 pub GPIO: GPIO,
1623 #[doc = "HCACHE"]
1624 pub HCACHE: HCACHE,
1625 #[doc = "HMATRIX"]
1626 pub HMATRIX: HMATRIX,
1627 #[doc = "IISC"]
1628 pub IISC: IISC,
1629 #[doc = "LCDCA"]
1630 pub LCDCA: LCDCA,
1631 #[doc = "PARC"]
1632 pub PARC: PARC,
1633 #[doc = "PDCA"]
1634 pub PDCA: PDCA,
1635 #[doc = "PEVC"]
1636 pub PEVC: PEVC,
1637 #[doc = "PICOUART"]
1638 pub PICOUART: PICOUART,
1639 #[doc = "PM"]
1640 pub PM: PM,
1641 #[doc = "SCIF"]
1642 pub SCIF: SCIF,
1643 #[doc = "SMAP"]
1644 pub SMAP: SMAP,
1645 #[doc = "SPI"]
1646 pub SPI: SPI,
1647 #[doc = "TC0"]
1648 pub TC0: TC0,
1649 #[doc = "TC1"]
1650 pub TC1: TC1,
1651 #[doc = "TRNG"]
1652 pub TRNG: TRNG,
1653 #[doc = "TWIM0"]
1654 pub TWIM0: TWIM0,
1655 #[doc = "TWIM1"]
1656 pub TWIM1: TWIM1,
1657 #[doc = "TWIM2"]
1658 pub TWIM2: TWIM2,
1659 #[doc = "TWIM3"]
1660 pub TWIM3: TWIM3,
1661 #[doc = "TWIS0"]
1662 pub TWIS0: TWIS0,
1663 #[doc = "TWIS1"]
1664 pub TWIS1: TWIS1,
1665 #[doc = "USART0"]
1666 pub USART0: USART0,
1667 #[doc = "USART1"]
1668 pub USART1: USART1,
1669 #[doc = "USART2"]
1670 pub USART2: USART2,
1671 #[doc = "USART3"]
1672 pub USART3: USART3,
1673 #[doc = "USBC"]
1674 pub USBC: USBC,
1675 #[doc = "WDT"]
1676 pub WDT: WDT,
1677}
1678impl Peripherals {
1679 #[doc = r" Returns all the peripherals *once*."]
1680 #[cfg(feature = "critical-section")]
1681 #[inline]
1682 pub fn take() -> Option<Self> {
1683 critical_section::with(|_| {
1684 if unsafe { DEVICE_PERIPHERALS } {
1685 return None;
1686 }
1687 Some(unsafe { Peripherals::steal() })
1688 })
1689 }
1690 #[doc = r" Unchecked version of `Peripherals::take`."]
1691 #[doc = r""]
1692 #[doc = r" # Safety"]
1693 #[doc = r""]
1694 #[doc = r" Each of the returned peripherals must be used at most once."]
1695 #[inline]
1696 pub unsafe fn steal() -> Self {
1697 DEVICE_PERIPHERALS = true;
1698 Peripherals {
1699 ABDACB: ABDACB {
1700 _marker: PhantomData,
1701 },
1702 ACIFC: ACIFC {
1703 _marker: PhantomData,
1704 },
1705 ADCIFE: ADCIFE {
1706 _marker: PhantomData,
1707 },
1708 AESA: AESA {
1709 _marker: PhantomData,
1710 },
1711 AST: AST {
1712 _marker: PhantomData,
1713 },
1714 BPM: BPM {
1715 _marker: PhantomData,
1716 },
1717 BSCIF: BSCIF {
1718 _marker: PhantomData,
1719 },
1720 CATB: CATB {
1721 _marker: PhantomData,
1722 },
1723 CHIPID: CHIPID {
1724 _marker: PhantomData,
1725 },
1726 CRCCU: CRCCU {
1727 _marker: PhantomData,
1728 },
1729 DACC: DACC {
1730 _marker: PhantomData,
1731 },
1732 EIC: EIC {
1733 _marker: PhantomData,
1734 },
1735 HFLASHC: HFLASHC {
1736 _marker: PhantomData,
1737 },
1738 FREQM: FREQM {
1739 _marker: PhantomData,
1740 },
1741 GLOC: GLOC {
1742 _marker: PhantomData,
1743 },
1744 GPIO: GPIO {
1745 _marker: PhantomData,
1746 },
1747 HCACHE: HCACHE {
1748 _marker: PhantomData,
1749 },
1750 HMATRIX: HMATRIX {
1751 _marker: PhantomData,
1752 },
1753 IISC: IISC {
1754 _marker: PhantomData,
1755 },
1756 LCDCA: LCDCA {
1757 _marker: PhantomData,
1758 },
1759 PARC: PARC {
1760 _marker: PhantomData,
1761 },
1762 PDCA: PDCA {
1763 _marker: PhantomData,
1764 },
1765 PEVC: PEVC {
1766 _marker: PhantomData,
1767 },
1768 PICOUART: PICOUART {
1769 _marker: PhantomData,
1770 },
1771 PM: PM {
1772 _marker: PhantomData,
1773 },
1774 SCIF: SCIF {
1775 _marker: PhantomData,
1776 },
1777 SMAP: SMAP {
1778 _marker: PhantomData,
1779 },
1780 SPI: SPI {
1781 _marker: PhantomData,
1782 },
1783 TC0: TC0 {
1784 _marker: PhantomData,
1785 },
1786 TC1: TC1 {
1787 _marker: PhantomData,
1788 },
1789 TRNG: TRNG {
1790 _marker: PhantomData,
1791 },
1792 TWIM0: TWIM0 {
1793 _marker: PhantomData,
1794 },
1795 TWIM1: TWIM1 {
1796 _marker: PhantomData,
1797 },
1798 TWIM2: TWIM2 {
1799 _marker: PhantomData,
1800 },
1801 TWIM3: TWIM3 {
1802 _marker: PhantomData,
1803 },
1804 TWIS0: TWIS0 {
1805 _marker: PhantomData,
1806 },
1807 TWIS1: TWIS1 {
1808 _marker: PhantomData,
1809 },
1810 USART0: USART0 {
1811 _marker: PhantomData,
1812 },
1813 USART1: USART1 {
1814 _marker: PhantomData,
1815 },
1816 USART2: USART2 {
1817 _marker: PhantomData,
1818 },
1819 USART3: USART3 {
1820 _marker: PhantomData,
1821 },
1822 USBC: USBC {
1823 _marker: PhantomData,
1824 },
1825 WDT: WDT {
1826 _marker: PhantomData,
1827 },
1828 }
1829 }
1830}