#![doc = "Peripheral access API for GD32VF103 microcontrollers (generated using svd2rust v0.17.0)\n\nYou can find an overview of the API [here].\n\n[here]: https://docs.rs/svd2rust/0.17.0/svd2rust/#peripheral-api"]
#![deny(const_err)]
#![deny(dead_code)]
#![deny(improper_ctypes)]
#![deny(legacy_directory_ownership)]
#![deny(missing_docs)]
#![deny(no_mangle_generic_items)]
#![deny(non_shorthand_field_patterns)]
#![deny(overflowing_literals)]
#![deny(path_statements)]
#![deny(patterns_in_fns_without_body)]
#![deny(plugin_as_library)]
#![deny(private_in_public)]
#![deny(safe_extern_statics)]
#![deny(unconditional_recursion)]
#![deny(unions_with_drop_fields)]
#![deny(unused_allocation)]
#![deny(unused_comparisons)]
#![deny(unused_parens)]
#![deny(while_true)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![no_std]
extern crate bare_metal;
extern crate riscv;
extern crate vcell;
use core::marker::PhantomData;
use core::ops::Deref;
#[doc = r"Number available in the NVIC for configuring priority"]
pub const NVIC_PRIO_BITS: u8 = 4;
#[doc(hidden)]
pub mod interrupt;
pub use self::interrupt::Interrupt;
#[allow(unused_imports)]
use generic::*;
#[doc = r"Common register and bit access and modify traits"]
pub mod generic;
#[doc = "Analog to digital converter"]
pub struct ADC0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for ADC0 {}
impl ADC0 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const adc0::RegisterBlock {
0x4001_2400 as *const _
}
}
impl Deref for ADC0 {
type Target = adc0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*ADC0::ptr() }
}
}
#[doc = "Analog to digital converter"]
pub mod adc0;
#[doc = "Analog to digital converter"]
pub struct ADC1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for ADC1 {}
impl ADC1 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const adc1::RegisterBlock {
0x4001_2800 as *const _
}
}
impl Deref for ADC1 {
type Target = adc1::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*ADC1::ptr() }
}
}
#[doc = "Analog to digital converter"]
pub mod adc1;
#[doc = "Alternate-function I/Os"]
pub struct AFIO {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for AFIO {}
impl AFIO {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const afio::RegisterBlock {
0x4001_0000 as *const _
}
}
impl Deref for AFIO {
type Target = afio::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*AFIO::ptr() }
}
}
#[doc = "Alternate-function I/Os"]
pub mod afio;
#[doc = "Backup registers"]
pub struct BKP {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for BKP {}
impl BKP {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const bkp::RegisterBlock {
0x4000_6c00 as *const _
}
}
impl Deref for BKP {
type Target = bkp::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*BKP::ptr() }
}
}
#[doc = "Backup registers"]
pub mod bkp;
#[doc = "Controller area network"]
pub struct CAN0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for CAN0 {}
impl CAN0 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const can0::RegisterBlock {
0x4000_6400 as *const _
}
}
impl Deref for CAN0 {
type Target = can0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*CAN0::ptr() }
}
}
#[doc = "Controller area network"]
pub mod can0;
#[doc = "Controller area network"]
pub struct CAN1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for CAN1 {}
impl CAN1 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const can0::RegisterBlock {
0x4000_6800 as *const _
}
}
impl Deref for CAN1 {
type Target = can0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*CAN1::ptr() }
}
}
#[doc = "cyclic redundancy check calculation unit"]
pub struct CRC {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for CRC {}
impl CRC {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const crc::RegisterBlock {
0x4002_3000 as *const _
}
}
impl Deref for CRC {
type Target = crc::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*CRC::ptr() }
}
}
#[doc = "cyclic redundancy check calculation unit"]
pub mod crc;
#[doc = "Digital-to-analog converter"]
pub struct DAC {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for DAC {}
impl DAC {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const dac::RegisterBlock {
0x4000_7400 as *const _
}
}
impl Deref for DAC {
type Target = dac::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*DAC::ptr() }
}
}
#[doc = "Digital-to-analog converter"]
pub mod dac;
#[doc = "Debug support"]
pub struct DBG {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for DBG {}
impl DBG {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const dbg::RegisterBlock {
0xe004_2000 as *const _
}
}
impl Deref for DBG {
type Target = dbg::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*DBG::ptr() }
}
}
#[doc = "Debug support"]
pub mod dbg;
#[doc = "DMA controller"]
pub struct DMA0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for DMA0 {}
impl DMA0 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const dma0::RegisterBlock {
0x4002_0000 as *const _
}
}
impl Deref for DMA0 {
type Target = dma0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*DMA0::ptr() }
}
}
#[doc = "DMA controller"]
pub mod dma0;
#[doc = "Direct memory access controller"]
pub struct DMA1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for DMA1 {}
impl DMA1 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const dma1::RegisterBlock {
0x4002_0000 as *const _
}
}
impl Deref for DMA1 {
type Target = dma1::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*DMA1::ptr() }
}
}
#[doc = "Direct memory access controller"]
pub mod dma1;
#[doc = "External memory controller"]
pub struct EXMC {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for EXMC {}
impl EXMC {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const exmc::RegisterBlock {
0xa000_0000 as *const _
}
}
impl Deref for EXMC {
type Target = exmc::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*EXMC::ptr() }
}
}
#[doc = "External memory controller"]
pub mod exmc;
#[doc = "External interrupt/event controller"]
pub struct EXTI {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for EXTI {}
impl EXTI {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const exti::RegisterBlock {
0x4001_0400 as *const _
}
}
impl Deref for EXTI {
type Target = exti::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*EXTI::ptr() }
}
}
#[doc = "External interrupt/event controller"]
pub mod exti;
#[doc = "FMC"]
pub struct FMC {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for FMC {}
impl FMC {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const fmc::RegisterBlock {
0x4002_2000 as *const _
}
}
impl Deref for FMC {
type Target = fmc::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*FMC::ptr() }
}
}
#[doc = "FMC"]
pub mod fmc;
#[doc = "free watchdog timer"]
pub struct FWDGT {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for FWDGT {}
impl FWDGT {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const fwdgt::RegisterBlock {
0x4000_3000 as *const _
}
}
impl Deref for FWDGT {
type Target = fwdgt::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*FWDGT::ptr() }
}
}
#[doc = "free watchdog timer"]
pub mod fwdgt;
#[doc = "General-purpose I/Os"]
pub struct GPIOA {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for GPIOA {}
impl GPIOA {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const gpioa::RegisterBlock {
0x4001_0800 as *const _
}
}
impl Deref for GPIOA {
type Target = gpioa::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*GPIOA::ptr() }
}
}
#[doc = "General-purpose I/Os"]
pub mod gpioa;
#[doc = "General-purpose I/Os"]
pub struct GPIOB {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for GPIOB {}
impl GPIOB {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const gpioa::RegisterBlock {
0x4001_0c00 as *const _
}
}
impl Deref for GPIOB {
type Target = gpioa::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*GPIOB::ptr() }
}
}
#[doc = "General-purpose I/Os"]
pub struct GPIOC {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for GPIOC {}
impl GPIOC {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const gpioa::RegisterBlock {
0x4001_1000 as *const _
}
}
impl Deref for GPIOC {
type Target = gpioa::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*GPIOC::ptr() }
}
}
#[doc = "General-purpose I/Os"]
pub struct GPIOD {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for GPIOD {}
impl GPIOD {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const gpioa::RegisterBlock {
0x4001_1400 as *const _
}
}
impl Deref for GPIOD {
type Target = gpioa::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*GPIOD::ptr() }
}
}
#[doc = "General-purpose I/Os"]
pub struct GPIOE {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for GPIOE {}
impl GPIOE {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const gpioa::RegisterBlock {
0x4001_1800 as *const _
}
}
impl Deref for GPIOE {
type Target = gpioa::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*GPIOE::ptr() }
}
}
#[doc = "Inter integrated circuit"]
pub struct I2C0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for I2C0 {}
impl I2C0 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const i2c0::RegisterBlock {
0x4000_5400 as *const _
}
}
impl Deref for I2C0 {
type Target = i2c0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*I2C0::ptr() }
}
}
#[doc = "Inter integrated circuit"]
pub mod i2c0;
#[doc = "Inter integrated circuit"]
pub struct I2C1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for I2C1 {}
impl I2C1 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const i2c0::RegisterBlock {
0x4000_5800 as *const _
}
}
impl Deref for I2C1 {
type Target = i2c0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*I2C1::ptr() }
}
}
#[doc = "Enhanced Core Local Interrupt Controller"]
pub struct ECLIC {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for ECLIC {}
impl ECLIC {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const eclic::RegisterBlock {
0xd200_0000 as *const _
}
}
impl Deref for ECLIC {
type Target = eclic::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*ECLIC::ptr() }
}
}
#[doc = "Enhanced Core Local Interrupt Controller"]
pub mod eclic;
#[doc = "Power management unit"]
pub struct PMU {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for PMU {}
impl PMU {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const pmu::RegisterBlock {
0x4000_7000 as *const _
}
}
impl Deref for PMU {
type Target = pmu::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*PMU::ptr() }
}
}
#[doc = "Power management unit"]
pub mod pmu;
#[doc = "Reset and clock unit"]
pub struct RCU {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for RCU {}
impl RCU {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const rcu::RegisterBlock {
0x4002_1000 as *const _
}
}
impl Deref for RCU {
type Target = rcu::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*RCU::ptr() }
}
}
#[doc = "Reset and clock unit"]
pub mod rcu;
#[doc = "Real-time clock"]
pub struct RTC {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for RTC {}
impl RTC {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const rtc::RegisterBlock {
0x4000_2800 as *const _
}
}
impl Deref for RTC {
type Target = rtc::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*RTC::ptr() }
}
}
#[doc = "Real-time clock"]
pub mod rtc;
#[doc = "Serial peripheral interface"]
pub struct SPI0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SPI0 {}
impl SPI0 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const spi0::RegisterBlock {
0x4001_3000 as *const _
}
}
impl Deref for SPI0 {
type Target = spi0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*SPI0::ptr() }
}
}
#[doc = "Serial peripheral interface"]
pub mod spi0;
#[doc = "Serial peripheral interface"]
pub struct SPI1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SPI1 {}
impl SPI1 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const spi0::RegisterBlock {
0x4000_3800 as *const _
}
}
impl Deref for SPI1 {
type Target = spi0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*SPI1::ptr() }
}
}
#[doc = "Serial peripheral interface"]
pub struct SPI2 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for SPI2 {}
impl SPI2 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const spi0::RegisterBlock {
0x4000_3c00 as *const _
}
}
impl Deref for SPI2 {
type Target = spi0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*SPI2::ptr() }
}
}
#[doc = "Advanced-timers"]
pub struct TIMER0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for TIMER0 {}
impl TIMER0 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const timer0::RegisterBlock {
0x4001_2c00 as *const _
}
}
impl Deref for TIMER0 {
type Target = timer0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*TIMER0::ptr() }
}
}
#[doc = "Advanced-timers"]
pub mod timer0;
#[doc = "General-purpose-timers"]
pub struct TIMER1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for TIMER1 {}
impl TIMER1 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const timer1::RegisterBlock {
0x4000_0000 as *const _
}
}
impl Deref for TIMER1 {
type Target = timer1::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*TIMER1::ptr() }
}
}
#[doc = "General-purpose-timers"]
pub mod timer1;
#[doc = "General-purpose-timers"]
pub struct TIMER2 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for TIMER2 {}
impl TIMER2 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const timer1::RegisterBlock {
0x4000_0400 as *const _
}
}
impl Deref for TIMER2 {
type Target = timer1::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*TIMER2::ptr() }
}
}
#[doc = "General-purpose-timers"]
pub struct TIMER3 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for TIMER3 {}
impl TIMER3 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const timer1::RegisterBlock {
0x4000_0800 as *const _
}
}
impl Deref for TIMER3 {
type Target = timer1::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*TIMER3::ptr() }
}
}
#[doc = "General-purpose-timers"]
pub struct TIMER4 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for TIMER4 {}
impl TIMER4 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const timer1::RegisterBlock {
0x4000_0c00 as *const _
}
}
impl Deref for TIMER4 {
type Target = timer1::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*TIMER4::ptr() }
}
}
#[doc = "Basic-timers"]
pub struct TIMER5 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for TIMER5 {}
impl TIMER5 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const timer5::RegisterBlock {
0x4000_1000 as *const _
}
}
impl Deref for TIMER5 {
type Target = timer5::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*TIMER5::ptr() }
}
}
#[doc = "Basic-timers"]
pub mod timer5;
#[doc = "Basic-timers"]
pub struct TIMER6 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for TIMER6 {}
impl TIMER6 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const timer5::RegisterBlock {
0x4000_1400 as *const _
}
}
impl Deref for TIMER6 {
type Target = timer5::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*TIMER6::ptr() }
}
}
#[doc = "Universal synchronous asynchronous receiver transmitter"]
pub struct USART0 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for USART0 {}
impl USART0 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const usart0::RegisterBlock {
0x4001_3800 as *const _
}
}
impl Deref for USART0 {
type Target = usart0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*USART0::ptr() }
}
}
#[doc = "Universal synchronous asynchronous receiver transmitter"]
pub mod usart0;
#[doc = "Universal synchronous asynchronous receiver transmitter"]
pub struct USART1 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for USART1 {}
impl USART1 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const usart0::RegisterBlock {
0x4000_4400 as *const _
}
}
impl Deref for USART1 {
type Target = usart0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*USART1::ptr() }
}
}
#[doc = "Universal synchronous asynchronous receiver transmitter"]
pub struct USART2 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for USART2 {}
impl USART2 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const usart0::RegisterBlock {
0x4000_4800 as *const _
}
}
impl Deref for USART2 {
type Target = usart0::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*USART2::ptr() }
}
}
#[doc = "Universal asynchronous receiver transmitter"]
pub struct UART3 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for UART3 {}
impl UART3 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const uart3::RegisterBlock {
0x4000_4c00 as *const _
}
}
impl Deref for UART3 {
type Target = uart3::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*UART3::ptr() }
}
}
#[doc = "Universal asynchronous receiver transmitter"]
pub mod uart3;
#[doc = "Universal asynchronous receiver transmitter"]
pub struct UART4 {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for UART4 {}
impl UART4 {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const uart3::RegisterBlock {
0x4000_5000 as *const _
}
}
impl Deref for UART4 {
type Target = uart3::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*UART4::ptr() }
}
}
#[doc = "USB full speed global registers"]
pub struct USBFS_GLOBAL {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for USBFS_GLOBAL {}
impl USBFS_GLOBAL {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const usbfs_global::RegisterBlock {
0x5000_0000 as *const _
}
}
impl Deref for USBFS_GLOBAL {
type Target = usbfs_global::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*USBFS_GLOBAL::ptr() }
}
}
#[doc = "USB full speed global registers"]
pub mod usbfs_global;
#[doc = "USB on the go full speed host"]
pub struct USBFS_HOST {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for USBFS_HOST {}
impl USBFS_HOST {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const usbfs_host::RegisterBlock {
0x5000_0400 as *const _
}
}
impl Deref for USBFS_HOST {
type Target = usbfs_host::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*USBFS_HOST::ptr() }
}
}
#[doc = "USB on the go full speed host"]
pub mod usbfs_host;
#[doc = "USB on the go full speed device"]
pub struct USBFS_DEVICE {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for USBFS_DEVICE {}
impl USBFS_DEVICE {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const usbfs_device::RegisterBlock {
0x5000_0800 as *const _
}
}
impl Deref for USBFS_DEVICE {
type Target = usbfs_device::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*USBFS_DEVICE::ptr() }
}
}
#[doc = "USB on the go full speed device"]
pub mod usbfs_device;
#[doc = "USB on the go full speed"]
pub struct USBFS_PWRCLK {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for USBFS_PWRCLK {}
impl USBFS_PWRCLK {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const usbfs_pwrclk::RegisterBlock {
0x5000_0e00 as *const _
}
}
impl Deref for USBFS_PWRCLK {
type Target = usbfs_pwrclk::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*USBFS_PWRCLK::ptr() }
}
}
#[doc = "USB on the go full speed"]
pub mod usbfs_pwrclk;
#[doc = "Window watchdog timer"]
pub struct WWDGT {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for WWDGT {}
impl WWDGT {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const wwdgt::RegisterBlock {
0x4000_2c00 as *const _
}
}
impl Deref for WWDGT {
type Target = wwdgt::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*WWDGT::ptr() }
}
}
#[doc = "Window watchdog timer"]
pub mod wwdgt;
#[doc = "Core timer"]
pub struct CTIMER {
_marker: PhantomData<*const ()>,
}
unsafe impl Send for CTIMER {}
impl CTIMER {
#[doc = r"Returns a pointer to the register block"]
#[inline(always)]
pub const fn ptr() -> *const ctimer::RegisterBlock {
0xd100_0000 as *const _
}
}
impl Deref for CTIMER {
type Target = ctimer::RegisterBlock;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*CTIMER::ptr() }
}
}
#[doc = "Core timer"]
pub mod ctimer;
#[no_mangle]
static mut DEVICE_PERIPHERALS: bool = false;
#[doc = r"All the peripherals"]
#[allow(non_snake_case)]
pub struct Peripherals {
#[doc = "ADC0"]
pub ADC0: ADC0,
#[doc = "ADC1"]
pub ADC1: ADC1,
#[doc = "AFIO"]
pub AFIO: AFIO,
#[doc = "BKP"]
pub BKP: BKP,
#[doc = "CAN0"]
pub CAN0: CAN0,
#[doc = "CAN1"]
pub CAN1: CAN1,
#[doc = "CRC"]
pub CRC: CRC,
#[doc = "DAC"]
pub DAC: DAC,
#[doc = "DBG"]
pub DBG: DBG,
#[doc = "DMA0"]
pub DMA0: DMA0,
#[doc = "DMA1"]
pub DMA1: DMA1,
#[doc = "EXMC"]
pub EXMC: EXMC,
#[doc = "EXTI"]
pub EXTI: EXTI,
#[doc = "FMC"]
pub FMC: FMC,
#[doc = "FWDGT"]
pub FWDGT: FWDGT,
#[doc = "GPIOA"]
pub GPIOA: GPIOA,
#[doc = "GPIOB"]
pub GPIOB: GPIOB,
#[doc = "GPIOC"]
pub GPIOC: GPIOC,
#[doc = "GPIOD"]
pub GPIOD: GPIOD,
#[doc = "GPIOE"]
pub GPIOE: GPIOE,
#[doc = "I2C0"]
pub I2C0: I2C0,
#[doc = "I2C1"]
pub I2C1: I2C1,
#[doc = "ECLIC"]
pub ECLIC: ECLIC,
#[doc = "PMU"]
pub PMU: PMU,
#[doc = "RCU"]
pub RCU: RCU,
#[doc = "RTC"]
pub RTC: RTC,
#[doc = "SPI0"]
pub SPI0: SPI0,
#[doc = "SPI1"]
pub SPI1: SPI1,
#[doc = "SPI2"]
pub SPI2: SPI2,
#[doc = "TIMER0"]
pub TIMER0: TIMER0,
#[doc = "TIMER1"]
pub TIMER1: TIMER1,
#[doc = "TIMER2"]
pub TIMER2: TIMER2,
#[doc = "TIMER3"]
pub TIMER3: TIMER3,
#[doc = "TIMER4"]
pub TIMER4: TIMER4,
#[doc = "TIMER5"]
pub TIMER5: TIMER5,
#[doc = "TIMER6"]
pub TIMER6: TIMER6,
#[doc = "USART0"]
pub USART0: USART0,
#[doc = "USART1"]
pub USART1: USART1,
#[doc = "USART2"]
pub USART2: USART2,
#[doc = "UART3"]
pub UART3: UART3,
#[doc = "UART4"]
pub UART4: UART4,
#[doc = "USBFS_GLOBAL"]
pub USBFS_GLOBAL: USBFS_GLOBAL,
#[doc = "USBFS_HOST"]
pub USBFS_HOST: USBFS_HOST,
#[doc = "USBFS_DEVICE"]
pub USBFS_DEVICE: USBFS_DEVICE,
#[doc = "USBFS_PWRCLK"]
pub USBFS_PWRCLK: USBFS_PWRCLK,
#[doc = "WWDGT"]
pub WWDGT: WWDGT,
#[doc = "CTIMER"]
pub CTIMER: CTIMER,
}
impl Peripherals {
#[doc = r"Returns all the peripherals *once*"]
#[inline]
pub fn take() -> Option<Self> {
riscv::interrupt::free(|_| {
if unsafe { DEVICE_PERIPHERALS } {
None
} else {
Some(unsafe { Peripherals::steal() })
}
})
}
#[doc = r"Unchecked version of `Peripherals::take`"]
#[inline]
pub unsafe fn steal() -> Self {
DEVICE_PERIPHERALS = true;
Peripherals {
ADC0: ADC0 {
_marker: PhantomData,
},
ADC1: ADC1 {
_marker: PhantomData,
},
AFIO: AFIO {
_marker: PhantomData,
},
BKP: BKP {
_marker: PhantomData,
},
CAN0: CAN0 {
_marker: PhantomData,
},
CAN1: CAN1 {
_marker: PhantomData,
},
CRC: CRC {
_marker: PhantomData,
},
DAC: DAC {
_marker: PhantomData,
},
DBG: DBG {
_marker: PhantomData,
},
DMA0: DMA0 {
_marker: PhantomData,
},
DMA1: DMA1 {
_marker: PhantomData,
},
EXMC: EXMC {
_marker: PhantomData,
},
EXTI: EXTI {
_marker: PhantomData,
},
FMC: FMC {
_marker: PhantomData,
},
FWDGT: FWDGT {
_marker: PhantomData,
},
GPIOA: GPIOA {
_marker: PhantomData,
},
GPIOB: GPIOB {
_marker: PhantomData,
},
GPIOC: GPIOC {
_marker: PhantomData,
},
GPIOD: GPIOD {
_marker: PhantomData,
},
GPIOE: GPIOE {
_marker: PhantomData,
},
I2C0: I2C0 {
_marker: PhantomData,
},
I2C1: I2C1 {
_marker: PhantomData,
},
ECLIC: ECLIC {
_marker: PhantomData,
},
PMU: PMU {
_marker: PhantomData,
},
RCU: RCU {
_marker: PhantomData,
},
RTC: RTC {
_marker: PhantomData,
},
SPI0: SPI0 {
_marker: PhantomData,
},
SPI1: SPI1 {
_marker: PhantomData,
},
SPI2: SPI2 {
_marker: PhantomData,
},
TIMER0: TIMER0 {
_marker: PhantomData,
},
TIMER1: TIMER1 {
_marker: PhantomData,
},
TIMER2: TIMER2 {
_marker: PhantomData,
},
TIMER3: TIMER3 {
_marker: PhantomData,
},
TIMER4: TIMER4 {
_marker: PhantomData,
},
TIMER5: TIMER5 {
_marker: PhantomData,
},
TIMER6: TIMER6 {
_marker: PhantomData,
},
USART0: USART0 {
_marker: PhantomData,
},
USART1: USART1 {
_marker: PhantomData,
},
USART2: USART2 {
_marker: PhantomData,
},
UART3: UART3 {
_marker: PhantomData,
},
UART4: UART4 {
_marker: PhantomData,
},
USBFS_GLOBAL: USBFS_GLOBAL {
_marker: PhantomData,
},
USBFS_HOST: USBFS_HOST {
_marker: PhantomData,
},
USBFS_DEVICE: USBFS_DEVICE {
_marker: PhantomData,
},
USBFS_PWRCLK: USBFS_PWRCLK {
_marker: PhantomData,
},
WWDGT: WWDGT {
_marker: PhantomData,
},
CTIMER: CTIMER {
_marker: PhantomData,
},
}
}
}