1#![doc = "Peripheral access API for STM32F401 microcontrollers (generated using svd2rust v0.24.1 ( ))\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.24.1/svd2rust/#peripheral-api\n[next]: https://github.com/rust-embedded/svd2rust/blob/master/CHANGELOG.md#unreleased\n[repository]: https://github.com/rust-embedded/svd2rust"]
3use core::marker::PhantomData;
4use core::ops::Deref;
5#[doc = r"Number available in the NVIC for configuring priority"]
6pub const NVIC_PRIO_BITS: u8 = 4;
7#[cfg(feature = "rt")]
8pub use self::Interrupt as interrupt;
9pub use cortex_m::peripheral::Peripherals as CorePeripherals;
10pub use cortex_m::peripheral::{CBP, CPUID, DCB, DWT, FPB, ITM, MPU, NVIC, SCB, SYST, TPIU};
11#[cfg(feature = "rt")]
12pub use cortex_m_rt::interrupt;
13#[cfg(feature = "rt")]
14extern "C" {
15 fn PVD();
16 fn TAMP_STAMP();
17 fn RTC_WKUP();
18 fn FLASH();
19 fn RCC();
20 fn EXTI0();
21 fn EXTI1();
22 fn EXTI2();
23 fn EXTI3();
24 fn EXTI4();
25 fn DMA1_STREAM0();
26 fn DMA1_STREAM1();
27 fn DMA1_STREAM2();
28 fn DMA1_STREAM3();
29 fn DMA1_STREAM4();
30 fn DMA1_STREAM5();
31 fn DMA1_STREAM6();
32 fn ADC();
33 fn EXTI9_5();
34 fn TIM1_BRK_TIM9();
35 fn TIM1_UP_TIM10();
36 fn TIM1_TRG_COM_TIM11();
37 fn TIM1_CC();
38 fn TIM2();
39 fn TIM3();
40 fn TIM4();
41 fn I2C1_EV();
42 fn I2C1_ER();
43 fn I2C2_EV();
44 fn I2C2_ER();
45 fn SPI1();
46 fn SPI2();
47 fn USART1();
48 fn USART2();
49 fn EXTI15_10();
50 fn RTC_ALARM();
51 fn OTG_FS_WKUP();
52 fn DMA1_STREAM7();
53 fn SDIO();
54 fn TIM5();
55 fn SPI3();
56 fn DMA2_STREAM0();
57 fn DMA2_STREAM1();
58 fn DMA2_STREAM2();
59 fn DMA2_STREAM3();
60 fn DMA2_STREAM4();
61 fn OTG_FS();
62 fn DMA2_STREAM5();
63 fn DMA2_STREAM6();
64 fn DMA2_STREAM7();
65 fn USART6();
66 fn I2C3_EV();
67 fn I2C3_ER();
68 fn FPU();
69 fn SPI4();
70}
71#[doc(hidden)]
72pub union Vector {
73 _handler: unsafe extern "C" fn(),
74 _reserved: u32,
75}
76#[cfg(feature = "rt")]
77#[doc(hidden)]
78#[link_section = ".vector_table.interrupts"]
79#[no_mangle]
80pub static __INTERRUPTS: [Vector; 85] = [
81 Vector { _reserved: 0 },
82 Vector { _handler: PVD },
83 Vector {
84 _handler: TAMP_STAMP,
85 },
86 Vector { _handler: RTC_WKUP },
87 Vector { _handler: FLASH },
88 Vector { _handler: RCC },
89 Vector { _handler: EXTI0 },
90 Vector { _handler: EXTI1 },
91 Vector { _handler: EXTI2 },
92 Vector { _handler: EXTI3 },
93 Vector { _handler: EXTI4 },
94 Vector {
95 _handler: DMA1_STREAM0,
96 },
97 Vector {
98 _handler: DMA1_STREAM1,
99 },
100 Vector {
101 _handler: DMA1_STREAM2,
102 },
103 Vector {
104 _handler: DMA1_STREAM3,
105 },
106 Vector {
107 _handler: DMA1_STREAM4,
108 },
109 Vector {
110 _handler: DMA1_STREAM5,
111 },
112 Vector {
113 _handler: DMA1_STREAM6,
114 },
115 Vector { _handler: ADC },
116 Vector { _reserved: 0 },
117 Vector { _reserved: 0 },
118 Vector { _reserved: 0 },
119 Vector { _reserved: 0 },
120 Vector { _handler: EXTI9_5 },
121 Vector {
122 _handler: TIM1_BRK_TIM9,
123 },
124 Vector {
125 _handler: TIM1_UP_TIM10,
126 },
127 Vector {
128 _handler: TIM1_TRG_COM_TIM11,
129 },
130 Vector { _handler: TIM1_CC },
131 Vector { _handler: TIM2 },
132 Vector { _handler: TIM3 },
133 Vector { _handler: TIM4 },
134 Vector { _handler: I2C1_EV },
135 Vector { _handler: I2C1_ER },
136 Vector { _handler: I2C2_EV },
137 Vector { _handler: I2C2_ER },
138 Vector { _handler: SPI1 },
139 Vector { _handler: SPI2 },
140 Vector { _handler: USART1 },
141 Vector { _handler: USART2 },
142 Vector { _reserved: 0 },
143 Vector {
144 _handler: EXTI15_10,
145 },
146 Vector {
147 _handler: RTC_ALARM,
148 },
149 Vector {
150 _handler: OTG_FS_WKUP,
151 },
152 Vector { _reserved: 0 },
153 Vector { _reserved: 0 },
154 Vector { _reserved: 0 },
155 Vector { _reserved: 0 },
156 Vector {
157 _handler: DMA1_STREAM7,
158 },
159 Vector { _reserved: 0 },
160 Vector { _handler: SDIO },
161 Vector { _handler: TIM5 },
162 Vector { _handler: SPI3 },
163 Vector { _reserved: 0 },
164 Vector { _reserved: 0 },
165 Vector { _reserved: 0 },
166 Vector { _reserved: 0 },
167 Vector {
168 _handler: DMA2_STREAM0,
169 },
170 Vector {
171 _handler: DMA2_STREAM1,
172 },
173 Vector {
174 _handler: DMA2_STREAM2,
175 },
176 Vector {
177 _handler: DMA2_STREAM3,
178 },
179 Vector {
180 _handler: DMA2_STREAM4,
181 },
182 Vector { _reserved: 0 },
183 Vector { _reserved: 0 },
184 Vector { _reserved: 0 },
185 Vector { _reserved: 0 },
186 Vector { _reserved: 0 },
187 Vector { _reserved: 0 },
188 Vector { _handler: OTG_FS },
189 Vector {
190 _handler: DMA2_STREAM5,
191 },
192 Vector {
193 _handler: DMA2_STREAM6,
194 },
195 Vector {
196 _handler: DMA2_STREAM7,
197 },
198 Vector { _handler: USART6 },
199 Vector { _handler: I2C3_EV },
200 Vector { _handler: I2C3_ER },
201 Vector { _reserved: 0 },
202 Vector { _reserved: 0 },
203 Vector { _reserved: 0 },
204 Vector { _reserved: 0 },
205 Vector { _reserved: 0 },
206 Vector { _reserved: 0 },
207 Vector { _reserved: 0 },
208 Vector { _handler: FPU },
209 Vector { _reserved: 0 },
210 Vector { _reserved: 0 },
211 Vector { _handler: SPI4 },
212];
213#[doc = r"Enumeration of all the interrupts."]
214#[derive(Copy, Clone, Debug, PartialEq, Eq)]
215#[repr(u16)]
216pub enum Interrupt {
217 #[doc = "1 - PVD through EXTI line detection interrupt"]
218 PVD = 1,
219 #[doc = "2 - Tamper and TimeStamp interrupts through the EXTI line"]
220 TAMP_STAMP = 2,
221 #[doc = "3 - RTC Wakeup interrupt through the EXTI line"]
222 RTC_WKUP = 3,
223 #[doc = "4 - FLASH global interrupt"]
224 FLASH = 4,
225 #[doc = "5 - RCC global interrupt"]
226 RCC = 5,
227 #[doc = "6 - EXTI Line0 interrupt"]
228 EXTI0 = 6,
229 #[doc = "7 - EXTI Line1 interrupt"]
230 EXTI1 = 7,
231 #[doc = "8 - EXTI Line2 interrupt"]
232 EXTI2 = 8,
233 #[doc = "9 - EXTI Line3 interrupt"]
234 EXTI3 = 9,
235 #[doc = "10 - EXTI Line4 interrupt"]
236 EXTI4 = 10,
237 #[doc = "11 - DMA1_STREAM0 global interrupt"]
238 DMA1_STREAM0 = 11,
239 #[doc = "12 - DMA1_STREAM1 global interrupt"]
240 DMA1_STREAM1 = 12,
241 #[doc = "13 - DMA1_STREAM2 global interrupt"]
242 DMA1_STREAM2 = 13,
243 #[doc = "14 - DMA1_STREAM3 global interrupt"]
244 DMA1_STREAM3 = 14,
245 #[doc = "15 - DMA1_STREAM4 global interrupt"]
246 DMA1_STREAM4 = 15,
247 #[doc = "16 - DMA1_STREAM5 global interrupt"]
248 DMA1_STREAM5 = 16,
249 #[doc = "17 - DMA1_STREAM6 global interrupt"]
250 DMA1_STREAM6 = 17,
251 #[doc = "18 - ADC1 global interrupt"]
252 ADC = 18,
253 #[doc = "23 - EXTI Line\\[9:5\\]
254interrupts"]
255 EXTI9_5 = 23,
256 #[doc = "24 - TIM1 Break interrupt and TIM9 global interrupt"]
257 TIM1_BRK_TIM9 = 24,
258 #[doc = "25 - TIM1 Update interrupt and TIM10 global interrupt"]
259 TIM1_UP_TIM10 = 25,
260 #[doc = "26 - TIM1 Trigger and Commutation interrupts and TIM11 global interrupt"]
261 TIM1_TRG_COM_TIM11 = 26,
262 #[doc = "27 - TIM1 Capture Compare interrupt"]
263 TIM1_CC = 27,
264 #[doc = "28 - TIM2 global interrupt"]
265 TIM2 = 28,
266 #[doc = "29 - TIM3 global interrupt"]
267 TIM3 = 29,
268 #[doc = "30 - TIM4 global interrupt"]
269 TIM4 = 30,
270 #[doc = "31 - I2C1 event interrupt"]
271 I2C1_EV = 31,
272 #[doc = "32 - I2C1 error interrupt"]
273 I2C1_ER = 32,
274 #[doc = "33 - I2C2 event interrupt"]
275 I2C2_EV = 33,
276 #[doc = "34 - I2C2 error interrupt"]
277 I2C2_ER = 34,
278 #[doc = "35 - SPI1 global interrupt"]
279 SPI1 = 35,
280 #[doc = "36 - SPI2 global interrupt"]
281 SPI2 = 36,
282 #[doc = "37 - USART1 global interrupt"]
283 USART1 = 37,
284 #[doc = "38 - USART2 global interrupt"]
285 USART2 = 38,
286 #[doc = "40 - EXTI Line\\[15:10\\]
287interrupts"]
288 EXTI15_10 = 40,
289 #[doc = "41 - RTC Alarms (A and B) through EXTI line interrupt"]
290 RTC_ALARM = 41,
291 #[doc = "42 - USB On-The-Go FS Wakeup through EXTI line interrupt"]
292 OTG_FS_WKUP = 42,
293 #[doc = "47 - DMA1_STREAM7 global interrupt"]
294 DMA1_STREAM7 = 47,
295 #[doc = "49 - SDIO global interrupt"]
296 SDIO = 49,
297 #[doc = "50 - TIM5 global interrupt"]
298 TIM5 = 50,
299 #[doc = "51 - SPI3 global interrupt"]
300 SPI3 = 51,
301 #[doc = "56 - DMA2_STREAM0 global interrupt"]
302 DMA2_STREAM0 = 56,
303 #[doc = "57 - DMA2_STREAM1 global interrupt"]
304 DMA2_STREAM1 = 57,
305 #[doc = "58 - DMA2_STREAM2 global interrupt"]
306 DMA2_STREAM2 = 58,
307 #[doc = "59 - DMA2_STREAM3 global interrupt"]
308 DMA2_STREAM3 = 59,
309 #[doc = "60 - DMA2_STREAM4 global interrupt"]
310 DMA2_STREAM4 = 60,
311 #[doc = "67 - USB On The Go FS global interrupt"]
312 OTG_FS = 67,
313 #[doc = "68 - DMA2_STREAM5 global interrupt"]
314 DMA2_STREAM5 = 68,
315 #[doc = "69 - DMA2_STREAM6 global interrupt"]
316 DMA2_STREAM6 = 69,
317 #[doc = "70 - DMA2_STREAM7 global interrupt"]
318 DMA2_STREAM7 = 70,
319 #[doc = "71 - USART6 global interrupt"]
320 USART6 = 71,
321 #[doc = "72 - I2C3 event interrupt"]
322 I2C3_EV = 72,
323 #[doc = "73 - I2C3 error interrupt"]
324 I2C3_ER = 73,
325 #[doc = "81 - Floating point unit interrupt"]
326 FPU = 81,
327 #[doc = "84 - SPI4 global interrupt"]
328 SPI4 = 84,
329}
330unsafe impl cortex_m::interrupt::InterruptNumber for Interrupt {
331 #[inline(always)]
332 fn number(self) -> u16 {
333 self as u16
334 }
335}
336#[doc = "ADC common registers"]
337pub struct ADC_COMMON {
338 _marker: PhantomData<*const ()>,
339}
340unsafe impl Send for ADC_COMMON {}
341impl ADC_COMMON {
342 #[doc = r"Pointer to the register block"]
343 pub const PTR: *const adc_common::RegisterBlock = 0x4001_2300 as *const _;
344 #[doc = r"Return the pointer to the register block"]
345 #[inline(always)]
346 pub const fn ptr() -> *const adc_common::RegisterBlock {
347 Self::PTR
348 }
349}
350impl Deref for ADC_COMMON {
351 type Target = adc_common::RegisterBlock;
352 #[inline(always)]
353 fn deref(&self) -> &Self::Target {
354 unsafe { &*Self::PTR }
355 }
356}
357impl core::fmt::Debug for ADC_COMMON {
358 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
359 f.debug_struct("ADC_COMMON").finish()
360 }
361}
362#[doc = "ADC common registers"]
363pub mod adc_common;
364#[doc = "Analog-to-digital converter"]
365pub struct ADC1 {
366 _marker: PhantomData<*const ()>,
367}
368unsafe impl Send for ADC1 {}
369impl ADC1 {
370 #[doc = r"Pointer to the register block"]
371 pub const PTR: *const adc1::RegisterBlock = 0x4001_2000 as *const _;
372 #[doc = r"Return the pointer to the register block"]
373 #[inline(always)]
374 pub const fn ptr() -> *const adc1::RegisterBlock {
375 Self::PTR
376 }
377}
378impl Deref for ADC1 {
379 type Target = adc1::RegisterBlock;
380 #[inline(always)]
381 fn deref(&self) -> &Self::Target {
382 unsafe { &*Self::PTR }
383 }
384}
385impl core::fmt::Debug for ADC1 {
386 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
387 f.debug_struct("ADC1").finish()
388 }
389}
390#[doc = "Analog-to-digital converter"]
391pub mod adc1;
392#[doc = "Cryptographic processor"]
393pub struct CRC {
394 _marker: PhantomData<*const ()>,
395}
396unsafe impl Send for CRC {}
397impl CRC {
398 #[doc = r"Pointer to the register block"]
399 pub const PTR: *const crc::RegisterBlock = 0x4002_3000 as *const _;
400 #[doc = r"Return the pointer to the register block"]
401 #[inline(always)]
402 pub const fn ptr() -> *const crc::RegisterBlock {
403 Self::PTR
404 }
405}
406impl Deref for CRC {
407 type Target = crc::RegisterBlock;
408 #[inline(always)]
409 fn deref(&self) -> &Self::Target {
410 unsafe { &*Self::PTR }
411 }
412}
413impl core::fmt::Debug for CRC {
414 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
415 f.debug_struct("CRC").finish()
416 }
417}
418#[doc = "Cryptographic processor"]
419pub mod crc;
420#[doc = "Debug support"]
421pub struct DBGMCU {
422 _marker: PhantomData<*const ()>,
423}
424unsafe impl Send for DBGMCU {}
425impl DBGMCU {
426 #[doc = r"Pointer to the register block"]
427 pub const PTR: *const dbgmcu::RegisterBlock = 0xe004_2000 as *const _;
428 #[doc = r"Return the pointer to the register block"]
429 #[inline(always)]
430 pub const fn ptr() -> *const dbgmcu::RegisterBlock {
431 Self::PTR
432 }
433}
434impl Deref for DBGMCU {
435 type Target = dbgmcu::RegisterBlock;
436 #[inline(always)]
437 fn deref(&self) -> &Self::Target {
438 unsafe { &*Self::PTR }
439 }
440}
441impl core::fmt::Debug for DBGMCU {
442 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
443 f.debug_struct("DBGMCU").finish()
444 }
445}
446#[doc = "Debug support"]
447pub mod dbgmcu;
448#[doc = "External interrupt/event controller"]
449pub struct EXTI {
450 _marker: PhantomData<*const ()>,
451}
452unsafe impl Send for EXTI {}
453impl EXTI {
454 #[doc = r"Pointer to the register block"]
455 pub const PTR: *const exti::RegisterBlock = 0x4001_3c00 as *const _;
456 #[doc = r"Return the pointer to the register block"]
457 #[inline(always)]
458 pub const fn ptr() -> *const exti::RegisterBlock {
459 Self::PTR
460 }
461}
462impl Deref for EXTI {
463 type Target = exti::RegisterBlock;
464 #[inline(always)]
465 fn deref(&self) -> &Self::Target {
466 unsafe { &*Self::PTR }
467 }
468}
469impl core::fmt::Debug for EXTI {
470 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
471 f.debug_struct("EXTI").finish()
472 }
473}
474#[doc = "External interrupt/event controller"]
475pub mod exti;
476#[doc = "FLASH"]
477pub struct FLASH {
478 _marker: PhantomData<*const ()>,
479}
480unsafe impl Send for FLASH {}
481impl FLASH {
482 #[doc = r"Pointer to the register block"]
483 pub const PTR: *const flash::RegisterBlock = 0x4002_3c00 as *const _;
484 #[doc = r"Return the pointer to the register block"]
485 #[inline(always)]
486 pub const fn ptr() -> *const flash::RegisterBlock {
487 Self::PTR
488 }
489}
490impl Deref for FLASH {
491 type Target = flash::RegisterBlock;
492 #[inline(always)]
493 fn deref(&self) -> &Self::Target {
494 unsafe { &*Self::PTR }
495 }
496}
497impl core::fmt::Debug for FLASH {
498 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
499 f.debug_struct("FLASH").finish()
500 }
501}
502#[doc = "FLASH"]
503pub mod flash;
504#[doc = "Independent watchdog"]
505pub struct IWDG {
506 _marker: PhantomData<*const ()>,
507}
508unsafe impl Send for IWDG {}
509impl IWDG {
510 #[doc = r"Pointer to the register block"]
511 pub const PTR: *const iwdg::RegisterBlock = 0x4000_3000 as *const _;
512 #[doc = r"Return the pointer to the register block"]
513 #[inline(always)]
514 pub const fn ptr() -> *const iwdg::RegisterBlock {
515 Self::PTR
516 }
517}
518impl Deref for IWDG {
519 type Target = iwdg::RegisterBlock;
520 #[inline(always)]
521 fn deref(&self) -> &Self::Target {
522 unsafe { &*Self::PTR }
523 }
524}
525impl core::fmt::Debug for IWDG {
526 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
527 f.debug_struct("IWDG").finish()
528 }
529}
530#[doc = "Independent watchdog"]
531pub mod iwdg;
532#[doc = "USB on the go full speed"]
533pub struct OTG_FS_DEVICE {
534 _marker: PhantomData<*const ()>,
535}
536unsafe impl Send for OTG_FS_DEVICE {}
537impl OTG_FS_DEVICE {
538 #[doc = r"Pointer to the register block"]
539 pub const PTR: *const otg_fs_device::RegisterBlock = 0x5000_0800 as *const _;
540 #[doc = r"Return the pointer to the register block"]
541 #[inline(always)]
542 pub const fn ptr() -> *const otg_fs_device::RegisterBlock {
543 Self::PTR
544 }
545}
546impl Deref for OTG_FS_DEVICE {
547 type Target = otg_fs_device::RegisterBlock;
548 #[inline(always)]
549 fn deref(&self) -> &Self::Target {
550 unsafe { &*Self::PTR }
551 }
552}
553impl core::fmt::Debug for OTG_FS_DEVICE {
554 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
555 f.debug_struct("OTG_FS_DEVICE").finish()
556 }
557}
558#[doc = "USB on the go full speed"]
559pub mod otg_fs_device;
560#[doc = "USB on the go full speed"]
561pub struct OTG_FS_GLOBAL {
562 _marker: PhantomData<*const ()>,
563}
564unsafe impl Send for OTG_FS_GLOBAL {}
565impl OTG_FS_GLOBAL {
566 #[doc = r"Pointer to the register block"]
567 pub const PTR: *const otg_fs_global::RegisterBlock = 0x5000_0000 as *const _;
568 #[doc = r"Return the pointer to the register block"]
569 #[inline(always)]
570 pub const fn ptr() -> *const otg_fs_global::RegisterBlock {
571 Self::PTR
572 }
573}
574impl Deref for OTG_FS_GLOBAL {
575 type Target = otg_fs_global::RegisterBlock;
576 #[inline(always)]
577 fn deref(&self) -> &Self::Target {
578 unsafe { &*Self::PTR }
579 }
580}
581impl core::fmt::Debug for OTG_FS_GLOBAL {
582 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
583 f.debug_struct("OTG_FS_GLOBAL").finish()
584 }
585}
586#[doc = "USB on the go full speed"]
587pub mod otg_fs_global;
588#[doc = "USB on the go full speed"]
589pub struct OTG_FS_HOST {
590 _marker: PhantomData<*const ()>,
591}
592unsafe impl Send for OTG_FS_HOST {}
593impl OTG_FS_HOST {
594 #[doc = r"Pointer to the register block"]
595 pub const PTR: *const otg_fs_host::RegisterBlock = 0x5000_0400 as *const _;
596 #[doc = r"Return the pointer to the register block"]
597 #[inline(always)]
598 pub const fn ptr() -> *const otg_fs_host::RegisterBlock {
599 Self::PTR
600 }
601}
602impl Deref for OTG_FS_HOST {
603 type Target = otg_fs_host::RegisterBlock;
604 #[inline(always)]
605 fn deref(&self) -> &Self::Target {
606 unsafe { &*Self::PTR }
607 }
608}
609impl core::fmt::Debug for OTG_FS_HOST {
610 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
611 f.debug_struct("OTG_FS_HOST").finish()
612 }
613}
614#[doc = "USB on the go full speed"]
615pub mod otg_fs_host;
616#[doc = "USB on the go full speed"]
617pub struct OTG_FS_PWRCLK {
618 _marker: PhantomData<*const ()>,
619}
620unsafe impl Send for OTG_FS_PWRCLK {}
621impl OTG_FS_PWRCLK {
622 #[doc = r"Pointer to the register block"]
623 pub const PTR: *const otg_fs_pwrclk::RegisterBlock = 0x5000_0e00 as *const _;
624 #[doc = r"Return the pointer to the register block"]
625 #[inline(always)]
626 pub const fn ptr() -> *const otg_fs_pwrclk::RegisterBlock {
627 Self::PTR
628 }
629}
630impl Deref for OTG_FS_PWRCLK {
631 type Target = otg_fs_pwrclk::RegisterBlock;
632 #[inline(always)]
633 fn deref(&self) -> &Self::Target {
634 unsafe { &*Self::PTR }
635 }
636}
637impl core::fmt::Debug for OTG_FS_PWRCLK {
638 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
639 f.debug_struct("OTG_FS_PWRCLK").finish()
640 }
641}
642#[doc = "USB on the go full speed"]
643pub mod otg_fs_pwrclk;
644#[doc = "Power control"]
645pub struct PWR {
646 _marker: PhantomData<*const ()>,
647}
648unsafe impl Send for PWR {}
649impl PWR {
650 #[doc = r"Pointer to the register block"]
651 pub const PTR: *const pwr::RegisterBlock = 0x4000_7000 as *const _;
652 #[doc = r"Return the pointer to the register block"]
653 #[inline(always)]
654 pub const fn ptr() -> *const pwr::RegisterBlock {
655 Self::PTR
656 }
657}
658impl Deref for PWR {
659 type Target = pwr::RegisterBlock;
660 #[inline(always)]
661 fn deref(&self) -> &Self::Target {
662 unsafe { &*Self::PTR }
663 }
664}
665impl core::fmt::Debug for PWR {
666 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
667 f.debug_struct("PWR").finish()
668 }
669}
670#[doc = "Power control"]
671pub mod pwr;
672#[doc = "Reset and clock control"]
673pub struct RCC {
674 _marker: PhantomData<*const ()>,
675}
676unsafe impl Send for RCC {}
677impl RCC {
678 #[doc = r"Pointer to the register block"]
679 pub const PTR: *const rcc::RegisterBlock = 0x4002_3800 as *const _;
680 #[doc = r"Return the pointer to the register block"]
681 #[inline(always)]
682 pub const fn ptr() -> *const rcc::RegisterBlock {
683 Self::PTR
684 }
685}
686impl Deref for RCC {
687 type Target = rcc::RegisterBlock;
688 #[inline(always)]
689 fn deref(&self) -> &Self::Target {
690 unsafe { &*Self::PTR }
691 }
692}
693impl core::fmt::Debug for RCC {
694 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
695 f.debug_struct("RCC").finish()
696 }
697}
698#[doc = "Reset and clock control"]
699pub mod rcc;
700#[doc = "Real-time clock"]
701pub struct RTC {
702 _marker: PhantomData<*const ()>,
703}
704unsafe impl Send for RTC {}
705impl RTC {
706 #[doc = r"Pointer to the register block"]
707 pub const PTR: *const rtc::RegisterBlock = 0x4000_2800 as *const _;
708 #[doc = r"Return the pointer to the register block"]
709 #[inline(always)]
710 pub const fn ptr() -> *const rtc::RegisterBlock {
711 Self::PTR
712 }
713}
714impl Deref for RTC {
715 type Target = rtc::RegisterBlock;
716 #[inline(always)]
717 fn deref(&self) -> &Self::Target {
718 unsafe { &*Self::PTR }
719 }
720}
721impl core::fmt::Debug for RTC {
722 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
723 f.debug_struct("RTC").finish()
724 }
725}
726#[doc = "Real-time clock"]
727pub mod rtc;
728#[doc = "Secure digital input/output interface"]
729pub struct SDIO {
730 _marker: PhantomData<*const ()>,
731}
732unsafe impl Send for SDIO {}
733impl SDIO {
734 #[doc = r"Pointer to the register block"]
735 pub const PTR: *const sdio::RegisterBlock = 0x4001_2c00 as *const _;
736 #[doc = r"Return the pointer to the register block"]
737 #[inline(always)]
738 pub const fn ptr() -> *const sdio::RegisterBlock {
739 Self::PTR
740 }
741}
742impl Deref for SDIO {
743 type Target = sdio::RegisterBlock;
744 #[inline(always)]
745 fn deref(&self) -> &Self::Target {
746 unsafe { &*Self::PTR }
747 }
748}
749impl core::fmt::Debug for SDIO {
750 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
751 f.debug_struct("SDIO").finish()
752 }
753}
754#[doc = "Secure digital input/output interface"]
755pub mod sdio;
756#[doc = "System configuration controller"]
757pub struct SYSCFG {
758 _marker: PhantomData<*const ()>,
759}
760unsafe impl Send for SYSCFG {}
761impl SYSCFG {
762 #[doc = r"Pointer to the register block"]
763 pub const PTR: *const syscfg::RegisterBlock = 0x4001_3800 as *const _;
764 #[doc = r"Return the pointer to the register block"]
765 #[inline(always)]
766 pub const fn ptr() -> *const syscfg::RegisterBlock {
767 Self::PTR
768 }
769}
770impl Deref for SYSCFG {
771 type Target = syscfg::RegisterBlock;
772 #[inline(always)]
773 fn deref(&self) -> &Self::Target {
774 unsafe { &*Self::PTR }
775 }
776}
777impl core::fmt::Debug for SYSCFG {
778 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
779 f.debug_struct("SYSCFG").finish()
780 }
781}
782#[doc = "System configuration controller"]
783pub mod syscfg;
784#[doc = "Advanced-timers"]
785pub struct TIM1 {
786 _marker: PhantomData<*const ()>,
787}
788unsafe impl Send for TIM1 {}
789impl TIM1 {
790 #[doc = r"Pointer to the register block"]
791 pub const PTR: *const tim1::RegisterBlock = 0x4001_0000 as *const _;
792 #[doc = r"Return the pointer to the register block"]
793 #[inline(always)]
794 pub const fn ptr() -> *const tim1::RegisterBlock {
795 Self::PTR
796 }
797}
798impl Deref for TIM1 {
799 type Target = tim1::RegisterBlock;
800 #[inline(always)]
801 fn deref(&self) -> &Self::Target {
802 unsafe { &*Self::PTR }
803 }
804}
805impl core::fmt::Debug for TIM1 {
806 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
807 f.debug_struct("TIM1").finish()
808 }
809}
810#[doc = "Advanced-timers"]
811pub mod tim1;
812#[doc = "General-purpose-timers"]
813pub struct TIM10 {
814 _marker: PhantomData<*const ()>,
815}
816unsafe impl Send for TIM10 {}
817impl TIM10 {
818 #[doc = r"Pointer to the register block"]
819 pub const PTR: *const tim10::RegisterBlock = 0x4001_4400 as *const _;
820 #[doc = r"Return the pointer to the register block"]
821 #[inline(always)]
822 pub const fn ptr() -> *const tim10::RegisterBlock {
823 Self::PTR
824 }
825}
826impl Deref for TIM10 {
827 type Target = tim10::RegisterBlock;
828 #[inline(always)]
829 fn deref(&self) -> &Self::Target {
830 unsafe { &*Self::PTR }
831 }
832}
833impl core::fmt::Debug for TIM10 {
834 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
835 f.debug_struct("TIM10").finish()
836 }
837}
838#[doc = "General-purpose-timers"]
839pub mod tim10;
840#[doc = "General-purpose-timers"]
841pub struct TIM11 {
842 _marker: PhantomData<*const ()>,
843}
844unsafe impl Send for TIM11 {}
845impl TIM11 {
846 #[doc = r"Pointer to the register block"]
847 pub const PTR: *const tim11::RegisterBlock = 0x4001_4800 as *const _;
848 #[doc = r"Return the pointer to the register block"]
849 #[inline(always)]
850 pub const fn ptr() -> *const tim11::RegisterBlock {
851 Self::PTR
852 }
853}
854impl Deref for TIM11 {
855 type Target = tim11::RegisterBlock;
856 #[inline(always)]
857 fn deref(&self) -> &Self::Target {
858 unsafe { &*Self::PTR }
859 }
860}
861impl core::fmt::Debug for TIM11 {
862 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
863 f.debug_struct("TIM11").finish()
864 }
865}
866#[doc = "General-purpose-timers"]
867pub mod tim11;
868#[doc = "General purpose timers"]
869pub struct TIM2 {
870 _marker: PhantomData<*const ()>,
871}
872unsafe impl Send for TIM2 {}
873impl TIM2 {
874 #[doc = r"Pointer to the register block"]
875 pub const PTR: *const tim2::RegisterBlock = 0x4000_0000 as *const _;
876 #[doc = r"Return the pointer to the register block"]
877 #[inline(always)]
878 pub const fn ptr() -> *const tim2::RegisterBlock {
879 Self::PTR
880 }
881}
882impl Deref for TIM2 {
883 type Target = tim2::RegisterBlock;
884 #[inline(always)]
885 fn deref(&self) -> &Self::Target {
886 unsafe { &*Self::PTR }
887 }
888}
889impl core::fmt::Debug for TIM2 {
890 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
891 f.debug_struct("TIM2").finish()
892 }
893}
894#[doc = "General purpose timers"]
895pub mod tim2;
896#[doc = "General purpose timers"]
897pub struct TIM3 {
898 _marker: PhantomData<*const ()>,
899}
900unsafe impl Send for TIM3 {}
901impl TIM3 {
902 #[doc = r"Pointer to the register block"]
903 pub const PTR: *const tim3::RegisterBlock = 0x4000_0400 as *const _;
904 #[doc = r"Return the pointer to the register block"]
905 #[inline(always)]
906 pub const fn ptr() -> *const tim3::RegisterBlock {
907 Self::PTR
908 }
909}
910impl Deref for TIM3 {
911 type Target = tim3::RegisterBlock;
912 #[inline(always)]
913 fn deref(&self) -> &Self::Target {
914 unsafe { &*Self::PTR }
915 }
916}
917impl core::fmt::Debug for TIM3 {
918 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
919 f.debug_struct("TIM3").finish()
920 }
921}
922#[doc = "General purpose timers"]
923pub mod tim3;
924#[doc = "General purpose timers"]
925pub struct TIM4 {
926 _marker: PhantomData<*const ()>,
927}
928unsafe impl Send for TIM4 {}
929impl TIM4 {
930 #[doc = r"Pointer to the register block"]
931 pub const PTR: *const tim3::RegisterBlock = 0x4000_0800 as *const _;
932 #[doc = r"Return the pointer to the register block"]
933 #[inline(always)]
934 pub const fn ptr() -> *const tim3::RegisterBlock {
935 Self::PTR
936 }
937}
938impl Deref for TIM4 {
939 type Target = tim3::RegisterBlock;
940 #[inline(always)]
941 fn deref(&self) -> &Self::Target {
942 unsafe { &*Self::PTR }
943 }
944}
945impl core::fmt::Debug for TIM4 {
946 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
947 f.debug_struct("TIM4").finish()
948 }
949}
950#[doc = "General purpose timers"]
951pub use tim3 as tim4;
952#[doc = "General-purpose-timers"]
953pub struct TIM5 {
954 _marker: PhantomData<*const ()>,
955}
956unsafe impl Send for TIM5 {}
957impl TIM5 {
958 #[doc = r"Pointer to the register block"]
959 pub const PTR: *const tim5::RegisterBlock = 0x4000_0c00 as *const _;
960 #[doc = r"Return the pointer to the register block"]
961 #[inline(always)]
962 pub const fn ptr() -> *const tim5::RegisterBlock {
963 Self::PTR
964 }
965}
966impl Deref for TIM5 {
967 type Target = tim5::RegisterBlock;
968 #[inline(always)]
969 fn deref(&self) -> &Self::Target {
970 unsafe { &*Self::PTR }
971 }
972}
973impl core::fmt::Debug for TIM5 {
974 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
975 f.debug_struct("TIM5").finish()
976 }
977}
978#[doc = "General-purpose-timers"]
979pub mod tim5;
980#[doc = "General purpose timers"]
981pub struct TIM9 {
982 _marker: PhantomData<*const ()>,
983}
984unsafe impl Send for TIM9 {}
985impl TIM9 {
986 #[doc = r"Pointer to the register block"]
987 pub const PTR: *const tim9::RegisterBlock = 0x4001_4000 as *const _;
988 #[doc = r"Return the pointer to the register block"]
989 #[inline(always)]
990 pub const fn ptr() -> *const tim9::RegisterBlock {
991 Self::PTR
992 }
993}
994impl Deref for TIM9 {
995 type Target = tim9::RegisterBlock;
996 #[inline(always)]
997 fn deref(&self) -> &Self::Target {
998 unsafe { &*Self::PTR }
999 }
1000}
1001impl core::fmt::Debug for TIM9 {
1002 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1003 f.debug_struct("TIM9").finish()
1004 }
1005}
1006#[doc = "General purpose timers"]
1007pub mod tim9;
1008#[doc = "Universal synchronous asynchronous receiver transmitter"]
1009pub struct USART1 {
1010 _marker: PhantomData<*const ()>,
1011}
1012unsafe impl Send for USART1 {}
1013impl USART1 {
1014 #[doc = r"Pointer to the register block"]
1015 pub const PTR: *const usart1::RegisterBlock = 0x4001_1000 as *const _;
1016 #[doc = r"Return the pointer to the register block"]
1017 #[inline(always)]
1018 pub const fn ptr() -> *const usart1::RegisterBlock {
1019 Self::PTR
1020 }
1021}
1022impl Deref for USART1 {
1023 type Target = usart1::RegisterBlock;
1024 #[inline(always)]
1025 fn deref(&self) -> &Self::Target {
1026 unsafe { &*Self::PTR }
1027 }
1028}
1029impl core::fmt::Debug for USART1 {
1030 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1031 f.debug_struct("USART1").finish()
1032 }
1033}
1034#[doc = "Universal synchronous asynchronous receiver transmitter"]
1035pub mod usart1;
1036#[doc = "Universal synchronous asynchronous receiver transmitter"]
1037pub struct USART2 {
1038 _marker: PhantomData<*const ()>,
1039}
1040unsafe impl Send for USART2 {}
1041impl USART2 {
1042 #[doc = r"Pointer to the register block"]
1043 pub const PTR: *const usart1::RegisterBlock = 0x4000_4400 as *const _;
1044 #[doc = r"Return the pointer to the register block"]
1045 #[inline(always)]
1046 pub const fn ptr() -> *const usart1::RegisterBlock {
1047 Self::PTR
1048 }
1049}
1050impl Deref for USART2 {
1051 type Target = usart1::RegisterBlock;
1052 #[inline(always)]
1053 fn deref(&self) -> &Self::Target {
1054 unsafe { &*Self::PTR }
1055 }
1056}
1057impl core::fmt::Debug for USART2 {
1058 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1059 f.debug_struct("USART2").finish()
1060 }
1061}
1062#[doc = "Universal synchronous asynchronous receiver transmitter"]
1063pub use usart1 as usart2;
1064#[doc = "Universal synchronous asynchronous receiver transmitter"]
1065pub struct USART6 {
1066 _marker: PhantomData<*const ()>,
1067}
1068unsafe impl Send for USART6 {}
1069impl USART6 {
1070 #[doc = r"Pointer to the register block"]
1071 pub const PTR: *const usart1::RegisterBlock = 0x4001_1400 as *const _;
1072 #[doc = r"Return the pointer to the register block"]
1073 #[inline(always)]
1074 pub const fn ptr() -> *const usart1::RegisterBlock {
1075 Self::PTR
1076 }
1077}
1078impl Deref for USART6 {
1079 type Target = usart1::RegisterBlock;
1080 #[inline(always)]
1081 fn deref(&self) -> &Self::Target {
1082 unsafe { &*Self::PTR }
1083 }
1084}
1085impl core::fmt::Debug for USART6 {
1086 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1087 f.debug_struct("USART6").finish()
1088 }
1089}
1090#[doc = "Universal synchronous asynchronous receiver transmitter"]
1091pub use usart1 as usart6;
1092#[doc = "Window watchdog"]
1093pub struct WWDG {
1094 _marker: PhantomData<*const ()>,
1095}
1096unsafe impl Send for WWDG {}
1097impl WWDG {
1098 #[doc = r"Pointer to the register block"]
1099 pub const PTR: *const wwdg::RegisterBlock = 0x4000_2c00 as *const _;
1100 #[doc = r"Return the pointer to the register block"]
1101 #[inline(always)]
1102 pub const fn ptr() -> *const wwdg::RegisterBlock {
1103 Self::PTR
1104 }
1105}
1106impl Deref for WWDG {
1107 type Target = wwdg::RegisterBlock;
1108 #[inline(always)]
1109 fn deref(&self) -> &Self::Target {
1110 unsafe { &*Self::PTR }
1111 }
1112}
1113impl core::fmt::Debug for WWDG {
1114 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1115 f.debug_struct("WWDG").finish()
1116 }
1117}
1118#[doc = "Window watchdog"]
1119pub mod wwdg;
1120#[doc = "DMA controller"]
1121pub struct DMA2 {
1122 _marker: PhantomData<*const ()>,
1123}
1124unsafe impl Send for DMA2 {}
1125impl DMA2 {
1126 #[doc = r"Pointer to the register block"]
1127 pub const PTR: *const dma2::RegisterBlock = 0x4002_6400 as *const _;
1128 #[doc = r"Return the pointer to the register block"]
1129 #[inline(always)]
1130 pub const fn ptr() -> *const dma2::RegisterBlock {
1131 Self::PTR
1132 }
1133}
1134impl Deref for DMA2 {
1135 type Target = dma2::RegisterBlock;
1136 #[inline(always)]
1137 fn deref(&self) -> &Self::Target {
1138 unsafe { &*Self::PTR }
1139 }
1140}
1141impl core::fmt::Debug for DMA2 {
1142 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1143 f.debug_struct("DMA2").finish()
1144 }
1145}
1146#[doc = "DMA controller"]
1147pub mod dma2;
1148#[doc = "DMA controller"]
1149pub struct DMA1 {
1150 _marker: PhantomData<*const ()>,
1151}
1152unsafe impl Send for DMA1 {}
1153impl DMA1 {
1154 #[doc = r"Pointer to the register block"]
1155 pub const PTR: *const dma2::RegisterBlock = 0x4002_6000 as *const _;
1156 #[doc = r"Return the pointer to the register block"]
1157 #[inline(always)]
1158 pub const fn ptr() -> *const dma2::RegisterBlock {
1159 Self::PTR
1160 }
1161}
1162impl Deref for DMA1 {
1163 type Target = dma2::RegisterBlock;
1164 #[inline(always)]
1165 fn deref(&self) -> &Self::Target {
1166 unsafe { &*Self::PTR }
1167 }
1168}
1169impl core::fmt::Debug for DMA1 {
1170 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1171 f.debug_struct("DMA1").finish()
1172 }
1173}
1174#[doc = "DMA controller"]
1175pub use dma2 as dma1;
1176#[doc = "General-purpose I/Os"]
1177pub struct GPIOH {
1178 _marker: PhantomData<*const ()>,
1179}
1180unsafe impl Send for GPIOH {}
1181impl GPIOH {
1182 #[doc = r"Pointer to the register block"]
1183 pub const PTR: *const gpioh::RegisterBlock = 0x4002_1c00 as *const _;
1184 #[doc = r"Return the pointer to the register block"]
1185 #[inline(always)]
1186 pub const fn ptr() -> *const gpioh::RegisterBlock {
1187 Self::PTR
1188 }
1189}
1190impl Deref for GPIOH {
1191 type Target = gpioh::RegisterBlock;
1192 #[inline(always)]
1193 fn deref(&self) -> &Self::Target {
1194 unsafe { &*Self::PTR }
1195 }
1196}
1197impl core::fmt::Debug for GPIOH {
1198 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1199 f.debug_struct("GPIOH").finish()
1200 }
1201}
1202#[doc = "General-purpose I/Os"]
1203pub mod gpioh;
1204#[doc = "General-purpose I/Os"]
1205pub struct GPIOE {
1206 _marker: PhantomData<*const ()>,
1207}
1208unsafe impl Send for GPIOE {}
1209impl GPIOE {
1210 #[doc = r"Pointer to the register block"]
1211 pub const PTR: *const gpioh::RegisterBlock = 0x4002_1000 as *const _;
1212 #[doc = r"Return the pointer to the register block"]
1213 #[inline(always)]
1214 pub const fn ptr() -> *const gpioh::RegisterBlock {
1215 Self::PTR
1216 }
1217}
1218impl Deref for GPIOE {
1219 type Target = gpioh::RegisterBlock;
1220 #[inline(always)]
1221 fn deref(&self) -> &Self::Target {
1222 unsafe { &*Self::PTR }
1223 }
1224}
1225impl core::fmt::Debug for GPIOE {
1226 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1227 f.debug_struct("GPIOE").finish()
1228 }
1229}
1230#[doc = "General-purpose I/Os"]
1231pub use gpioh as gpioe;
1232#[doc = "General-purpose I/Os"]
1233pub struct GPIOD {
1234 _marker: PhantomData<*const ()>,
1235}
1236unsafe impl Send for GPIOD {}
1237impl GPIOD {
1238 #[doc = r"Pointer to the register block"]
1239 pub const PTR: *const gpioh::RegisterBlock = 0x4002_0c00 as *const _;
1240 #[doc = r"Return the pointer to the register block"]
1241 #[inline(always)]
1242 pub const fn ptr() -> *const gpioh::RegisterBlock {
1243 Self::PTR
1244 }
1245}
1246impl Deref for GPIOD {
1247 type Target = gpioh::RegisterBlock;
1248 #[inline(always)]
1249 fn deref(&self) -> &Self::Target {
1250 unsafe { &*Self::PTR }
1251 }
1252}
1253impl core::fmt::Debug for GPIOD {
1254 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1255 f.debug_struct("GPIOD").finish()
1256 }
1257}
1258#[doc = "General-purpose I/Os"]
1259pub use gpioh as gpiod;
1260#[doc = "General-purpose I/Os"]
1261pub struct GPIOC {
1262 _marker: PhantomData<*const ()>,
1263}
1264unsafe impl Send for GPIOC {}
1265impl GPIOC {
1266 #[doc = r"Pointer to the register block"]
1267 pub const PTR: *const gpioh::RegisterBlock = 0x4002_0800 as *const _;
1268 #[doc = r"Return the pointer to the register block"]
1269 #[inline(always)]
1270 pub const fn ptr() -> *const gpioh::RegisterBlock {
1271 Self::PTR
1272 }
1273}
1274impl Deref for GPIOC {
1275 type Target = gpioh::RegisterBlock;
1276 #[inline(always)]
1277 fn deref(&self) -> &Self::Target {
1278 unsafe { &*Self::PTR }
1279 }
1280}
1281impl core::fmt::Debug for GPIOC {
1282 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1283 f.debug_struct("GPIOC").finish()
1284 }
1285}
1286#[doc = "General-purpose I/Os"]
1287pub use gpioh as gpioc;
1288#[doc = "General-purpose I/Os"]
1289pub struct GPIOB {
1290 _marker: PhantomData<*const ()>,
1291}
1292unsafe impl Send for GPIOB {}
1293impl GPIOB {
1294 #[doc = r"Pointer to the register block"]
1295 pub const PTR: *const gpiob::RegisterBlock = 0x4002_0400 as *const _;
1296 #[doc = r"Return the pointer to the register block"]
1297 #[inline(always)]
1298 pub const fn ptr() -> *const gpiob::RegisterBlock {
1299 Self::PTR
1300 }
1301}
1302impl Deref for GPIOB {
1303 type Target = gpiob::RegisterBlock;
1304 #[inline(always)]
1305 fn deref(&self) -> &Self::Target {
1306 unsafe { &*Self::PTR }
1307 }
1308}
1309impl core::fmt::Debug for GPIOB {
1310 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1311 f.debug_struct("GPIOB").finish()
1312 }
1313}
1314#[doc = "General-purpose I/Os"]
1315pub mod gpiob;
1316#[doc = "General-purpose I/Os"]
1317pub struct GPIOA {
1318 _marker: PhantomData<*const ()>,
1319}
1320unsafe impl Send for GPIOA {}
1321impl GPIOA {
1322 #[doc = r"Pointer to the register block"]
1323 pub const PTR: *const gpioa::RegisterBlock = 0x4002_0000 as *const _;
1324 #[doc = r"Return the pointer to the register block"]
1325 #[inline(always)]
1326 pub const fn ptr() -> *const gpioa::RegisterBlock {
1327 Self::PTR
1328 }
1329}
1330impl Deref for GPIOA {
1331 type Target = gpioa::RegisterBlock;
1332 #[inline(always)]
1333 fn deref(&self) -> &Self::Target {
1334 unsafe { &*Self::PTR }
1335 }
1336}
1337impl core::fmt::Debug for GPIOA {
1338 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1339 f.debug_struct("GPIOA").finish()
1340 }
1341}
1342#[doc = "General-purpose I/Os"]
1343pub mod gpioa;
1344#[doc = "Inter-integrated circuit"]
1345pub struct I2C3 {
1346 _marker: PhantomData<*const ()>,
1347}
1348unsafe impl Send for I2C3 {}
1349impl I2C3 {
1350 #[doc = r"Pointer to the register block"]
1351 pub const PTR: *const i2c1::RegisterBlock = 0x4000_5c00 as *const _;
1352 #[doc = r"Return the pointer to the register block"]
1353 #[inline(always)]
1354 pub const fn ptr() -> *const i2c1::RegisterBlock {
1355 Self::PTR
1356 }
1357}
1358impl Deref for I2C3 {
1359 type Target = i2c1::RegisterBlock;
1360 #[inline(always)]
1361 fn deref(&self) -> &Self::Target {
1362 unsafe { &*Self::PTR }
1363 }
1364}
1365impl core::fmt::Debug for I2C3 {
1366 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1367 f.debug_struct("I2C3").finish()
1368 }
1369}
1370#[doc = "Inter-integrated circuit"]
1371pub use i2c1 as i2c3;
1372#[doc = "Inter-integrated circuit"]
1373pub struct I2C2 {
1374 _marker: PhantomData<*const ()>,
1375}
1376unsafe impl Send for I2C2 {}
1377impl I2C2 {
1378 #[doc = r"Pointer to the register block"]
1379 pub const PTR: *const i2c1::RegisterBlock = 0x4000_5800 as *const _;
1380 #[doc = r"Return the pointer to the register block"]
1381 #[inline(always)]
1382 pub const fn ptr() -> *const i2c1::RegisterBlock {
1383 Self::PTR
1384 }
1385}
1386impl Deref for I2C2 {
1387 type Target = i2c1::RegisterBlock;
1388 #[inline(always)]
1389 fn deref(&self) -> &Self::Target {
1390 unsafe { &*Self::PTR }
1391 }
1392}
1393impl core::fmt::Debug for I2C2 {
1394 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1395 f.debug_struct("I2C2").finish()
1396 }
1397}
1398#[doc = "Inter-integrated circuit"]
1399pub use i2c1 as i2c2;
1400#[doc = "Inter-integrated circuit"]
1401pub struct I2C1 {
1402 _marker: PhantomData<*const ()>,
1403}
1404unsafe impl Send for I2C1 {}
1405impl I2C1 {
1406 #[doc = r"Pointer to the register block"]
1407 pub const PTR: *const i2c1::RegisterBlock = 0x4000_5400 as *const _;
1408 #[doc = r"Return the pointer to the register block"]
1409 #[inline(always)]
1410 pub const fn ptr() -> *const i2c1::RegisterBlock {
1411 Self::PTR
1412 }
1413}
1414impl Deref for I2C1 {
1415 type Target = i2c1::RegisterBlock;
1416 #[inline(always)]
1417 fn deref(&self) -> &Self::Target {
1418 unsafe { &*Self::PTR }
1419 }
1420}
1421impl core::fmt::Debug for I2C1 {
1422 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1423 f.debug_struct("I2C1").finish()
1424 }
1425}
1426#[doc = "Inter-integrated circuit"]
1427pub mod i2c1;
1428#[doc = "Serial peripheral interface"]
1429pub struct I2S2EXT {
1430 _marker: PhantomData<*const ()>,
1431}
1432unsafe impl Send for I2S2EXT {}
1433impl I2S2EXT {
1434 #[doc = r"Pointer to the register block"]
1435 pub const PTR: *const spi1::RegisterBlock = 0x4000_3400 as *const _;
1436 #[doc = r"Return the pointer to the register block"]
1437 #[inline(always)]
1438 pub const fn ptr() -> *const spi1::RegisterBlock {
1439 Self::PTR
1440 }
1441}
1442impl Deref for I2S2EXT {
1443 type Target = spi1::RegisterBlock;
1444 #[inline(always)]
1445 fn deref(&self) -> &Self::Target {
1446 unsafe { &*Self::PTR }
1447 }
1448}
1449impl core::fmt::Debug for I2S2EXT {
1450 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1451 f.debug_struct("I2S2EXT").finish()
1452 }
1453}
1454#[doc = "Serial peripheral interface"]
1455pub use spi1 as i2s2ext;
1456#[doc = "Serial peripheral interface"]
1457pub struct I2S3EXT {
1458 _marker: PhantomData<*const ()>,
1459}
1460unsafe impl Send for I2S3EXT {}
1461impl I2S3EXT {
1462 #[doc = r"Pointer to the register block"]
1463 pub const PTR: *const spi1::RegisterBlock = 0x4000_4000 as *const _;
1464 #[doc = r"Return the pointer to the register block"]
1465 #[inline(always)]
1466 pub const fn ptr() -> *const spi1::RegisterBlock {
1467 Self::PTR
1468 }
1469}
1470impl Deref for I2S3EXT {
1471 type Target = spi1::RegisterBlock;
1472 #[inline(always)]
1473 fn deref(&self) -> &Self::Target {
1474 unsafe { &*Self::PTR }
1475 }
1476}
1477impl core::fmt::Debug for I2S3EXT {
1478 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1479 f.debug_struct("I2S3EXT").finish()
1480 }
1481}
1482#[doc = "Serial peripheral interface"]
1483pub use spi1 as i2s3ext;
1484#[doc = "Serial peripheral interface"]
1485pub struct SPI1 {
1486 _marker: PhantomData<*const ()>,
1487}
1488unsafe impl Send for SPI1 {}
1489impl SPI1 {
1490 #[doc = r"Pointer to the register block"]
1491 pub const PTR: *const spi1::RegisterBlock = 0x4001_3000 as *const _;
1492 #[doc = r"Return the pointer to the register block"]
1493 #[inline(always)]
1494 pub const fn ptr() -> *const spi1::RegisterBlock {
1495 Self::PTR
1496 }
1497}
1498impl Deref for SPI1 {
1499 type Target = spi1::RegisterBlock;
1500 #[inline(always)]
1501 fn deref(&self) -> &Self::Target {
1502 unsafe { &*Self::PTR }
1503 }
1504}
1505impl core::fmt::Debug for SPI1 {
1506 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1507 f.debug_struct("SPI1").finish()
1508 }
1509}
1510#[doc = "Serial peripheral interface"]
1511pub mod spi1;
1512#[doc = "Serial peripheral interface"]
1513pub struct SPI2 {
1514 _marker: PhantomData<*const ()>,
1515}
1516unsafe impl Send for SPI2 {}
1517impl SPI2 {
1518 #[doc = r"Pointer to the register block"]
1519 pub const PTR: *const spi1::RegisterBlock = 0x4000_3800 as *const _;
1520 #[doc = r"Return the pointer to the register block"]
1521 #[inline(always)]
1522 pub const fn ptr() -> *const spi1::RegisterBlock {
1523 Self::PTR
1524 }
1525}
1526impl Deref for SPI2 {
1527 type Target = spi1::RegisterBlock;
1528 #[inline(always)]
1529 fn deref(&self) -> &Self::Target {
1530 unsafe { &*Self::PTR }
1531 }
1532}
1533impl core::fmt::Debug for SPI2 {
1534 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1535 f.debug_struct("SPI2").finish()
1536 }
1537}
1538#[doc = "Serial peripheral interface"]
1539pub use spi1 as spi2;
1540#[doc = "Serial peripheral interface"]
1541pub struct SPI3 {
1542 _marker: PhantomData<*const ()>,
1543}
1544unsafe impl Send for SPI3 {}
1545impl SPI3 {
1546 #[doc = r"Pointer to the register block"]
1547 pub const PTR: *const spi1::RegisterBlock = 0x4000_3c00 as *const _;
1548 #[doc = r"Return the pointer to the register block"]
1549 #[inline(always)]
1550 pub const fn ptr() -> *const spi1::RegisterBlock {
1551 Self::PTR
1552 }
1553}
1554impl Deref for SPI3 {
1555 type Target = spi1::RegisterBlock;
1556 #[inline(always)]
1557 fn deref(&self) -> &Self::Target {
1558 unsafe { &*Self::PTR }
1559 }
1560}
1561impl core::fmt::Debug for SPI3 {
1562 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1563 f.debug_struct("SPI3").finish()
1564 }
1565}
1566#[doc = "Serial peripheral interface"]
1567pub use spi1 as spi3;
1568#[doc = "Serial peripheral interface"]
1569pub struct SPI4 {
1570 _marker: PhantomData<*const ()>,
1571}
1572unsafe impl Send for SPI4 {}
1573impl SPI4 {
1574 #[doc = r"Pointer to the register block"]
1575 pub const PTR: *const spi1::RegisterBlock = 0x4001_3400 as *const _;
1576 #[doc = r"Return the pointer to the register block"]
1577 #[inline(always)]
1578 pub const fn ptr() -> *const spi1::RegisterBlock {
1579 Self::PTR
1580 }
1581}
1582impl Deref for SPI4 {
1583 type Target = spi1::RegisterBlock;
1584 #[inline(always)]
1585 fn deref(&self) -> &Self::Target {
1586 unsafe { &*Self::PTR }
1587 }
1588}
1589impl core::fmt::Debug for SPI4 {
1590 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1591 f.debug_struct("SPI4").finish()
1592 }
1593}
1594#[doc = "Serial peripheral interface"]
1595pub use spi1 as spi4;
1596#[doc = "Floting point unit"]
1597pub struct FPU {
1598 _marker: PhantomData<*const ()>,
1599}
1600unsafe impl Send for FPU {}
1601impl FPU {
1602 #[doc = r"Pointer to the register block"]
1603 pub const PTR: *const fpu::RegisterBlock = 0xe000_ef34 as *const _;
1604 #[doc = r"Return the pointer to the register block"]
1605 #[inline(always)]
1606 pub const fn ptr() -> *const fpu::RegisterBlock {
1607 Self::PTR
1608 }
1609}
1610impl Deref for FPU {
1611 type Target = fpu::RegisterBlock;
1612 #[inline(always)]
1613 fn deref(&self) -> &Self::Target {
1614 unsafe { &*Self::PTR }
1615 }
1616}
1617impl core::fmt::Debug for FPU {
1618 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1619 f.debug_struct("FPU").finish()
1620 }
1621}
1622#[doc = "Floting point unit"]
1623pub mod fpu;
1624#[doc = "SysTick timer"]
1625pub struct STK {
1626 _marker: PhantomData<*const ()>,
1627}
1628unsafe impl Send for STK {}
1629impl STK {
1630 #[doc = r"Pointer to the register block"]
1631 pub const PTR: *const stk::RegisterBlock = 0xe000_e010 as *const _;
1632 #[doc = r"Return the pointer to the register block"]
1633 #[inline(always)]
1634 pub const fn ptr() -> *const stk::RegisterBlock {
1635 Self::PTR
1636 }
1637}
1638impl Deref for STK {
1639 type Target = stk::RegisterBlock;
1640 #[inline(always)]
1641 fn deref(&self) -> &Self::Target {
1642 unsafe { &*Self::PTR }
1643 }
1644}
1645impl core::fmt::Debug for STK {
1646 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1647 f.debug_struct("STK").finish()
1648 }
1649}
1650#[doc = "SysTick timer"]
1651pub mod stk;
1652#[doc = "Nested vectored interrupt controller"]
1653pub struct NVIC_STIR {
1654 _marker: PhantomData<*const ()>,
1655}
1656unsafe impl Send for NVIC_STIR {}
1657impl NVIC_STIR {
1658 #[doc = r"Pointer to the register block"]
1659 pub const PTR: *const nvic_stir::RegisterBlock = 0xe000_ef00 as *const _;
1660 #[doc = r"Return the pointer to the register block"]
1661 #[inline(always)]
1662 pub const fn ptr() -> *const nvic_stir::RegisterBlock {
1663 Self::PTR
1664 }
1665}
1666impl Deref for NVIC_STIR {
1667 type Target = nvic_stir::RegisterBlock;
1668 #[inline(always)]
1669 fn deref(&self) -> &Self::Target {
1670 unsafe { &*Self::PTR }
1671 }
1672}
1673impl core::fmt::Debug for NVIC_STIR {
1674 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1675 f.debug_struct("NVIC_STIR").finish()
1676 }
1677}
1678#[doc = "Nested vectored interrupt controller"]
1679pub mod nvic_stir;
1680#[doc = "Floating point unit CPACR"]
1681pub struct FPU_CPACR {
1682 _marker: PhantomData<*const ()>,
1683}
1684unsafe impl Send for FPU_CPACR {}
1685impl FPU_CPACR {
1686 #[doc = r"Pointer to the register block"]
1687 pub const PTR: *const fpu_cpacr::RegisterBlock = 0xe000_ed88 as *const _;
1688 #[doc = r"Return the pointer to the register block"]
1689 #[inline(always)]
1690 pub const fn ptr() -> *const fpu_cpacr::RegisterBlock {
1691 Self::PTR
1692 }
1693}
1694impl Deref for FPU_CPACR {
1695 type Target = fpu_cpacr::RegisterBlock;
1696 #[inline(always)]
1697 fn deref(&self) -> &Self::Target {
1698 unsafe { &*Self::PTR }
1699 }
1700}
1701impl core::fmt::Debug for FPU_CPACR {
1702 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1703 f.debug_struct("FPU_CPACR").finish()
1704 }
1705}
1706#[doc = "Floating point unit CPACR"]
1707pub mod fpu_cpacr;
1708#[doc = "System control block ACTLR"]
1709pub struct SCB_ACTRL {
1710 _marker: PhantomData<*const ()>,
1711}
1712unsafe impl Send for SCB_ACTRL {}
1713impl SCB_ACTRL {
1714 #[doc = r"Pointer to the register block"]
1715 pub const PTR: *const scb_actrl::RegisterBlock = 0xe000_e008 as *const _;
1716 #[doc = r"Return the pointer to the register block"]
1717 #[inline(always)]
1718 pub const fn ptr() -> *const scb_actrl::RegisterBlock {
1719 Self::PTR
1720 }
1721}
1722impl Deref for SCB_ACTRL {
1723 type Target = scb_actrl::RegisterBlock;
1724 #[inline(always)]
1725 fn deref(&self) -> &Self::Target {
1726 unsafe { &*Self::PTR }
1727 }
1728}
1729impl core::fmt::Debug for SCB_ACTRL {
1730 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1731 f.debug_struct("SCB_ACTRL").finish()
1732 }
1733}
1734#[doc = "System control block ACTLR"]
1735pub mod scb_actrl;
1736#[no_mangle]
1737static mut DEVICE_PERIPHERALS: bool = false;
1738#[doc = r"All the peripherals"]
1739#[allow(non_snake_case)]
1740pub struct Peripherals {
1741 #[doc = "ADC_COMMON"]
1742 pub ADC_COMMON: ADC_COMMON,
1743 #[doc = "ADC1"]
1744 pub ADC1: ADC1,
1745 #[doc = "CRC"]
1746 pub CRC: CRC,
1747 #[doc = "DBGMCU"]
1748 pub DBGMCU: DBGMCU,
1749 #[doc = "EXTI"]
1750 pub EXTI: EXTI,
1751 #[doc = "FLASH"]
1752 pub FLASH: FLASH,
1753 #[doc = "IWDG"]
1754 pub IWDG: IWDG,
1755 #[doc = "OTG_FS_DEVICE"]
1756 pub OTG_FS_DEVICE: OTG_FS_DEVICE,
1757 #[doc = "OTG_FS_GLOBAL"]
1758 pub OTG_FS_GLOBAL: OTG_FS_GLOBAL,
1759 #[doc = "OTG_FS_HOST"]
1760 pub OTG_FS_HOST: OTG_FS_HOST,
1761 #[doc = "OTG_FS_PWRCLK"]
1762 pub OTG_FS_PWRCLK: OTG_FS_PWRCLK,
1763 #[doc = "PWR"]
1764 pub PWR: PWR,
1765 #[doc = "RCC"]
1766 pub RCC: RCC,
1767 #[doc = "RTC"]
1768 pub RTC: RTC,
1769 #[doc = "SDIO"]
1770 pub SDIO: SDIO,
1771 #[doc = "SYSCFG"]
1772 pub SYSCFG: SYSCFG,
1773 #[doc = "TIM1"]
1774 pub TIM1: TIM1,
1775 #[doc = "TIM10"]
1776 pub TIM10: TIM10,
1777 #[doc = "TIM11"]
1778 pub TIM11: TIM11,
1779 #[doc = "TIM2"]
1780 pub TIM2: TIM2,
1781 #[doc = "TIM3"]
1782 pub TIM3: TIM3,
1783 #[doc = "TIM4"]
1784 pub TIM4: TIM4,
1785 #[doc = "TIM5"]
1786 pub TIM5: TIM5,
1787 #[doc = "TIM9"]
1788 pub TIM9: TIM9,
1789 #[doc = "USART1"]
1790 pub USART1: USART1,
1791 #[doc = "USART2"]
1792 pub USART2: USART2,
1793 #[doc = "USART6"]
1794 pub USART6: USART6,
1795 #[doc = "WWDG"]
1796 pub WWDG: WWDG,
1797 #[doc = "DMA2"]
1798 pub DMA2: DMA2,
1799 #[doc = "DMA1"]
1800 pub DMA1: DMA1,
1801 #[doc = "GPIOH"]
1802 pub GPIOH: GPIOH,
1803 #[doc = "GPIOE"]
1804 pub GPIOE: GPIOE,
1805 #[doc = "GPIOD"]
1806 pub GPIOD: GPIOD,
1807 #[doc = "GPIOC"]
1808 pub GPIOC: GPIOC,
1809 #[doc = "GPIOB"]
1810 pub GPIOB: GPIOB,
1811 #[doc = "GPIOA"]
1812 pub GPIOA: GPIOA,
1813 #[doc = "I2C3"]
1814 pub I2C3: I2C3,
1815 #[doc = "I2C2"]
1816 pub I2C2: I2C2,
1817 #[doc = "I2C1"]
1818 pub I2C1: I2C1,
1819 #[doc = "I2S2EXT"]
1820 pub I2S2EXT: I2S2EXT,
1821 #[doc = "I2S3EXT"]
1822 pub I2S3EXT: I2S3EXT,
1823 #[doc = "SPI1"]
1824 pub SPI1: SPI1,
1825 #[doc = "SPI2"]
1826 pub SPI2: SPI2,
1827 #[doc = "SPI3"]
1828 pub SPI3: SPI3,
1829 #[doc = "SPI4"]
1830 pub SPI4: SPI4,
1831 #[doc = "FPU"]
1832 pub FPU: FPU,
1833 #[doc = "STK"]
1834 pub STK: STK,
1835 #[doc = "NVIC_STIR"]
1836 pub NVIC_STIR: NVIC_STIR,
1837 #[doc = "FPU_CPACR"]
1838 pub FPU_CPACR: FPU_CPACR,
1839 #[doc = "SCB_ACTRL"]
1840 pub SCB_ACTRL: SCB_ACTRL,
1841}
1842impl Peripherals {
1843 #[doc = r"Returns all the peripherals *once*"]
1844 #[inline]
1845 pub fn take() -> Option<Self> {
1846 cortex_m::interrupt::free(|_| {
1847 if unsafe { DEVICE_PERIPHERALS } {
1848 None
1849 } else {
1850 Some(unsafe { Peripherals::steal() })
1851 }
1852 })
1853 }
1854 #[doc = r"Unchecked version of `Peripherals::take`"]
1855 #[inline]
1856 pub unsafe fn steal() -> Self {
1857 DEVICE_PERIPHERALS = true;
1858 Peripherals {
1859 ADC_COMMON: ADC_COMMON {
1860 _marker: PhantomData,
1861 },
1862 ADC1: ADC1 {
1863 _marker: PhantomData,
1864 },
1865 CRC: CRC {
1866 _marker: PhantomData,
1867 },
1868 DBGMCU: DBGMCU {
1869 _marker: PhantomData,
1870 },
1871 EXTI: EXTI {
1872 _marker: PhantomData,
1873 },
1874 FLASH: FLASH {
1875 _marker: PhantomData,
1876 },
1877 IWDG: IWDG {
1878 _marker: PhantomData,
1879 },
1880 OTG_FS_DEVICE: OTG_FS_DEVICE {
1881 _marker: PhantomData,
1882 },
1883 OTG_FS_GLOBAL: OTG_FS_GLOBAL {
1884 _marker: PhantomData,
1885 },
1886 OTG_FS_HOST: OTG_FS_HOST {
1887 _marker: PhantomData,
1888 },
1889 OTG_FS_PWRCLK: OTG_FS_PWRCLK {
1890 _marker: PhantomData,
1891 },
1892 PWR: PWR {
1893 _marker: PhantomData,
1894 },
1895 RCC: RCC {
1896 _marker: PhantomData,
1897 },
1898 RTC: RTC {
1899 _marker: PhantomData,
1900 },
1901 SDIO: SDIO {
1902 _marker: PhantomData,
1903 },
1904 SYSCFG: SYSCFG {
1905 _marker: PhantomData,
1906 },
1907 TIM1: TIM1 {
1908 _marker: PhantomData,
1909 },
1910 TIM10: TIM10 {
1911 _marker: PhantomData,
1912 },
1913 TIM11: TIM11 {
1914 _marker: PhantomData,
1915 },
1916 TIM2: TIM2 {
1917 _marker: PhantomData,
1918 },
1919 TIM3: TIM3 {
1920 _marker: PhantomData,
1921 },
1922 TIM4: TIM4 {
1923 _marker: PhantomData,
1924 },
1925 TIM5: TIM5 {
1926 _marker: PhantomData,
1927 },
1928 TIM9: TIM9 {
1929 _marker: PhantomData,
1930 },
1931 USART1: USART1 {
1932 _marker: PhantomData,
1933 },
1934 USART2: USART2 {
1935 _marker: PhantomData,
1936 },
1937 USART6: USART6 {
1938 _marker: PhantomData,
1939 },
1940 WWDG: WWDG {
1941 _marker: PhantomData,
1942 },
1943 DMA2: DMA2 {
1944 _marker: PhantomData,
1945 },
1946 DMA1: DMA1 {
1947 _marker: PhantomData,
1948 },
1949 GPIOH: GPIOH {
1950 _marker: PhantomData,
1951 },
1952 GPIOE: GPIOE {
1953 _marker: PhantomData,
1954 },
1955 GPIOD: GPIOD {
1956 _marker: PhantomData,
1957 },
1958 GPIOC: GPIOC {
1959 _marker: PhantomData,
1960 },
1961 GPIOB: GPIOB {
1962 _marker: PhantomData,
1963 },
1964 GPIOA: GPIOA {
1965 _marker: PhantomData,
1966 },
1967 I2C3: I2C3 {
1968 _marker: PhantomData,
1969 },
1970 I2C2: I2C2 {
1971 _marker: PhantomData,
1972 },
1973 I2C1: I2C1 {
1974 _marker: PhantomData,
1975 },
1976 I2S2EXT: I2S2EXT {
1977 _marker: PhantomData,
1978 },
1979 I2S3EXT: I2S3EXT {
1980 _marker: PhantomData,
1981 },
1982 SPI1: SPI1 {
1983 _marker: PhantomData,
1984 },
1985 SPI2: SPI2 {
1986 _marker: PhantomData,
1987 },
1988 SPI3: SPI3 {
1989 _marker: PhantomData,
1990 },
1991 SPI4: SPI4 {
1992 _marker: PhantomData,
1993 },
1994 FPU: FPU {
1995 _marker: PhantomData,
1996 },
1997 STK: STK {
1998 _marker: PhantomData,
1999 },
2000 NVIC_STIR: NVIC_STIR {
2001 _marker: PhantomData,
2002 },
2003 FPU_CPACR: FPU_CPACR {
2004 _marker: PhantomData,
2005 },
2006 SCB_ACTRL: SCB_ACTRL {
2007 _marker: PhantomData,
2008 },
2009 }
2010 }
2011}