#![allow(clippy::missing_safety_doc)]
#![allow(clippy::identity_op)]
#![allow(clippy::unnecessary_cast)]
#![allow(clippy::erasing_op)]
#[doc = "Reset and clock control"]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Rcc {
ptr: *mut u8,
}
unsafe impl Send for Rcc {}
unsafe impl Sync for Rcc {}
impl Rcc {
#[inline(always)]
pub const unsafe fn from_ptr(ptr: *mut ()) -> Self {
Self { ptr: ptr as _ }
}
#[inline(always)]
pub const fn as_ptr(&self) -> *mut () {
self.ptr as _
}
#[doc = "clock control register"]
#[inline(always)]
pub const fn cr(self) -> crate::common::Reg<regs::Cr, crate::common::RW> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0usize) as _) }
}
#[doc = "PLL configuration register"]
#[inline(always)]
pub const fn pllcfgr(self) -> crate::common::Reg<regs::Pllcfgr, crate::common::RW> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x04usize) as _) }
}
#[doc = "clock configuration register"]
#[inline(always)]
pub const fn cfgr(self) -> crate::common::Reg<regs::Cfgr, crate::common::RW> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x08usize) as _) }
}
#[doc = "clock interrupt register"]
#[inline(always)]
pub const fn cir(self) -> crate::common::Reg<regs::Cir, crate::common::RW> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0cusize) as _) }
}
#[doc = "AHB1 peripheral reset register"]
#[inline(always)]
pub const fn ahb1rstr(self) -> crate::common::Reg<regs::Ahb1rstr, crate::common::RW> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x10usize) as _) }
}
#[doc = "AHB2 peripheral reset register"]
#[inline(always)]
pub const fn ahb2rstr(self) -> crate::common::Reg<regs::Ahb2rstr, crate::common::RW> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x14usize) as _) }
}
#[doc = "AHB3 peripheral reset register"]
#[inline(always)]
pub const fn ahb3rstr(self) -> crate::common::Reg<regs::Ahb3rstr, crate::common::RW> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x18usize) as _) }
}
#[doc = "APB1 peripheral reset register"]
#[inline(always)]
pub const fn apb1rstr(self) -> crate::common::Reg<regs::Apb1rstr, crate::common::RW> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x20usize) as _) }
}
#[doc = "APB2 peripheral reset register"]
#[inline(always)]
pub const fn apb2rstr(self) -> crate::common::Reg<regs::Apb2rstr, crate::common::RW> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x24usize) as _) }
}
#[doc = "AHB1 peripheral clock register"]
#[inline(always)]
pub const fn ahb1enr(self) -> crate::common::Reg<regs::Ahb1enr, crate::common::RW> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x30usize) as _) }
}
#[doc = "AHB2 peripheral clock enable register"]
#[inline(always)]
pub const fn ahb2enr(self) -> crate::common::Reg<regs::Ahb2enr, crate::common::RW> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x34usize) as _) }
}
#[doc = "AHB3 peripheral clock enable register"]
#[inline(always)]
pub const fn ahb3enr(self) -> crate::common::Reg<regs::Ahb3enr, crate::common::RW> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x38usize) as _) }
}
#[doc = "APB1 peripheral clock enable register"]
#[inline(always)]
pub const fn apb1enr(self) -> crate::common::Reg<regs::Apb1enr, crate::common::RW> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x40usize) as _) }
}
#[doc = "APB2 peripheral clock enable register"]
#[inline(always)]
pub const fn apb2enr(self) -> crate::common::Reg<regs::Apb2enr, crate::common::RW> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x44usize) as _) }
}
#[doc = "AHB1 peripheral clock enable in low power mode register"]
#[inline(always)]
pub const fn ahb1lpenr(self) -> crate::common::Reg<regs::Ahb1lpenr, crate::common::RW> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x50usize) as _) }
}
#[doc = "AHB2 peripheral clock enable in low power mode register"]
#[inline(always)]
pub const fn ahb2lpenr(self) -> crate::common::Reg<regs::Ahb2lpenr, crate::common::RW> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x54usize) as _) }
}
#[doc = "AHB3 peripheral clock enable in low power mode register"]
#[inline(always)]
pub const fn ahb3lpenr(self) -> crate::common::Reg<regs::Ahb3lpenr, crate::common::RW> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x58usize) as _) }
}
#[doc = "APB1 peripheral clock enable in low power mode register"]
#[inline(always)]
pub const fn apb1lpenr(self) -> crate::common::Reg<regs::Apb1lpenr, crate::common::RW> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x60usize) as _) }
}
#[doc = "APB2 peripheral clock enabled in low power mode register"]
#[inline(always)]
pub const fn apb2lpenr(self) -> crate::common::Reg<regs::Apb2lpenr, crate::common::RW> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x64usize) as _) }
}
#[doc = "Backup domain control register"]
#[inline(always)]
pub const fn bdcr(self) -> crate::common::Reg<regs::Bdcr, crate::common::RW> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x70usize) as _) }
}
#[doc = "clock control & status register"]
#[inline(always)]
pub const fn csr(self) -> crate::common::Reg<regs::Csr, crate::common::RW> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x74usize) as _) }
}
#[doc = "spread spectrum clock generation register"]
#[inline(always)]
pub const fn sscgr(self) -> crate::common::Reg<regs::Sscgr, crate::common::RW> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x80usize) as _) }
}
#[doc = "PLLI2S configuration register"]
#[inline(always)]
pub const fn plli2scfgr(self) -> crate::common::Reg<regs::Plli2scfgr, crate::common::RW> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x84usize) as _) }
}
#[doc = "PLL configuration register"]
#[inline(always)]
pub const fn pllsaicfgr(self) -> crate::common::Reg<regs::Pllsaicfgr, crate::common::RW> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x88usize) as _) }
}
#[doc = "dedicated clocks configuration register"]
#[inline(always)]
pub const fn dckcfgr1(self) -> crate::common::Reg<regs::Dckcfgr1, crate::common::RW> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x8cusize) as _) }
}
#[doc = "dedicated clocks configuration register"]
#[inline(always)]
pub const fn dckcfgr2(self) -> crate::common::Reg<regs::Dckcfgr2, crate::common::RW> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x90usize) as _) }
}
}
pub mod regs {
#[doc = "AHB1 peripheral clock register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ahb1enr(pub u32);
impl Ahb1enr {
#[doc = "IO port A clock enable"]
#[inline(always)]
pub const fn gpioaen(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "IO port A clock enable"]
#[inline(always)]
pub fn set_gpioaen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "IO port B clock enable"]
#[inline(always)]
pub const fn gpioben(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "IO port B clock enable"]
#[inline(always)]
pub fn set_gpioben(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "IO port C clock enable"]
#[inline(always)]
pub const fn gpiocen(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[doc = "IO port C clock enable"]
#[inline(always)]
pub fn set_gpiocen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
#[doc = "IO port D clock enable"]
#[inline(always)]
pub const fn gpioden(&self) -> bool {
let val = (self.0 >> 3usize) & 0x01;
val != 0
}
#[doc = "IO port D clock enable"]
#[inline(always)]
pub fn set_gpioden(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
}
#[doc = "IO port E clock enable"]
#[inline(always)]
pub const fn gpioeen(&self) -> bool {
let val = (self.0 >> 4usize) & 0x01;
val != 0
}
#[doc = "IO port E clock enable"]
#[inline(always)]
pub fn set_gpioeen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
}
#[doc = "IO port F clock enable"]
#[inline(always)]
pub const fn gpiofen(&self) -> bool {
let val = (self.0 >> 5usize) & 0x01;
val != 0
}
#[doc = "IO port F clock enable"]
#[inline(always)]
pub fn set_gpiofen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
}
#[doc = "IO port G clock enable"]
#[inline(always)]
pub const fn gpiogen(&self) -> bool {
let val = (self.0 >> 6usize) & 0x01;
val != 0
}
#[doc = "IO port G clock enable"]
#[inline(always)]
pub fn set_gpiogen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 6usize)) | (((val as u32) & 0x01) << 6usize);
}
#[doc = "IO port H clock enable"]
#[inline(always)]
pub const fn gpiohen(&self) -> bool {
let val = (self.0 >> 7usize) & 0x01;
val != 0
}
#[doc = "IO port H clock enable"]
#[inline(always)]
pub fn set_gpiohen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 7usize)) | (((val as u32) & 0x01) << 7usize);
}
#[doc = "IO port I clock enable"]
#[inline(always)]
pub const fn gpioien(&self) -> bool {
let val = (self.0 >> 8usize) & 0x01;
val != 0
}
#[doc = "IO port I clock enable"]
#[inline(always)]
pub fn set_gpioien(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 8usize)) | (((val as u32) & 0x01) << 8usize);
}
#[doc = "IO port J clock enable"]
#[inline(always)]
pub const fn gpiojen(&self) -> bool {
let val = (self.0 >> 9usize) & 0x01;
val != 0
}
#[doc = "IO port J clock enable"]
#[inline(always)]
pub fn set_gpiojen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 9usize)) | (((val as u32) & 0x01) << 9usize);
}
#[doc = "IO port K clock enable"]
#[inline(always)]
pub const fn gpioken(&self) -> bool {
let val = (self.0 >> 10usize) & 0x01;
val != 0
}
#[doc = "IO port K clock enable"]
#[inline(always)]
pub fn set_gpioken(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 10usize)) | (((val as u32) & 0x01) << 10usize);
}
#[doc = "CRC clock enable"]
#[inline(always)]
pub const fn crcen(&self) -> bool {
let val = (self.0 >> 12usize) & 0x01;
val != 0
}
#[doc = "CRC clock enable"]
#[inline(always)]
pub fn set_crcen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 12usize)) | (((val as u32) & 0x01) << 12usize);
}
#[doc = "Backup SRAM interface clock enable"]
#[inline(always)]
pub const fn bkpsramen(&self) -> bool {
let val = (self.0 >> 18usize) & 0x01;
val != 0
}
#[doc = "Backup SRAM interface clock enable"]
#[inline(always)]
pub fn set_bkpsramen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 18usize)) | (((val as u32) & 0x01) << 18usize);
}
#[doc = "CCM data RAM clock enable"]
#[inline(always)]
pub const fn dtcmramen(&self) -> bool {
let val = (self.0 >> 20usize) & 0x01;
val != 0
}
#[doc = "CCM data RAM clock enable"]
#[inline(always)]
pub fn set_dtcmramen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 20usize)) | (((val as u32) & 0x01) << 20usize);
}
#[doc = "DMA1 clock enable"]
#[inline(always)]
pub const fn dma1en(&self) -> bool {
let val = (self.0 >> 21usize) & 0x01;
val != 0
}
#[doc = "DMA1 clock enable"]
#[inline(always)]
pub fn set_dma1en(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 21usize)) | (((val as u32) & 0x01) << 21usize);
}
#[doc = "DMA2 clock enable"]
#[inline(always)]
pub const fn dma2en(&self) -> bool {
let val = (self.0 >> 22usize) & 0x01;
val != 0
}
#[doc = "DMA2 clock enable"]
#[inline(always)]
pub fn set_dma2en(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 22usize)) | (((val as u32) & 0x01) << 22usize);
}
#[doc = "DMA2D clock enable"]
#[inline(always)]
pub const fn dma2den(&self) -> bool {
let val = (self.0 >> 23usize) & 0x01;
val != 0
}
#[doc = "DMA2D clock enable"]
#[inline(always)]
pub fn set_dma2den(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 23usize)) | (((val as u32) & 0x01) << 23usize);
}
#[doc = "Ethernet MAC clock enable"]
#[inline(always)]
pub const fn ethen(&self) -> bool {
let val = (self.0 >> 25usize) & 0x01;
val != 0
}
#[doc = "Ethernet MAC clock enable"]
#[inline(always)]
pub fn set_ethen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 25usize)) | (((val as u32) & 0x01) << 25usize);
}
#[doc = "Ethernet Transmission clock enable"]
#[inline(always)]
pub const fn ethtxen(&self) -> bool {
let val = (self.0 >> 26usize) & 0x01;
val != 0
}
#[doc = "Ethernet Transmission clock enable"]
#[inline(always)]
pub fn set_ethtxen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 26usize)) | (((val as u32) & 0x01) << 26usize);
}
#[doc = "Ethernet Reception clock enable"]
#[inline(always)]
pub const fn ethrxen(&self) -> bool {
let val = (self.0 >> 27usize) & 0x01;
val != 0
}
#[doc = "Ethernet Reception clock enable"]
#[inline(always)]
pub fn set_ethrxen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 27usize)) | (((val as u32) & 0x01) << 27usize);
}
#[doc = "Ethernet PTP clock enable"]
#[inline(always)]
pub const fn ethptpen(&self) -> bool {
let val = (self.0 >> 28usize) & 0x01;
val != 0
}
#[doc = "Ethernet PTP clock enable"]
#[inline(always)]
pub fn set_ethptpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 28usize)) | (((val as u32) & 0x01) << 28usize);
}
#[doc = "USB OTG HS clock enable"]
#[inline(always)]
pub const fn usb_otg_hsen(&self) -> bool {
let val = (self.0 >> 29usize) & 0x01;
val != 0
}
#[doc = "USB OTG HS clock enable"]
#[inline(always)]
pub fn set_usb_otg_hsen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 29usize)) | (((val as u32) & 0x01) << 29usize);
}
#[doc = "USB OTG HSULPI clock enable"]
#[inline(always)]
pub const fn usb_otg_hsulpien(&self) -> bool {
let val = (self.0 >> 30usize) & 0x01;
val != 0
}
#[doc = "USB OTG HSULPI clock enable"]
#[inline(always)]
pub fn set_usb_otg_hsulpien(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 30usize)) | (((val as u32) & 0x01) << 30usize);
}
}
impl Default for Ahb1enr {
#[inline(always)]
fn default() -> Ahb1enr {
Ahb1enr(0)
}
}
impl core::fmt::Debug for Ahb1enr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Ahb1enr")
.field("gpioaen", &self.gpioaen())
.field("gpioben", &self.gpioben())
.field("gpiocen", &self.gpiocen())
.field("gpioden", &self.gpioden())
.field("gpioeen", &self.gpioeen())
.field("gpiofen", &self.gpiofen())
.field("gpiogen", &self.gpiogen())
.field("gpiohen", &self.gpiohen())
.field("gpioien", &self.gpioien())
.field("gpiojen", &self.gpiojen())
.field("gpioken", &self.gpioken())
.field("crcen", &self.crcen())
.field("bkpsramen", &self.bkpsramen())
.field("dtcmramen", &self.dtcmramen())
.field("dma1en", &self.dma1en())
.field("dma2en", &self.dma2en())
.field("dma2den", &self.dma2den())
.field("ethen", &self.ethen())
.field("ethtxen", &self.ethtxen())
.field("ethrxen", &self.ethrxen())
.field("ethptpen", &self.ethptpen())
.field("usb_otg_hsen", &self.usb_otg_hsen())
.field("usb_otg_hsulpien", &self.usb_otg_hsulpien())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Ahb1enr {
fn format(&self, f: defmt::Formatter) {
defmt :: write ! (f , "Ahb1enr {{ gpioaen: {=bool:?}, gpioben: {=bool:?}, gpiocen: {=bool:?}, gpioden: {=bool:?}, gpioeen: {=bool:?}, gpiofen: {=bool:?}, gpiogen: {=bool:?}, gpiohen: {=bool:?}, gpioien: {=bool:?}, gpiojen: {=bool:?}, gpioken: {=bool:?}, crcen: {=bool:?}, bkpsramen: {=bool:?}, dtcmramen: {=bool:?}, dma1en: {=bool:?}, dma2en: {=bool:?}, dma2den: {=bool:?}, ethen: {=bool:?}, ethtxen: {=bool:?}, ethrxen: {=bool:?}, ethptpen: {=bool:?}, usb_otg_hsen: {=bool:?}, usb_otg_hsulpien: {=bool:?} }}" , self . gpioaen () , self . gpioben () , self . gpiocen () , self . gpioden () , self . gpioeen () , self . gpiofen () , self . gpiogen () , self . gpiohen () , self . gpioien () , self . gpiojen () , self . gpioken () , self . crcen () , self . bkpsramen () , self . dtcmramen () , self . dma1en () , self . dma2en () , self . dma2den () , self . ethen () , self . ethtxen () , self . ethrxen () , self . ethptpen () , self . usb_otg_hsen () , self . usb_otg_hsulpien ())
}
}
#[doc = "AHB1 peripheral clock enable in low power mode register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ahb1lpenr(pub u32);
impl Ahb1lpenr {
#[doc = "IO port A clock enable during sleep mode"]
#[inline(always)]
pub const fn gpioalpen(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "IO port A clock enable during sleep mode"]
#[inline(always)]
pub fn set_gpioalpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "IO port B clock enable during Sleep mode"]
#[inline(always)]
pub const fn gpioblpen(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "IO port B clock enable during Sleep mode"]
#[inline(always)]
pub fn set_gpioblpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "IO port C clock enable during Sleep mode"]
#[inline(always)]
pub const fn gpioclpen(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[doc = "IO port C clock enable during Sleep mode"]
#[inline(always)]
pub fn set_gpioclpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
#[doc = "IO port D clock enable during Sleep mode"]
#[inline(always)]
pub const fn gpiodlpen(&self) -> bool {
let val = (self.0 >> 3usize) & 0x01;
val != 0
}
#[doc = "IO port D clock enable during Sleep mode"]
#[inline(always)]
pub fn set_gpiodlpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
}
#[doc = "IO port E clock enable during Sleep mode"]
#[inline(always)]
pub const fn gpioelpen(&self) -> bool {
let val = (self.0 >> 4usize) & 0x01;
val != 0
}
#[doc = "IO port E clock enable during Sleep mode"]
#[inline(always)]
pub fn set_gpioelpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
}
#[doc = "IO port F clock enable during Sleep mode"]
#[inline(always)]
pub const fn gpioflpen(&self) -> bool {
let val = (self.0 >> 5usize) & 0x01;
val != 0
}
#[doc = "IO port F clock enable during Sleep mode"]
#[inline(always)]
pub fn set_gpioflpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
}
#[doc = "IO port G clock enable during Sleep mode"]
#[inline(always)]
pub const fn gpioglpen(&self) -> bool {
let val = (self.0 >> 6usize) & 0x01;
val != 0
}
#[doc = "IO port G clock enable during Sleep mode"]
#[inline(always)]
pub fn set_gpioglpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 6usize)) | (((val as u32) & 0x01) << 6usize);
}
#[doc = "IO port H clock enable during Sleep mode"]
#[inline(always)]
pub const fn gpiohlpen(&self) -> bool {
let val = (self.0 >> 7usize) & 0x01;
val != 0
}
#[doc = "IO port H clock enable during Sleep mode"]
#[inline(always)]
pub fn set_gpiohlpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 7usize)) | (((val as u32) & 0x01) << 7usize);
}
#[doc = "IO port I clock enable during Sleep mode"]
#[inline(always)]
pub const fn gpioilpen(&self) -> bool {
let val = (self.0 >> 8usize) & 0x01;
val != 0
}
#[doc = "IO port I clock enable during Sleep mode"]
#[inline(always)]
pub fn set_gpioilpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 8usize)) | (((val as u32) & 0x01) << 8usize);
}
#[doc = "IO port J clock enable during Sleep mode"]
#[inline(always)]
pub const fn gpiojlpen(&self) -> bool {
let val = (self.0 >> 9usize) & 0x01;
val != 0
}
#[doc = "IO port J clock enable during Sleep mode"]
#[inline(always)]
pub fn set_gpiojlpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 9usize)) | (((val as u32) & 0x01) << 9usize);
}
#[doc = "IO port K clock enable during Sleep mode"]
#[inline(always)]
pub const fn gpioklpen(&self) -> bool {
let val = (self.0 >> 10usize) & 0x01;
val != 0
}
#[doc = "IO port K clock enable during Sleep mode"]
#[inline(always)]
pub fn set_gpioklpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 10usize)) | (((val as u32) & 0x01) << 10usize);
}
#[doc = "CRC clock enable during Sleep mode"]
#[inline(always)]
pub const fn crclpen(&self) -> bool {
let val = (self.0 >> 12usize) & 0x01;
val != 0
}
#[doc = "CRC clock enable during Sleep mode"]
#[inline(always)]
pub fn set_crclpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 12usize)) | (((val as u32) & 0x01) << 12usize);
}
#[doc = "AXI to AHB bridge clock enable during Sleep mode"]
#[inline(always)]
pub const fn axilpen(&self) -> bool {
let val = (self.0 >> 13usize) & 0x01;
val != 0
}
#[doc = "AXI to AHB bridge clock enable during Sleep mode"]
#[inline(always)]
pub fn set_axilpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 13usize)) | (((val as u32) & 0x01) << 13usize);
}
#[doc = "Flash interface clock enable during Sleep mode"]
#[inline(always)]
pub const fn flashlpen(&self) -> bool {
let val = (self.0 >> 15usize) & 0x01;
val != 0
}
#[doc = "Flash interface clock enable during Sleep mode"]
#[inline(always)]
pub fn set_flashlpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 15usize)) | (((val as u32) & 0x01) << 15usize);
}
#[doc = "SRAM 1interface clock enable during Sleep mode"]
#[inline(always)]
pub const fn sram1lpen(&self) -> bool {
let val = (self.0 >> 16usize) & 0x01;
val != 0
}
#[doc = "SRAM 1interface clock enable during Sleep mode"]
#[inline(always)]
pub fn set_sram1lpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 16usize)) | (((val as u32) & 0x01) << 16usize);
}
#[doc = "SRAM 2 interface clock enable during Sleep mode"]
#[inline(always)]
pub const fn sram2lpen(&self) -> bool {
let val = (self.0 >> 17usize) & 0x01;
val != 0
}
#[doc = "SRAM 2 interface clock enable during Sleep mode"]
#[inline(always)]
pub fn set_sram2lpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 17usize)) | (((val as u32) & 0x01) << 17usize);
}
#[doc = "Backup SRAM interface clock enable during Sleep mode"]
#[inline(always)]
pub const fn bkpsramlpen(&self) -> bool {
let val = (self.0 >> 18usize) & 0x01;
val != 0
}
#[doc = "Backup SRAM interface clock enable during Sleep mode"]
#[inline(always)]
pub fn set_bkpsramlpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 18usize)) | (((val as u32) & 0x01) << 18usize);
}
#[doc = "SRAM 3 interface clock enable during Sleep mode"]
#[inline(always)]
pub const fn sram3lpen(&self) -> bool {
let val = (self.0 >> 19usize) & 0x01;
val != 0
}
#[doc = "SRAM 3 interface clock enable during Sleep mode"]
#[inline(always)]
pub fn set_sram3lpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 19usize)) | (((val as u32) & 0x01) << 19usize);
}
#[doc = "DTCM RAM interface clock enable during Sleep mode"]
#[inline(always)]
pub const fn dtcmlpen(&self) -> bool {
let val = (self.0 >> 20usize) & 0x01;
val != 0
}
#[doc = "DTCM RAM interface clock enable during Sleep mode"]
#[inline(always)]
pub fn set_dtcmlpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 20usize)) | (((val as u32) & 0x01) << 20usize);
}
#[doc = "DMA1 clock enable during Sleep mode"]
#[inline(always)]
pub const fn dma1lpen(&self) -> bool {
let val = (self.0 >> 21usize) & 0x01;
val != 0
}
#[doc = "DMA1 clock enable during Sleep mode"]
#[inline(always)]
pub fn set_dma1lpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 21usize)) | (((val as u32) & 0x01) << 21usize);
}
#[doc = "DMA2 clock enable during Sleep mode"]
#[inline(always)]
pub const fn dma2lpen(&self) -> bool {
let val = (self.0 >> 22usize) & 0x01;
val != 0
}
#[doc = "DMA2 clock enable during Sleep mode"]
#[inline(always)]
pub fn set_dma2lpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 22usize)) | (((val as u32) & 0x01) << 22usize);
}
#[doc = "DMA2D clock enable during Sleep mode"]
#[inline(always)]
pub const fn dma2dlpen(&self) -> bool {
let val = (self.0 >> 23usize) & 0x01;
val != 0
}
#[doc = "DMA2D clock enable during Sleep mode"]
#[inline(always)]
pub fn set_dma2dlpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 23usize)) | (((val as u32) & 0x01) << 23usize);
}
#[doc = "Ethernet MAC clock enable during Sleep mode"]
#[inline(always)]
pub const fn ethlpen(&self) -> bool {
let val = (self.0 >> 25usize) & 0x01;
val != 0
}
#[doc = "Ethernet MAC clock enable during Sleep mode"]
#[inline(always)]
pub fn set_ethlpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 25usize)) | (((val as u32) & 0x01) << 25usize);
}
#[doc = "Ethernet transmission clock enable during Sleep mode"]
#[inline(always)]
pub const fn ethtxlpen(&self) -> bool {
let val = (self.0 >> 26usize) & 0x01;
val != 0
}
#[doc = "Ethernet transmission clock enable during Sleep mode"]
#[inline(always)]
pub fn set_ethtxlpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 26usize)) | (((val as u32) & 0x01) << 26usize);
}
#[doc = "Ethernet reception clock enable during Sleep mode"]
#[inline(always)]
pub const fn ethrxlpen(&self) -> bool {
let val = (self.0 >> 27usize) & 0x01;
val != 0
}
#[doc = "Ethernet reception clock enable during Sleep mode"]
#[inline(always)]
pub fn set_ethrxlpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 27usize)) | (((val as u32) & 0x01) << 27usize);
}
#[doc = "Ethernet PTP clock enable during Sleep mode"]
#[inline(always)]
pub const fn ethptplpen(&self) -> bool {
let val = (self.0 >> 28usize) & 0x01;
val != 0
}
#[doc = "Ethernet PTP clock enable during Sleep mode"]
#[inline(always)]
pub fn set_ethptplpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 28usize)) | (((val as u32) & 0x01) << 28usize);
}
#[doc = "USB OTG HS clock enable during Sleep mode"]
#[inline(always)]
pub const fn usb_otg_hslpen(&self) -> bool {
let val = (self.0 >> 29usize) & 0x01;
val != 0
}
#[doc = "USB OTG HS clock enable during Sleep mode"]
#[inline(always)]
pub fn set_usb_otg_hslpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 29usize)) | (((val as u32) & 0x01) << 29usize);
}
#[doc = "USB OTG HS ULPI clock enable during Sleep mode"]
#[inline(always)]
pub const fn usb_otg_hsulpilpen(&self) -> bool {
let val = (self.0 >> 30usize) & 0x01;
val != 0
}
#[doc = "USB OTG HS ULPI clock enable during Sleep mode"]
#[inline(always)]
pub fn set_usb_otg_hsulpilpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 30usize)) | (((val as u32) & 0x01) << 30usize);
}
}
impl Default for Ahb1lpenr {
#[inline(always)]
fn default() -> Ahb1lpenr {
Ahb1lpenr(0)
}
}
impl core::fmt::Debug for Ahb1lpenr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Ahb1lpenr")
.field("gpioalpen", &self.gpioalpen())
.field("gpioblpen", &self.gpioblpen())
.field("gpioclpen", &self.gpioclpen())
.field("gpiodlpen", &self.gpiodlpen())
.field("gpioelpen", &self.gpioelpen())
.field("gpioflpen", &self.gpioflpen())
.field("gpioglpen", &self.gpioglpen())
.field("gpiohlpen", &self.gpiohlpen())
.field("gpioilpen", &self.gpioilpen())
.field("gpiojlpen", &self.gpiojlpen())
.field("gpioklpen", &self.gpioklpen())
.field("crclpen", &self.crclpen())
.field("axilpen", &self.axilpen())
.field("flashlpen", &self.flashlpen())
.field("sram1lpen", &self.sram1lpen())
.field("sram2lpen", &self.sram2lpen())
.field("bkpsramlpen", &self.bkpsramlpen())
.field("sram3lpen", &self.sram3lpen())
.field("dtcmlpen", &self.dtcmlpen())
.field("dma1lpen", &self.dma1lpen())
.field("dma2lpen", &self.dma2lpen())
.field("dma2dlpen", &self.dma2dlpen())
.field("ethlpen", &self.ethlpen())
.field("ethtxlpen", &self.ethtxlpen())
.field("ethrxlpen", &self.ethrxlpen())
.field("ethptplpen", &self.ethptplpen())
.field("usb_otg_hslpen", &self.usb_otg_hslpen())
.field("usb_otg_hsulpilpen", &self.usb_otg_hsulpilpen())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Ahb1lpenr {
fn format(&self, f: defmt::Formatter) {
defmt :: write ! (f , "Ahb1lpenr {{ gpioalpen: {=bool:?}, gpioblpen: {=bool:?}, gpioclpen: {=bool:?}, gpiodlpen: {=bool:?}, gpioelpen: {=bool:?}, gpioflpen: {=bool:?}, gpioglpen: {=bool:?}, gpiohlpen: {=bool:?}, gpioilpen: {=bool:?}, gpiojlpen: {=bool:?}, gpioklpen: {=bool:?}, crclpen: {=bool:?}, axilpen: {=bool:?}, flashlpen: {=bool:?}, sram1lpen: {=bool:?}, sram2lpen: {=bool:?}, bkpsramlpen: {=bool:?}, sram3lpen: {=bool:?}, dtcmlpen: {=bool:?}, dma1lpen: {=bool:?}, dma2lpen: {=bool:?}, dma2dlpen: {=bool:?}, ethlpen: {=bool:?}, ethtxlpen: {=bool:?}, ethrxlpen: {=bool:?}, ethptplpen: {=bool:?}, usb_otg_hslpen: {=bool:?}, usb_otg_hsulpilpen: {=bool:?} }}" , self . gpioalpen () , self . gpioblpen () , self . gpioclpen () , self . gpiodlpen () , self . gpioelpen () , self . gpioflpen () , self . gpioglpen () , self . gpiohlpen () , self . gpioilpen () , self . gpiojlpen () , self . gpioklpen () , self . crclpen () , self . axilpen () , self . flashlpen () , self . sram1lpen () , self . sram2lpen () , self . bkpsramlpen () , self . sram3lpen () , self . dtcmlpen () , self . dma1lpen () , self . dma2lpen () , self . dma2dlpen () , self . ethlpen () , self . ethtxlpen () , self . ethrxlpen () , self . ethptplpen () , self . usb_otg_hslpen () , self . usb_otg_hsulpilpen ())
}
}
#[doc = "AHB1 peripheral reset register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ahb1rstr(pub u32);
impl Ahb1rstr {
#[doc = "IO port A reset"]
#[inline(always)]
pub const fn gpioarst(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "IO port A reset"]
#[inline(always)]
pub fn set_gpioarst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "IO port B reset"]
#[inline(always)]
pub const fn gpiobrst(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "IO port B reset"]
#[inline(always)]
pub fn set_gpiobrst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "IO port C reset"]
#[inline(always)]
pub const fn gpiocrst(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[doc = "IO port C reset"]
#[inline(always)]
pub fn set_gpiocrst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
#[doc = "IO port D reset"]
#[inline(always)]
pub const fn gpiodrst(&self) -> bool {
let val = (self.0 >> 3usize) & 0x01;
val != 0
}
#[doc = "IO port D reset"]
#[inline(always)]
pub fn set_gpiodrst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
}
#[doc = "IO port E reset"]
#[inline(always)]
pub const fn gpioerst(&self) -> bool {
let val = (self.0 >> 4usize) & 0x01;
val != 0
}
#[doc = "IO port E reset"]
#[inline(always)]
pub fn set_gpioerst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
}
#[doc = "IO port F reset"]
#[inline(always)]
pub const fn gpiofrst(&self) -> bool {
let val = (self.0 >> 5usize) & 0x01;
val != 0
}
#[doc = "IO port F reset"]
#[inline(always)]
pub fn set_gpiofrst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
}
#[doc = "IO port G reset"]
#[inline(always)]
pub const fn gpiogrst(&self) -> bool {
let val = (self.0 >> 6usize) & 0x01;
val != 0
}
#[doc = "IO port G reset"]
#[inline(always)]
pub fn set_gpiogrst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 6usize)) | (((val as u32) & 0x01) << 6usize);
}
#[doc = "IO port H reset"]
#[inline(always)]
pub const fn gpiohrst(&self) -> bool {
let val = (self.0 >> 7usize) & 0x01;
val != 0
}
#[doc = "IO port H reset"]
#[inline(always)]
pub fn set_gpiohrst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 7usize)) | (((val as u32) & 0x01) << 7usize);
}
#[doc = "IO port I reset"]
#[inline(always)]
pub const fn gpioirst(&self) -> bool {
let val = (self.0 >> 8usize) & 0x01;
val != 0
}
#[doc = "IO port I reset"]
#[inline(always)]
pub fn set_gpioirst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 8usize)) | (((val as u32) & 0x01) << 8usize);
}
#[doc = "IO port J reset"]
#[inline(always)]
pub const fn gpiojrst(&self) -> bool {
let val = (self.0 >> 9usize) & 0x01;
val != 0
}
#[doc = "IO port J reset"]
#[inline(always)]
pub fn set_gpiojrst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 9usize)) | (((val as u32) & 0x01) << 9usize);
}
#[doc = "IO port K reset"]
#[inline(always)]
pub const fn gpiokrst(&self) -> bool {
let val = (self.0 >> 10usize) & 0x01;
val != 0
}
#[doc = "IO port K reset"]
#[inline(always)]
pub fn set_gpiokrst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 10usize)) | (((val as u32) & 0x01) << 10usize);
}
#[doc = "CRC reset"]
#[inline(always)]
pub const fn crcrst(&self) -> bool {
let val = (self.0 >> 12usize) & 0x01;
val != 0
}
#[doc = "CRC reset"]
#[inline(always)]
pub fn set_crcrst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 12usize)) | (((val as u32) & 0x01) << 12usize);
}
#[doc = "DMA2 reset"]
#[inline(always)]
pub const fn dma1rst(&self) -> bool {
let val = (self.0 >> 21usize) & 0x01;
val != 0
}
#[doc = "DMA2 reset"]
#[inline(always)]
pub fn set_dma1rst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 21usize)) | (((val as u32) & 0x01) << 21usize);
}
#[doc = "DMA2 reset"]
#[inline(always)]
pub const fn dma2rst(&self) -> bool {
let val = (self.0 >> 22usize) & 0x01;
val != 0
}
#[doc = "DMA2 reset"]
#[inline(always)]
pub fn set_dma2rst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 22usize)) | (((val as u32) & 0x01) << 22usize);
}
#[doc = "DMA2D reset"]
#[inline(always)]
pub const fn dma2drst(&self) -> bool {
let val = (self.0 >> 23usize) & 0x01;
val != 0
}
#[doc = "DMA2D reset"]
#[inline(always)]
pub fn set_dma2drst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 23usize)) | (((val as u32) & 0x01) << 23usize);
}
#[doc = "Ethernet MAC reset"]
#[inline(always)]
pub const fn ethrst(&self) -> bool {
let val = (self.0 >> 25usize) & 0x01;
val != 0
}
#[doc = "Ethernet MAC reset"]
#[inline(always)]
pub fn set_ethrst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 25usize)) | (((val as u32) & 0x01) << 25usize);
}
#[doc = "USB OTG HS module reset"]
#[inline(always)]
pub const fn usb_otg_hsrst(&self) -> bool {
let val = (self.0 >> 29usize) & 0x01;
val != 0
}
#[doc = "USB OTG HS module reset"]
#[inline(always)]
pub fn set_usb_otg_hsrst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 29usize)) | (((val as u32) & 0x01) << 29usize);
}
}
impl Default for Ahb1rstr {
#[inline(always)]
fn default() -> Ahb1rstr {
Ahb1rstr(0)
}
}
impl core::fmt::Debug for Ahb1rstr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Ahb1rstr")
.field("gpioarst", &self.gpioarst())
.field("gpiobrst", &self.gpiobrst())
.field("gpiocrst", &self.gpiocrst())
.field("gpiodrst", &self.gpiodrst())
.field("gpioerst", &self.gpioerst())
.field("gpiofrst", &self.gpiofrst())
.field("gpiogrst", &self.gpiogrst())
.field("gpiohrst", &self.gpiohrst())
.field("gpioirst", &self.gpioirst())
.field("gpiojrst", &self.gpiojrst())
.field("gpiokrst", &self.gpiokrst())
.field("crcrst", &self.crcrst())
.field("dma1rst", &self.dma1rst())
.field("dma2rst", &self.dma2rst())
.field("dma2drst", &self.dma2drst())
.field("ethrst", &self.ethrst())
.field("usb_otg_hsrst", &self.usb_otg_hsrst())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Ahb1rstr {
fn format(&self, f: defmt::Formatter) {
defmt :: write ! (f , "Ahb1rstr {{ gpioarst: {=bool:?}, gpiobrst: {=bool:?}, gpiocrst: {=bool:?}, gpiodrst: {=bool:?}, gpioerst: {=bool:?}, gpiofrst: {=bool:?}, gpiogrst: {=bool:?}, gpiohrst: {=bool:?}, gpioirst: {=bool:?}, gpiojrst: {=bool:?}, gpiokrst: {=bool:?}, crcrst: {=bool:?}, dma1rst: {=bool:?}, dma2rst: {=bool:?}, dma2drst: {=bool:?}, ethrst: {=bool:?}, usb_otg_hsrst: {=bool:?} }}" , self . gpioarst () , self . gpiobrst () , self . gpiocrst () , self . gpiodrst () , self . gpioerst () , self . gpiofrst () , self . gpiogrst () , self . gpiohrst () , self . gpioirst () , self . gpiojrst () , self . gpiokrst () , self . crcrst () , self . dma1rst () , self . dma2rst () , self . dma2drst () , self . ethrst () , self . usb_otg_hsrst ())
}
}
#[doc = "AHB2 peripheral clock enable register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ahb2enr(pub u32);
impl Ahb2enr {
#[doc = "Camera interface enable"]
#[inline(always)]
pub const fn dcmien(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Camera interface enable"]
#[inline(always)]
pub fn set_dcmien(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "JPEG enable"]
#[inline(always)]
pub const fn jpegen(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "JPEG enable"]
#[inline(always)]
pub fn set_jpegen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "AES module clock enable"]
#[inline(always)]
pub const fn aesen(&self) -> bool {
let val = (self.0 >> 4usize) & 0x01;
val != 0
}
#[doc = "AES module clock enable"]
#[inline(always)]
pub fn set_aesen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
}
#[doc = "Cryptographic modules clock enable"]
#[inline(always)]
pub const fn crypen(&self) -> bool {
let val = (self.0 >> 4usize) & 0x01;
val != 0
}
#[doc = "Cryptographic modules clock enable"]
#[inline(always)]
pub fn set_crypen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
}
#[doc = "Hash modules clock enable"]
#[inline(always)]
pub const fn hashen(&self) -> bool {
let val = (self.0 >> 5usize) & 0x01;
val != 0
}
#[doc = "Hash modules clock enable"]
#[inline(always)]
pub fn set_hashen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
}
#[doc = "Random number generator clock enable"]
#[inline(always)]
pub const fn rngen(&self) -> bool {
let val = (self.0 >> 6usize) & 0x01;
val != 0
}
#[doc = "Random number generator clock enable"]
#[inline(always)]
pub fn set_rngen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 6usize)) | (((val as u32) & 0x01) << 6usize);
}
#[doc = "USB OTG FS clock enable"]
#[inline(always)]
pub const fn usb_otg_fsen(&self) -> bool {
let val = (self.0 >> 7usize) & 0x01;
val != 0
}
#[doc = "USB OTG FS clock enable"]
#[inline(always)]
pub fn set_usb_otg_fsen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 7usize)) | (((val as u32) & 0x01) << 7usize);
}
}
impl Default for Ahb2enr {
#[inline(always)]
fn default() -> Ahb2enr {
Ahb2enr(0)
}
}
impl core::fmt::Debug for Ahb2enr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Ahb2enr")
.field("dcmien", &self.dcmien())
.field("jpegen", &self.jpegen())
.field("aesen", &self.aesen())
.field("crypen", &self.crypen())
.field("hashen", &self.hashen())
.field("rngen", &self.rngen())
.field("usb_otg_fsen", &self.usb_otg_fsen())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Ahb2enr {
fn format(&self, f: defmt::Formatter) {
defmt :: write ! (f , "Ahb2enr {{ dcmien: {=bool:?}, jpegen: {=bool:?}, aesen: {=bool:?}, crypen: {=bool:?}, hashen: {=bool:?}, rngen: {=bool:?}, usb_otg_fsen: {=bool:?} }}" , self . dcmien () , self . jpegen () , self . aesen () , self . crypen () , self . hashen () , self . rngen () , self . usb_otg_fsen ())
}
}
#[doc = "AHB2 peripheral clock enable in low power mode register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ahb2lpenr(pub u32);
impl Ahb2lpenr {
#[doc = "Camera interface enable during Sleep mode"]
#[inline(always)]
pub const fn dcmilpen(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Camera interface enable during Sleep mode"]
#[inline(always)]
pub fn set_dcmilpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "JPEG module enabled during Sleep mode"]
#[inline(always)]
pub const fn jpeglpen(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "JPEG module enabled during Sleep mode"]
#[inline(always)]
pub fn set_jpeglpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "AES module clock enable during Sleep mode"]
#[inline(always)]
pub const fn aeslpen(&self) -> bool {
let val = (self.0 >> 4usize) & 0x01;
val != 0
}
#[doc = "AES module clock enable during Sleep mode"]
#[inline(always)]
pub fn set_aeslpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
}
#[doc = "Cryptography modules clock enable during Sleep mode"]
#[inline(always)]
pub const fn cryplpen(&self) -> bool {
let val = (self.0 >> 4usize) & 0x01;
val != 0
}
#[doc = "Cryptography modules clock enable during Sleep mode"]
#[inline(always)]
pub fn set_cryplpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
}
#[doc = "Hash modules clock enable during Sleep mode"]
#[inline(always)]
pub const fn hashlpen(&self) -> bool {
let val = (self.0 >> 5usize) & 0x01;
val != 0
}
#[doc = "Hash modules clock enable during Sleep mode"]
#[inline(always)]
pub fn set_hashlpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
}
#[doc = "Random number generator clock enable during Sleep mode"]
#[inline(always)]
pub const fn rnglpen(&self) -> bool {
let val = (self.0 >> 6usize) & 0x01;
val != 0
}
#[doc = "Random number generator clock enable during Sleep mode"]
#[inline(always)]
pub fn set_rnglpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 6usize)) | (((val as u32) & 0x01) << 6usize);
}
#[doc = "USB OTG FS clock enable during Sleep mode"]
#[inline(always)]
pub const fn usb_otg_fslpen(&self) -> bool {
let val = (self.0 >> 7usize) & 0x01;
val != 0
}
#[doc = "USB OTG FS clock enable during Sleep mode"]
#[inline(always)]
pub fn set_usb_otg_fslpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 7usize)) | (((val as u32) & 0x01) << 7usize);
}
}
impl Default for Ahb2lpenr {
#[inline(always)]
fn default() -> Ahb2lpenr {
Ahb2lpenr(0)
}
}
impl core::fmt::Debug for Ahb2lpenr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Ahb2lpenr")
.field("dcmilpen", &self.dcmilpen())
.field("jpeglpen", &self.jpeglpen())
.field("aeslpen", &self.aeslpen())
.field("cryplpen", &self.cryplpen())
.field("hashlpen", &self.hashlpen())
.field("rnglpen", &self.rnglpen())
.field("usb_otg_fslpen", &self.usb_otg_fslpen())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Ahb2lpenr {
fn format(&self, f: defmt::Formatter) {
defmt :: write ! (f , "Ahb2lpenr {{ dcmilpen: {=bool:?}, jpeglpen: {=bool:?}, aeslpen: {=bool:?}, cryplpen: {=bool:?}, hashlpen: {=bool:?}, rnglpen: {=bool:?}, usb_otg_fslpen: {=bool:?} }}" , self . dcmilpen () , self . jpeglpen () , self . aeslpen () , self . cryplpen () , self . hashlpen () , self . rnglpen () , self . usb_otg_fslpen ())
}
}
#[doc = "AHB2 peripheral reset register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ahb2rstr(pub u32);
impl Ahb2rstr {
#[doc = "Camera interface reset"]
#[inline(always)]
pub const fn dcmirst(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Camera interface reset"]
#[inline(always)]
pub fn set_dcmirst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "AES module reset"]
#[inline(always)]
pub const fn aesrst(&self) -> bool {
let val = (self.0 >> 4usize) & 0x01;
val != 0
}
#[doc = "AES module reset"]
#[inline(always)]
pub fn set_aesrst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
}
#[doc = "Cryptographic module reset"]
#[inline(always)]
pub const fn cryprst(&self) -> bool {
let val = (self.0 >> 4usize) & 0x01;
val != 0
}
#[doc = "Cryptographic module reset"]
#[inline(always)]
pub fn set_cryprst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
}
#[doc = "Hash module reset"]
#[inline(always)]
pub const fn hsahrst(&self) -> bool {
let val = (self.0 >> 5usize) & 0x01;
val != 0
}
#[doc = "Hash module reset"]
#[inline(always)]
pub fn set_hsahrst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
}
#[doc = "Random number generator module reset"]
#[inline(always)]
pub const fn rngrst(&self) -> bool {
let val = (self.0 >> 6usize) & 0x01;
val != 0
}
#[doc = "Random number generator module reset"]
#[inline(always)]
pub fn set_rngrst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 6usize)) | (((val as u32) & 0x01) << 6usize);
}
#[doc = "USB OTG FS module reset"]
#[inline(always)]
pub const fn usb_otg_fsrst(&self) -> bool {
let val = (self.0 >> 7usize) & 0x01;
val != 0
}
#[doc = "USB OTG FS module reset"]
#[inline(always)]
pub fn set_usb_otg_fsrst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 7usize)) | (((val as u32) & 0x01) << 7usize);
}
}
impl Default for Ahb2rstr {
#[inline(always)]
fn default() -> Ahb2rstr {
Ahb2rstr(0)
}
}
impl core::fmt::Debug for Ahb2rstr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Ahb2rstr")
.field("dcmirst", &self.dcmirst())
.field("aesrst", &self.aesrst())
.field("cryprst", &self.cryprst())
.field("hsahrst", &self.hsahrst())
.field("rngrst", &self.rngrst())
.field("usb_otg_fsrst", &self.usb_otg_fsrst())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Ahb2rstr {
fn format(&self, f: defmt::Formatter) {
defmt :: write ! (f , "Ahb2rstr {{ dcmirst: {=bool:?}, aesrst: {=bool:?}, cryprst: {=bool:?}, hsahrst: {=bool:?}, rngrst: {=bool:?}, usb_otg_fsrst: {=bool:?} }}" , self . dcmirst () , self . aesrst () , self . cryprst () , self . hsahrst () , self . rngrst () , self . usb_otg_fsrst ())
}
}
#[doc = "AHB3 peripheral clock enable register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ahb3enr(pub u32);
impl Ahb3enr {
#[doc = "Flexible memory controller module clock enable"]
#[inline(always)]
pub const fn fmcen(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Flexible memory controller module clock enable"]
#[inline(always)]
pub fn set_fmcen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "Quad SPI memory controller clock enable"]
#[inline(always)]
pub const fn quadspien(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "Quad SPI memory controller clock enable"]
#[inline(always)]
pub fn set_quadspien(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
}
impl Default for Ahb3enr {
#[inline(always)]
fn default() -> Ahb3enr {
Ahb3enr(0)
}
}
impl core::fmt::Debug for Ahb3enr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Ahb3enr")
.field("fmcen", &self.fmcen())
.field("quadspien", &self.quadspien())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Ahb3enr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Ahb3enr {{ fmcen: {=bool:?}, quadspien: {=bool:?} }}",
self.fmcen(),
self.quadspien()
)
}
}
#[doc = "AHB3 peripheral clock enable in low power mode register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ahb3lpenr(pub u32);
impl Ahb3lpenr {
#[doc = "Flexible memory controller module clock enable during Sleep mode"]
#[inline(always)]
pub const fn fmclpen(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Flexible memory controller module clock enable during Sleep mode"]
#[inline(always)]
pub fn set_fmclpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "Quand SPI memory controller clock enable during Sleep mode"]
#[inline(always)]
pub const fn quadspilpen(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "Quand SPI memory controller clock enable during Sleep mode"]
#[inline(always)]
pub fn set_quadspilpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
}
impl Default for Ahb3lpenr {
#[inline(always)]
fn default() -> Ahb3lpenr {
Ahb3lpenr(0)
}
}
impl core::fmt::Debug for Ahb3lpenr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Ahb3lpenr")
.field("fmclpen", &self.fmclpen())
.field("quadspilpen", &self.quadspilpen())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Ahb3lpenr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Ahb3lpenr {{ fmclpen: {=bool:?}, quadspilpen: {=bool:?} }}",
self.fmclpen(),
self.quadspilpen()
)
}
}
#[doc = "AHB3 peripheral reset register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ahb3rstr(pub u32);
impl Ahb3rstr {
#[doc = "Flexible memory controller module reset"]
#[inline(always)]
pub const fn fmcrst(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Flexible memory controller module reset"]
#[inline(always)]
pub fn set_fmcrst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "Quad SPI memory controller reset"]
#[inline(always)]
pub const fn quadspirst(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "Quad SPI memory controller reset"]
#[inline(always)]
pub fn set_quadspirst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
}
impl Default for Ahb3rstr {
#[inline(always)]
fn default() -> Ahb3rstr {
Ahb3rstr(0)
}
}
impl core::fmt::Debug for Ahb3rstr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Ahb3rstr")
.field("fmcrst", &self.fmcrst())
.field("quadspirst", &self.quadspirst())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Ahb3rstr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Ahb3rstr {{ fmcrst: {=bool:?}, quadspirst: {=bool:?} }}",
self.fmcrst(),
self.quadspirst()
)
}
}
#[doc = "APB1 peripheral clock enable register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Apb1enr(pub u32);
impl Apb1enr {
#[doc = "TIM2 clock enable"]
#[inline(always)]
pub const fn tim2en(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "TIM2 clock enable"]
#[inline(always)]
pub fn set_tim2en(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "TIM3 clock enable"]
#[inline(always)]
pub const fn tim3en(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "TIM3 clock enable"]
#[inline(always)]
pub fn set_tim3en(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "TIM4 clock enable"]
#[inline(always)]
pub const fn tim4en(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[doc = "TIM4 clock enable"]
#[inline(always)]
pub fn set_tim4en(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
#[doc = "TIM5 clock enable"]
#[inline(always)]
pub const fn tim5en(&self) -> bool {
let val = (self.0 >> 3usize) & 0x01;
val != 0
}
#[doc = "TIM5 clock enable"]
#[inline(always)]
pub fn set_tim5en(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
}
#[doc = "TIM6 clock enable"]
#[inline(always)]
pub const fn tim6en(&self) -> bool {
let val = (self.0 >> 4usize) & 0x01;
val != 0
}
#[doc = "TIM6 clock enable"]
#[inline(always)]
pub fn set_tim6en(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
}
#[doc = "TIM7 clock enable"]
#[inline(always)]
pub const fn tim7en(&self) -> bool {
let val = (self.0 >> 5usize) & 0x01;
val != 0
}
#[doc = "TIM7 clock enable"]
#[inline(always)]
pub fn set_tim7en(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
}
#[doc = "TIM12 clock enable"]
#[inline(always)]
pub const fn tim12en(&self) -> bool {
let val = (self.0 >> 6usize) & 0x01;
val != 0
}
#[doc = "TIM12 clock enable"]
#[inline(always)]
pub fn set_tim12en(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 6usize)) | (((val as u32) & 0x01) << 6usize);
}
#[doc = "TIM13 clock enable"]
#[inline(always)]
pub const fn tim13en(&self) -> bool {
let val = (self.0 >> 7usize) & 0x01;
val != 0
}
#[doc = "TIM13 clock enable"]
#[inline(always)]
pub fn set_tim13en(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 7usize)) | (((val as u32) & 0x01) << 7usize);
}
#[doc = "TIM14 clock enable"]
#[inline(always)]
pub const fn tim14en(&self) -> bool {
let val = (self.0 >> 8usize) & 0x01;
val != 0
}
#[doc = "TIM14 clock enable"]
#[inline(always)]
pub fn set_tim14en(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 8usize)) | (((val as u32) & 0x01) << 8usize);
}
#[doc = "Low power timer 1 clock enable"]
#[inline(always)]
pub const fn lptim1en(&self) -> bool {
let val = (self.0 >> 9usize) & 0x01;
val != 0
}
#[doc = "Low power timer 1 clock enable"]
#[inline(always)]
pub fn set_lptim1en(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 9usize)) | (((val as u32) & 0x01) << 9usize);
}
#[doc = "RTCAPB clock enable"]
#[inline(always)]
pub const fn rtcen(&self) -> bool {
let val = (self.0 >> 10usize) & 0x01;
val != 0
}
#[doc = "RTCAPB clock enable"]
#[inline(always)]
pub fn set_rtcen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 10usize)) | (((val as u32) & 0x01) << 10usize);
}
#[doc = "Window watchdog clock enable"]
#[inline(always)]
pub const fn wwdgen(&self) -> bool {
let val = (self.0 >> 11usize) & 0x01;
val != 0
}
#[doc = "Window watchdog clock enable"]
#[inline(always)]
pub fn set_wwdgen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 11usize)) | (((val as u32) & 0x01) << 11usize);
}
#[doc = "CAN 3 enable"]
#[inline(always)]
pub const fn can3en(&self) -> bool {
let val = (self.0 >> 13usize) & 0x01;
val != 0
}
#[doc = "CAN 3 enable"]
#[inline(always)]
pub fn set_can3en(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 13usize)) | (((val as u32) & 0x01) << 13usize);
}
#[doc = "SPI2 clock enable"]
#[inline(always)]
pub const fn spi2en(&self) -> bool {
let val = (self.0 >> 14usize) & 0x01;
val != 0
}
#[doc = "SPI2 clock enable"]
#[inline(always)]
pub fn set_spi2en(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 14usize)) | (((val as u32) & 0x01) << 14usize);
}
#[doc = "SPI3 clock enable"]
#[inline(always)]
pub const fn spi3en(&self) -> bool {
let val = (self.0 >> 15usize) & 0x01;
val != 0
}
#[doc = "SPI3 clock enable"]
#[inline(always)]
pub fn set_spi3en(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 15usize)) | (((val as u32) & 0x01) << 15usize);
}
#[doc = "SPDIF-RX clock enable"]
#[inline(always)]
pub const fn spdifrxen(&self) -> bool {
let val = (self.0 >> 16usize) & 0x01;
val != 0
}
#[doc = "SPDIF-RX clock enable"]
#[inline(always)]
pub fn set_spdifrxen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 16usize)) | (((val as u32) & 0x01) << 16usize);
}
#[doc = "USART 2 clock enable"]
#[inline(always)]
pub const fn usart2en(&self) -> bool {
let val = (self.0 >> 17usize) & 0x01;
val != 0
}
#[doc = "USART 2 clock enable"]
#[inline(always)]
pub fn set_usart2en(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 17usize)) | (((val as u32) & 0x01) << 17usize);
}
#[doc = "USART3 clock enable"]
#[inline(always)]
pub const fn usart3en(&self) -> bool {
let val = (self.0 >> 18usize) & 0x01;
val != 0
}
#[doc = "USART3 clock enable"]
#[inline(always)]
pub fn set_usart3en(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 18usize)) | (((val as u32) & 0x01) << 18usize);
}
#[doc = "UART4 clock enable"]
#[inline(always)]
pub const fn uart4en(&self) -> bool {
let val = (self.0 >> 19usize) & 0x01;
val != 0
}
#[doc = "UART4 clock enable"]
#[inline(always)]
pub fn set_uart4en(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 19usize)) | (((val as u32) & 0x01) << 19usize);
}
#[doc = "UART5 clock enable"]
#[inline(always)]
pub const fn uart5en(&self) -> bool {
let val = (self.0 >> 20usize) & 0x01;
val != 0
}
#[doc = "UART5 clock enable"]
#[inline(always)]
pub fn set_uart5en(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 20usize)) | (((val as u32) & 0x01) << 20usize);
}
#[doc = "I2C1 clock enable"]
#[inline(always)]
pub const fn i2c1en(&self) -> bool {
let val = (self.0 >> 21usize) & 0x01;
val != 0
}
#[doc = "I2C1 clock enable"]
#[inline(always)]
pub fn set_i2c1en(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 21usize)) | (((val as u32) & 0x01) << 21usize);
}
#[doc = "I2C2 clock enable"]
#[inline(always)]
pub const fn i2c2en(&self) -> bool {
let val = (self.0 >> 22usize) & 0x01;
val != 0
}
#[doc = "I2C2 clock enable"]
#[inline(always)]
pub fn set_i2c2en(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 22usize)) | (((val as u32) & 0x01) << 22usize);
}
#[doc = "I2C3 clock enable"]
#[inline(always)]
pub const fn i2c3en(&self) -> bool {
let val = (self.0 >> 23usize) & 0x01;
val != 0
}
#[doc = "I2C3 clock enable"]
#[inline(always)]
pub fn set_i2c3en(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 23usize)) | (((val as u32) & 0x01) << 23usize);
}
#[doc = "I2C4 clock enable"]
#[inline(always)]
pub const fn i2c4en(&self) -> bool {
let val = (self.0 >> 24usize) & 0x01;
val != 0
}
#[doc = "I2C4 clock enable"]
#[inline(always)]
pub fn set_i2c4en(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 24usize)) | (((val as u32) & 0x01) << 24usize);
}
#[doc = "CAN 1 clock enable"]
#[inline(always)]
pub const fn can1en(&self) -> bool {
let val = (self.0 >> 25usize) & 0x01;
val != 0
}
#[doc = "CAN 1 clock enable"]
#[inline(always)]
pub fn set_can1en(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 25usize)) | (((val as u32) & 0x01) << 25usize);
}
#[doc = "CAN 2 clock enable"]
#[inline(always)]
pub const fn can2en(&self) -> bool {
let val = (self.0 >> 26usize) & 0x01;
val != 0
}
#[doc = "CAN 2 clock enable"]
#[inline(always)]
pub fn set_can2en(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 26usize)) | (((val as u32) & 0x01) << 26usize);
}
#[doc = "HDMI-CEN clock enable"]
#[inline(always)]
pub const fn cecen(&self) -> bool {
let val = (self.0 >> 27usize) & 0x01;
val != 0
}
#[doc = "HDMI-CEN clock enable"]
#[inline(always)]
pub fn set_cecen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 27usize)) | (((val as u32) & 0x01) << 27usize);
}
#[doc = "Power interface clock enable"]
#[inline(always)]
pub const fn pwren(&self) -> bool {
let val = (self.0 >> 28usize) & 0x01;
val != 0
}
#[doc = "Power interface clock enable"]
#[inline(always)]
pub fn set_pwren(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 28usize)) | (((val as u32) & 0x01) << 28usize);
}
#[doc = "DAC interface clock enable"]
#[inline(always)]
pub const fn dacen(&self) -> bool {
let val = (self.0 >> 29usize) & 0x01;
val != 0
}
#[doc = "DAC interface clock enable"]
#[inline(always)]
pub fn set_dacen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 29usize)) | (((val as u32) & 0x01) << 29usize);
}
#[doc = "UART7 clock enable"]
#[inline(always)]
pub const fn uart7en(&self) -> bool {
let val = (self.0 >> 30usize) & 0x01;
val != 0
}
#[doc = "UART7 clock enable"]
#[inline(always)]
pub fn set_uart7en(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 30usize)) | (((val as u32) & 0x01) << 30usize);
}
#[doc = "UART8 clock enable"]
#[inline(always)]
pub const fn uart8en(&self) -> bool {
let val = (self.0 >> 31usize) & 0x01;
val != 0
}
#[doc = "UART8 clock enable"]
#[inline(always)]
pub fn set_uart8en(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 31usize)) | (((val as u32) & 0x01) << 31usize);
}
}
impl Default for Apb1enr {
#[inline(always)]
fn default() -> Apb1enr {
Apb1enr(0)
}
}
impl core::fmt::Debug for Apb1enr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Apb1enr")
.field("tim2en", &self.tim2en())
.field("tim3en", &self.tim3en())
.field("tim4en", &self.tim4en())
.field("tim5en", &self.tim5en())
.field("tim6en", &self.tim6en())
.field("tim7en", &self.tim7en())
.field("tim12en", &self.tim12en())
.field("tim13en", &self.tim13en())
.field("tim14en", &self.tim14en())
.field("lptim1en", &self.lptim1en())
.field("rtcen", &self.rtcen())
.field("wwdgen", &self.wwdgen())
.field("can3en", &self.can3en())
.field("spi2en", &self.spi2en())
.field("spi3en", &self.spi3en())
.field("spdifrxen", &self.spdifrxen())
.field("usart2en", &self.usart2en())
.field("usart3en", &self.usart3en())
.field("uart4en", &self.uart4en())
.field("uart5en", &self.uart5en())
.field("i2c1en", &self.i2c1en())
.field("i2c2en", &self.i2c2en())
.field("i2c3en", &self.i2c3en())
.field("i2c4en", &self.i2c4en())
.field("can1en", &self.can1en())
.field("can2en", &self.can2en())
.field("cecen", &self.cecen())
.field("pwren", &self.pwren())
.field("dacen", &self.dacen())
.field("uart7en", &self.uart7en())
.field("uart8en", &self.uart8en())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Apb1enr {
fn format(&self, f: defmt::Formatter) {
defmt :: write ! (f , "Apb1enr {{ tim2en: {=bool:?}, tim3en: {=bool:?}, tim4en: {=bool:?}, tim5en: {=bool:?}, tim6en: {=bool:?}, tim7en: {=bool:?}, tim12en: {=bool:?}, tim13en: {=bool:?}, tim14en: {=bool:?}, lptim1en: {=bool:?}, rtcen: {=bool:?}, wwdgen: {=bool:?}, can3en: {=bool:?}, spi2en: {=bool:?}, spi3en: {=bool:?}, spdifrxen: {=bool:?}, usart2en: {=bool:?}, usart3en: {=bool:?}, uart4en: {=bool:?}, uart5en: {=bool:?}, i2c1en: {=bool:?}, i2c2en: {=bool:?}, i2c3en: {=bool:?}, i2c4en: {=bool:?}, can1en: {=bool:?}, can2en: {=bool:?}, cecen: {=bool:?}, pwren: {=bool:?}, dacen: {=bool:?}, uart7en: {=bool:?}, uart8en: {=bool:?} }}" , self . tim2en () , self . tim3en () , self . tim4en () , self . tim5en () , self . tim6en () , self . tim7en () , self . tim12en () , self . tim13en () , self . tim14en () , self . lptim1en () , self . rtcen () , self . wwdgen () , self . can3en () , self . spi2en () , self . spi3en () , self . spdifrxen () , self . usart2en () , self . usart3en () , self . uart4en () , self . uart5en () , self . i2c1en () , self . i2c2en () , self . i2c3en () , self . i2c4en () , self . can1en () , self . can2en () , self . cecen () , self . pwren () , self . dacen () , self . uart7en () , self . uart8en ())
}
}
#[doc = "APB1 peripheral clock enable in low power mode register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Apb1lpenr(pub u32);
impl Apb1lpenr {
#[doc = "TIM2 clock enable during Sleep mode"]
#[inline(always)]
pub const fn tim2lpen(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "TIM2 clock enable during Sleep mode"]
#[inline(always)]
pub fn set_tim2lpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "TIM3 clock enable during Sleep mode"]
#[inline(always)]
pub const fn tim3lpen(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "TIM3 clock enable during Sleep mode"]
#[inline(always)]
pub fn set_tim3lpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "TIM4 clock enable during Sleep mode"]
#[inline(always)]
pub const fn tim4lpen(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[doc = "TIM4 clock enable during Sleep mode"]
#[inline(always)]
pub fn set_tim4lpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
#[doc = "TIM5 clock enable during Sleep mode"]
#[inline(always)]
pub const fn tim5lpen(&self) -> bool {
let val = (self.0 >> 3usize) & 0x01;
val != 0
}
#[doc = "TIM5 clock enable during Sleep mode"]
#[inline(always)]
pub fn set_tim5lpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
}
#[doc = "TIM6 clock enable during Sleep mode"]
#[inline(always)]
pub const fn tim6lpen(&self) -> bool {
let val = (self.0 >> 4usize) & 0x01;
val != 0
}
#[doc = "TIM6 clock enable during Sleep mode"]
#[inline(always)]
pub fn set_tim6lpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
}
#[doc = "TIM7 clock enable during Sleep mode"]
#[inline(always)]
pub const fn tim7lpen(&self) -> bool {
let val = (self.0 >> 5usize) & 0x01;
val != 0
}
#[doc = "TIM7 clock enable during Sleep mode"]
#[inline(always)]
pub fn set_tim7lpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
}
#[doc = "TIM12 clock enable during Sleep mode"]
#[inline(always)]
pub const fn tim12lpen(&self) -> bool {
let val = (self.0 >> 6usize) & 0x01;
val != 0
}
#[doc = "TIM12 clock enable during Sleep mode"]
#[inline(always)]
pub fn set_tim12lpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 6usize)) | (((val as u32) & 0x01) << 6usize);
}
#[doc = "TIM13 clock enable during Sleep mode"]
#[inline(always)]
pub const fn tim13lpen(&self) -> bool {
let val = (self.0 >> 7usize) & 0x01;
val != 0
}
#[doc = "TIM13 clock enable during Sleep mode"]
#[inline(always)]
pub fn set_tim13lpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 7usize)) | (((val as u32) & 0x01) << 7usize);
}
#[doc = "TIM14 clock enable during Sleep mode"]
#[inline(always)]
pub const fn tim14lpen(&self) -> bool {
let val = (self.0 >> 8usize) & 0x01;
val != 0
}
#[doc = "TIM14 clock enable during Sleep mode"]
#[inline(always)]
pub fn set_tim14lpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 8usize)) | (((val as u32) & 0x01) << 8usize);
}
#[doc = "low power timer 1 clock enable during Sleep mode"]
#[inline(always)]
pub const fn lptim1lpen(&self) -> bool {
let val = (self.0 >> 9usize) & 0x01;
val != 0
}
#[doc = "low power timer 1 clock enable during Sleep mode"]
#[inline(always)]
pub fn set_lptim1lpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 9usize)) | (((val as u32) & 0x01) << 9usize);
}
#[doc = "RTCAPB clock enable during Sleep mode"]
#[inline(always)]
pub const fn rtclpen(&self) -> bool {
let val = (self.0 >> 10usize) & 0x01;
val != 0
}
#[doc = "RTCAPB clock enable during Sleep mode"]
#[inline(always)]
pub fn set_rtclpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 10usize)) | (((val as u32) & 0x01) << 10usize);
}
#[doc = "Window watchdog clock enable during Sleep mode"]
#[inline(always)]
pub const fn wwdglpen(&self) -> bool {
let val = (self.0 >> 11usize) & 0x01;
val != 0
}
#[doc = "Window watchdog clock enable during Sleep mode"]
#[inline(always)]
pub fn set_wwdglpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 11usize)) | (((val as u32) & 0x01) << 11usize);
}
#[doc = "CAN 3 clock enable during Sleep mode"]
#[inline(always)]
pub const fn can3lpen(&self) -> bool {
let val = (self.0 >> 13usize) & 0x01;
val != 0
}
#[doc = "CAN 3 clock enable during Sleep mode"]
#[inline(always)]
pub fn set_can3lpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 13usize)) | (((val as u32) & 0x01) << 13usize);
}
#[doc = "SPI2 clock enable during Sleep mode"]
#[inline(always)]
pub const fn spi2lpen(&self) -> bool {
let val = (self.0 >> 14usize) & 0x01;
val != 0
}
#[doc = "SPI2 clock enable during Sleep mode"]
#[inline(always)]
pub fn set_spi2lpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 14usize)) | (((val as u32) & 0x01) << 14usize);
}
#[doc = "SPI3 clock enable during Sleep mode"]
#[inline(always)]
pub const fn spi3lpen(&self) -> bool {
let val = (self.0 >> 15usize) & 0x01;
val != 0
}
#[doc = "SPI3 clock enable during Sleep mode"]
#[inline(always)]
pub fn set_spi3lpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 15usize)) | (((val as u32) & 0x01) << 15usize);
}
#[doc = "SPDIF-RX clock enable during sleep mode"]
#[inline(always)]
pub const fn spdifrxlpen(&self) -> bool {
let val = (self.0 >> 16usize) & 0x01;
val != 0
}
#[doc = "SPDIF-RX clock enable during sleep mode"]
#[inline(always)]
pub fn set_spdifrxlpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 16usize)) | (((val as u32) & 0x01) << 16usize);
}
#[doc = "USART2 clock enable during Sleep mode"]
#[inline(always)]
pub const fn usart2lpen(&self) -> bool {
let val = (self.0 >> 17usize) & 0x01;
val != 0
}
#[doc = "USART2 clock enable during Sleep mode"]
#[inline(always)]
pub fn set_usart2lpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 17usize)) | (((val as u32) & 0x01) << 17usize);
}
#[doc = "USART3 clock enable during Sleep mode"]
#[inline(always)]
pub const fn usart3lpen(&self) -> bool {
let val = (self.0 >> 18usize) & 0x01;
val != 0
}
#[doc = "USART3 clock enable during Sleep mode"]
#[inline(always)]
pub fn set_usart3lpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 18usize)) | (((val as u32) & 0x01) << 18usize);
}
#[doc = "UART4 clock enable during Sleep mode"]
#[inline(always)]
pub const fn uart4lpen(&self) -> bool {
let val = (self.0 >> 19usize) & 0x01;
val != 0
}
#[doc = "UART4 clock enable during Sleep mode"]
#[inline(always)]
pub fn set_uart4lpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 19usize)) | (((val as u32) & 0x01) << 19usize);
}
#[doc = "UART5 clock enable during Sleep mode"]
#[inline(always)]
pub const fn uart5lpen(&self) -> bool {
let val = (self.0 >> 20usize) & 0x01;
val != 0
}
#[doc = "UART5 clock enable during Sleep mode"]
#[inline(always)]
pub fn set_uart5lpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 20usize)) | (((val as u32) & 0x01) << 20usize);
}
#[doc = "I2C1 clock enable during Sleep mode"]
#[inline(always)]
pub const fn i2c1lpen(&self) -> bool {
let val = (self.0 >> 21usize) & 0x01;
val != 0
}
#[doc = "I2C1 clock enable during Sleep mode"]
#[inline(always)]
pub fn set_i2c1lpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 21usize)) | (((val as u32) & 0x01) << 21usize);
}
#[doc = "I2C2 clock enable during Sleep mode"]
#[inline(always)]
pub const fn i2c2lpen(&self) -> bool {
let val = (self.0 >> 22usize) & 0x01;
val != 0
}
#[doc = "I2C2 clock enable during Sleep mode"]
#[inline(always)]
pub fn set_i2c2lpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 22usize)) | (((val as u32) & 0x01) << 22usize);
}
#[doc = "I2C3 clock enable during Sleep mode"]
#[inline(always)]
pub const fn i2c3lpen(&self) -> bool {
let val = (self.0 >> 23usize) & 0x01;
val != 0
}
#[doc = "I2C3 clock enable during Sleep mode"]
#[inline(always)]
pub fn set_i2c3lpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 23usize)) | (((val as u32) & 0x01) << 23usize);
}
#[doc = "I2C4 clock enable during Sleep mode"]
#[inline(always)]
pub const fn i2c4lpen(&self) -> bool {
let val = (self.0 >> 24usize) & 0x01;
val != 0
}
#[doc = "I2C4 clock enable during Sleep mode"]
#[inline(always)]
pub fn set_i2c4lpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 24usize)) | (((val as u32) & 0x01) << 24usize);
}
#[doc = "CAN 1 clock enable during Sleep mode"]
#[inline(always)]
pub const fn can1lpen(&self) -> bool {
let val = (self.0 >> 25usize) & 0x01;
val != 0
}
#[doc = "CAN 1 clock enable during Sleep mode"]
#[inline(always)]
pub fn set_can1lpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 25usize)) | (((val as u32) & 0x01) << 25usize);
}
#[doc = "CAN 2 clock enable during Sleep mode"]
#[inline(always)]
pub const fn can2lpen(&self) -> bool {
let val = (self.0 >> 26usize) & 0x01;
val != 0
}
#[doc = "CAN 2 clock enable during Sleep mode"]
#[inline(always)]
pub fn set_can2lpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 26usize)) | (((val as u32) & 0x01) << 26usize);
}
#[doc = "HDMI-CEN clock enable during Sleep mode"]
#[inline(always)]
pub const fn ceclpen(&self) -> bool {
let val = (self.0 >> 27usize) & 0x01;
val != 0
}
#[doc = "HDMI-CEN clock enable during Sleep mode"]
#[inline(always)]
pub fn set_ceclpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 27usize)) | (((val as u32) & 0x01) << 27usize);
}
#[doc = "Power interface clock enable during Sleep mode"]
#[inline(always)]
pub const fn pwrlpen(&self) -> bool {
let val = (self.0 >> 28usize) & 0x01;
val != 0
}
#[doc = "Power interface clock enable during Sleep mode"]
#[inline(always)]
pub fn set_pwrlpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 28usize)) | (((val as u32) & 0x01) << 28usize);
}
#[doc = "DAC interface clock enable during Sleep mode"]
#[inline(always)]
pub const fn daclpen(&self) -> bool {
let val = (self.0 >> 29usize) & 0x01;
val != 0
}
#[doc = "DAC interface clock enable during Sleep mode"]
#[inline(always)]
pub fn set_daclpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 29usize)) | (((val as u32) & 0x01) << 29usize);
}
#[doc = "UART7 clock enable during Sleep mode"]
#[inline(always)]
pub const fn uart7lpen(&self) -> bool {
let val = (self.0 >> 30usize) & 0x01;
val != 0
}
#[doc = "UART7 clock enable during Sleep mode"]
#[inline(always)]
pub fn set_uart7lpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 30usize)) | (((val as u32) & 0x01) << 30usize);
}
#[doc = "UART8 clock enable during Sleep mode"]
#[inline(always)]
pub const fn uart8lpen(&self) -> bool {
let val = (self.0 >> 31usize) & 0x01;
val != 0
}
#[doc = "UART8 clock enable during Sleep mode"]
#[inline(always)]
pub fn set_uart8lpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 31usize)) | (((val as u32) & 0x01) << 31usize);
}
}
impl Default for Apb1lpenr {
#[inline(always)]
fn default() -> Apb1lpenr {
Apb1lpenr(0)
}
}
impl core::fmt::Debug for Apb1lpenr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Apb1lpenr")
.field("tim2lpen", &self.tim2lpen())
.field("tim3lpen", &self.tim3lpen())
.field("tim4lpen", &self.tim4lpen())
.field("tim5lpen", &self.tim5lpen())
.field("tim6lpen", &self.tim6lpen())
.field("tim7lpen", &self.tim7lpen())
.field("tim12lpen", &self.tim12lpen())
.field("tim13lpen", &self.tim13lpen())
.field("tim14lpen", &self.tim14lpen())
.field("lptim1lpen", &self.lptim1lpen())
.field("rtclpen", &self.rtclpen())
.field("wwdglpen", &self.wwdglpen())
.field("can3lpen", &self.can3lpen())
.field("spi2lpen", &self.spi2lpen())
.field("spi3lpen", &self.spi3lpen())
.field("spdifrxlpen", &self.spdifrxlpen())
.field("usart2lpen", &self.usart2lpen())
.field("usart3lpen", &self.usart3lpen())
.field("uart4lpen", &self.uart4lpen())
.field("uart5lpen", &self.uart5lpen())
.field("i2c1lpen", &self.i2c1lpen())
.field("i2c2lpen", &self.i2c2lpen())
.field("i2c3lpen", &self.i2c3lpen())
.field("i2c4lpen", &self.i2c4lpen())
.field("can1lpen", &self.can1lpen())
.field("can2lpen", &self.can2lpen())
.field("ceclpen", &self.ceclpen())
.field("pwrlpen", &self.pwrlpen())
.field("daclpen", &self.daclpen())
.field("uart7lpen", &self.uart7lpen())
.field("uart8lpen", &self.uart8lpen())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Apb1lpenr {
fn format(&self, f: defmt::Formatter) {
defmt :: write ! (f , "Apb1lpenr {{ tim2lpen: {=bool:?}, tim3lpen: {=bool:?}, tim4lpen: {=bool:?}, tim5lpen: {=bool:?}, tim6lpen: {=bool:?}, tim7lpen: {=bool:?}, tim12lpen: {=bool:?}, tim13lpen: {=bool:?}, tim14lpen: {=bool:?}, lptim1lpen: {=bool:?}, rtclpen: {=bool:?}, wwdglpen: {=bool:?}, can3lpen: {=bool:?}, spi2lpen: {=bool:?}, spi3lpen: {=bool:?}, spdifrxlpen: {=bool:?}, usart2lpen: {=bool:?}, usart3lpen: {=bool:?}, uart4lpen: {=bool:?}, uart5lpen: {=bool:?}, i2c1lpen: {=bool:?}, i2c2lpen: {=bool:?}, i2c3lpen: {=bool:?}, i2c4lpen: {=bool:?}, can1lpen: {=bool:?}, can2lpen: {=bool:?}, ceclpen: {=bool:?}, pwrlpen: {=bool:?}, daclpen: {=bool:?}, uart7lpen: {=bool:?}, uart8lpen: {=bool:?} }}" , self . tim2lpen () , self . tim3lpen () , self . tim4lpen () , self . tim5lpen () , self . tim6lpen () , self . tim7lpen () , self . tim12lpen () , self . tim13lpen () , self . tim14lpen () , self . lptim1lpen () , self . rtclpen () , self . wwdglpen () , self . can3lpen () , self . spi2lpen () , self . spi3lpen () , self . spdifrxlpen () , self . usart2lpen () , self . usart3lpen () , self . uart4lpen () , self . uart5lpen () , self . i2c1lpen () , self . i2c2lpen () , self . i2c3lpen () , self . i2c4lpen () , self . can1lpen () , self . can2lpen () , self . ceclpen () , self . pwrlpen () , self . daclpen () , self . uart7lpen () , self . uart8lpen ())
}
}
#[doc = "APB1 peripheral reset register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Apb1rstr(pub u32);
impl Apb1rstr {
#[doc = "TIM2 reset"]
#[inline(always)]
pub const fn tim2rst(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "TIM2 reset"]
#[inline(always)]
pub fn set_tim2rst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "TIM3 reset"]
#[inline(always)]
pub const fn tim3rst(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "TIM3 reset"]
#[inline(always)]
pub fn set_tim3rst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "TIM4 reset"]
#[inline(always)]
pub const fn tim4rst(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[doc = "TIM4 reset"]
#[inline(always)]
pub fn set_tim4rst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
#[doc = "TIM5 reset"]
#[inline(always)]
pub const fn tim5rst(&self) -> bool {
let val = (self.0 >> 3usize) & 0x01;
val != 0
}
#[doc = "TIM5 reset"]
#[inline(always)]
pub fn set_tim5rst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
}
#[doc = "TIM6 reset"]
#[inline(always)]
pub const fn tim6rst(&self) -> bool {
let val = (self.0 >> 4usize) & 0x01;
val != 0
}
#[doc = "TIM6 reset"]
#[inline(always)]
pub fn set_tim6rst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
}
#[doc = "TIM7 reset"]
#[inline(always)]
pub const fn tim7rst(&self) -> bool {
let val = (self.0 >> 5usize) & 0x01;
val != 0
}
#[doc = "TIM7 reset"]
#[inline(always)]
pub fn set_tim7rst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
}
#[doc = "TIM12 reset"]
#[inline(always)]
pub const fn tim12rst(&self) -> bool {
let val = (self.0 >> 6usize) & 0x01;
val != 0
}
#[doc = "TIM12 reset"]
#[inline(always)]
pub fn set_tim12rst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 6usize)) | (((val as u32) & 0x01) << 6usize);
}
#[doc = "TIM13 reset"]
#[inline(always)]
pub const fn tim13rst(&self) -> bool {
let val = (self.0 >> 7usize) & 0x01;
val != 0
}
#[doc = "TIM13 reset"]
#[inline(always)]
pub fn set_tim13rst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 7usize)) | (((val as u32) & 0x01) << 7usize);
}
#[doc = "TIM14 reset"]
#[inline(always)]
pub const fn tim14rst(&self) -> bool {
let val = (self.0 >> 8usize) & 0x01;
val != 0
}
#[doc = "TIM14 reset"]
#[inline(always)]
pub fn set_tim14rst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 8usize)) | (((val as u32) & 0x01) << 8usize);
}
#[doc = "Low power timer 1 reset"]
#[inline(always)]
pub const fn lptim1rst(&self) -> bool {
let val = (self.0 >> 9usize) & 0x01;
val != 0
}
#[doc = "Low power timer 1 reset"]
#[inline(always)]
pub fn set_lptim1rst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 9usize)) | (((val as u32) & 0x01) << 9usize);
}
#[doc = "Window watchdog reset"]
#[inline(always)]
pub const fn wwdgrst(&self) -> bool {
let val = (self.0 >> 11usize) & 0x01;
val != 0
}
#[doc = "Window watchdog reset"]
#[inline(always)]
pub fn set_wwdgrst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 11usize)) | (((val as u32) & 0x01) << 11usize);
}
#[doc = "CAN 3 reset"]
#[inline(always)]
pub const fn can3rst(&self) -> bool {
let val = (self.0 >> 13usize) & 0x01;
val != 0
}
#[doc = "CAN 3 reset"]
#[inline(always)]
pub fn set_can3rst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 13usize)) | (((val as u32) & 0x01) << 13usize);
}
#[doc = "SPI 2 reset"]
#[inline(always)]
pub const fn spi2rst(&self) -> bool {
let val = (self.0 >> 14usize) & 0x01;
val != 0
}
#[doc = "SPI 2 reset"]
#[inline(always)]
pub fn set_spi2rst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 14usize)) | (((val as u32) & 0x01) << 14usize);
}
#[doc = "SPI 3 reset"]
#[inline(always)]
pub const fn spi3rst(&self) -> bool {
let val = (self.0 >> 15usize) & 0x01;
val != 0
}
#[doc = "SPI 3 reset"]
#[inline(always)]
pub fn set_spi3rst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 15usize)) | (((val as u32) & 0x01) << 15usize);
}
#[doc = "SPDIF-RX reset"]
#[inline(always)]
pub const fn spdifrxrst(&self) -> bool {
let val = (self.0 >> 16usize) & 0x01;
val != 0
}
#[doc = "SPDIF-RX reset"]
#[inline(always)]
pub fn set_spdifrxrst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 16usize)) | (((val as u32) & 0x01) << 16usize);
}
#[doc = "USART 2 reset"]
#[inline(always)]
pub const fn usart2rst(&self) -> bool {
let val = (self.0 >> 17usize) & 0x01;
val != 0
}
#[doc = "USART 2 reset"]
#[inline(always)]
pub fn set_usart2rst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 17usize)) | (((val as u32) & 0x01) << 17usize);
}
#[doc = "USART 3 reset"]
#[inline(always)]
pub const fn usart3rst(&self) -> bool {
let val = (self.0 >> 18usize) & 0x01;
val != 0
}
#[doc = "USART 3 reset"]
#[inline(always)]
pub fn set_usart3rst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 18usize)) | (((val as u32) & 0x01) << 18usize);
}
#[doc = "USART 4 reset"]
#[inline(always)]
pub const fn uart4rst(&self) -> bool {
let val = (self.0 >> 19usize) & 0x01;
val != 0
}
#[doc = "USART 4 reset"]
#[inline(always)]
pub fn set_uart4rst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 19usize)) | (((val as u32) & 0x01) << 19usize);
}
#[doc = "USART 5 reset"]
#[inline(always)]
pub const fn uart5rst(&self) -> bool {
let val = (self.0 >> 20usize) & 0x01;
val != 0
}
#[doc = "USART 5 reset"]
#[inline(always)]
pub fn set_uart5rst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 20usize)) | (((val as u32) & 0x01) << 20usize);
}
#[doc = "I2C 1 reset"]
#[inline(always)]
pub const fn i2c1rst(&self) -> bool {
let val = (self.0 >> 21usize) & 0x01;
val != 0
}
#[doc = "I2C 1 reset"]
#[inline(always)]
pub fn set_i2c1rst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 21usize)) | (((val as u32) & 0x01) << 21usize);
}
#[doc = "I2C 2 reset"]
#[inline(always)]
pub const fn i2c2rst(&self) -> bool {
let val = (self.0 >> 22usize) & 0x01;
val != 0
}
#[doc = "I2C 2 reset"]
#[inline(always)]
pub fn set_i2c2rst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 22usize)) | (((val as u32) & 0x01) << 22usize);
}
#[doc = "I2C3 reset"]
#[inline(always)]
pub const fn i2c3rst(&self) -> bool {
let val = (self.0 >> 23usize) & 0x01;
val != 0
}
#[doc = "I2C3 reset"]
#[inline(always)]
pub fn set_i2c3rst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 23usize)) | (((val as u32) & 0x01) << 23usize);
}
#[doc = "I2C 4 reset"]
#[inline(always)]
pub const fn i2c4rst(&self) -> bool {
let val = (self.0 >> 24usize) & 0x01;
val != 0
}
#[doc = "I2C 4 reset"]
#[inline(always)]
pub fn set_i2c4rst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 24usize)) | (((val as u32) & 0x01) << 24usize);
}
#[doc = "CAN1 reset"]
#[inline(always)]
pub const fn can1rst(&self) -> bool {
let val = (self.0 >> 25usize) & 0x01;
val != 0
}
#[doc = "CAN1 reset"]
#[inline(always)]
pub fn set_can1rst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 25usize)) | (((val as u32) & 0x01) << 25usize);
}
#[doc = "CAN2 reset"]
#[inline(always)]
pub const fn can2rst(&self) -> bool {
let val = (self.0 >> 26usize) & 0x01;
val != 0
}
#[doc = "CAN2 reset"]
#[inline(always)]
pub fn set_can2rst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 26usize)) | (((val as u32) & 0x01) << 26usize);
}
#[doc = "HDMI-CEC reset"]
#[inline(always)]
pub const fn cecrst(&self) -> bool {
let val = (self.0 >> 27usize) & 0x01;
val != 0
}
#[doc = "HDMI-CEC reset"]
#[inline(always)]
pub fn set_cecrst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 27usize)) | (((val as u32) & 0x01) << 27usize);
}
#[doc = "Power interface reset"]
#[inline(always)]
pub const fn pwrrst(&self) -> bool {
let val = (self.0 >> 28usize) & 0x01;
val != 0
}
#[doc = "Power interface reset"]
#[inline(always)]
pub fn set_pwrrst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 28usize)) | (((val as u32) & 0x01) << 28usize);
}
#[doc = "DAC reset"]
#[inline(always)]
pub const fn dacrst(&self) -> bool {
let val = (self.0 >> 29usize) & 0x01;
val != 0
}
#[doc = "DAC reset"]
#[inline(always)]
pub fn set_dacrst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 29usize)) | (((val as u32) & 0x01) << 29usize);
}
#[doc = "UART7 reset"]
#[inline(always)]
pub const fn uart7rst(&self) -> bool {
let val = (self.0 >> 30usize) & 0x01;
val != 0
}
#[doc = "UART7 reset"]
#[inline(always)]
pub fn set_uart7rst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 30usize)) | (((val as u32) & 0x01) << 30usize);
}
#[doc = "UART8 reset"]
#[inline(always)]
pub const fn uart8rst(&self) -> bool {
let val = (self.0 >> 31usize) & 0x01;
val != 0
}
#[doc = "UART8 reset"]
#[inline(always)]
pub fn set_uart8rst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 31usize)) | (((val as u32) & 0x01) << 31usize);
}
}
impl Default for Apb1rstr {
#[inline(always)]
fn default() -> Apb1rstr {
Apb1rstr(0)
}
}
impl core::fmt::Debug for Apb1rstr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Apb1rstr")
.field("tim2rst", &self.tim2rst())
.field("tim3rst", &self.tim3rst())
.field("tim4rst", &self.tim4rst())
.field("tim5rst", &self.tim5rst())
.field("tim6rst", &self.tim6rst())
.field("tim7rst", &self.tim7rst())
.field("tim12rst", &self.tim12rst())
.field("tim13rst", &self.tim13rst())
.field("tim14rst", &self.tim14rst())
.field("lptim1rst", &self.lptim1rst())
.field("wwdgrst", &self.wwdgrst())
.field("can3rst", &self.can3rst())
.field("spi2rst", &self.spi2rst())
.field("spi3rst", &self.spi3rst())
.field("spdifrxrst", &self.spdifrxrst())
.field("usart2rst", &self.usart2rst())
.field("usart3rst", &self.usart3rst())
.field("uart4rst", &self.uart4rst())
.field("uart5rst", &self.uart5rst())
.field("i2c1rst", &self.i2c1rst())
.field("i2c2rst", &self.i2c2rst())
.field("i2c3rst", &self.i2c3rst())
.field("i2c4rst", &self.i2c4rst())
.field("can1rst", &self.can1rst())
.field("can2rst", &self.can2rst())
.field("cecrst", &self.cecrst())
.field("pwrrst", &self.pwrrst())
.field("dacrst", &self.dacrst())
.field("uart7rst", &self.uart7rst())
.field("uart8rst", &self.uart8rst())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Apb1rstr {
fn format(&self, f: defmt::Formatter) {
defmt :: write ! (f , "Apb1rstr {{ tim2rst: {=bool:?}, tim3rst: {=bool:?}, tim4rst: {=bool:?}, tim5rst: {=bool:?}, tim6rst: {=bool:?}, tim7rst: {=bool:?}, tim12rst: {=bool:?}, tim13rst: {=bool:?}, tim14rst: {=bool:?}, lptim1rst: {=bool:?}, wwdgrst: {=bool:?}, can3rst: {=bool:?}, spi2rst: {=bool:?}, spi3rst: {=bool:?}, spdifrxrst: {=bool:?}, usart2rst: {=bool:?}, usart3rst: {=bool:?}, uart4rst: {=bool:?}, uart5rst: {=bool:?}, i2c1rst: {=bool:?}, i2c2rst: {=bool:?}, i2c3rst: {=bool:?}, i2c4rst: {=bool:?}, can1rst: {=bool:?}, can2rst: {=bool:?}, cecrst: {=bool:?}, pwrrst: {=bool:?}, dacrst: {=bool:?}, uart7rst: {=bool:?}, uart8rst: {=bool:?} }}" , self . tim2rst () , self . tim3rst () , self . tim4rst () , self . tim5rst () , self . tim6rst () , self . tim7rst () , self . tim12rst () , self . tim13rst () , self . tim14rst () , self . lptim1rst () , self . wwdgrst () , self . can3rst () , self . spi2rst () , self . spi3rst () , self . spdifrxrst () , self . usart2rst () , self . usart3rst () , self . uart4rst () , self . uart5rst () , self . i2c1rst () , self . i2c2rst () , self . i2c3rst () , self . i2c4rst () , self . can1rst () , self . can2rst () , self . cecrst () , self . pwrrst () , self . dacrst () , self . uart7rst () , self . uart8rst ())
}
}
#[doc = "APB2 peripheral clock enable register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Apb2enr(pub u32);
impl Apb2enr {
#[doc = "TIM1 clock enable"]
#[inline(always)]
pub const fn tim1en(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "TIM1 clock enable"]
#[inline(always)]
pub fn set_tim1en(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "TIM8 clock enable"]
#[inline(always)]
pub const fn tim8en(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "TIM8 clock enable"]
#[inline(always)]
pub fn set_tim8en(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "USART1 clock enable"]
#[inline(always)]
pub const fn usart1en(&self) -> bool {
let val = (self.0 >> 4usize) & 0x01;
val != 0
}
#[doc = "USART1 clock enable"]
#[inline(always)]
pub fn set_usart1en(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
}
#[doc = "USART6 clock enable"]
#[inline(always)]
pub const fn usart6en(&self) -> bool {
let val = (self.0 >> 5usize) & 0x01;
val != 0
}
#[doc = "USART6 clock enable"]
#[inline(always)]
pub fn set_usart6en(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
}
#[doc = "SDMMC2 clock enable"]
#[inline(always)]
pub const fn sdmmc2en(&self) -> bool {
let val = (self.0 >> 7usize) & 0x01;
val != 0
}
#[doc = "SDMMC2 clock enable"]
#[inline(always)]
pub fn set_sdmmc2en(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 7usize)) | (((val as u32) & 0x01) << 7usize);
}
#[doc = "ADC1 clock enable"]
#[inline(always)]
pub const fn adc1en(&self) -> bool {
let val = (self.0 >> 8usize) & 0x01;
val != 0
}
#[doc = "ADC1 clock enable"]
#[inline(always)]
pub fn set_adc1en(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 8usize)) | (((val as u32) & 0x01) << 8usize);
}
#[doc = "ADC2 clock enable"]
#[inline(always)]
pub const fn adc2en(&self) -> bool {
let val = (self.0 >> 9usize) & 0x01;
val != 0
}
#[doc = "ADC2 clock enable"]
#[inline(always)]
pub fn set_adc2en(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 9usize)) | (((val as u32) & 0x01) << 9usize);
}
#[doc = "ADC3 clock enable"]
#[inline(always)]
pub const fn adc3en(&self) -> bool {
let val = (self.0 >> 10usize) & 0x01;
val != 0
}
#[doc = "ADC3 clock enable"]
#[inline(always)]
pub fn set_adc3en(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 10usize)) | (((val as u32) & 0x01) << 10usize);
}
#[doc = "SDMMC1 clock enable"]
#[inline(always)]
pub const fn sdmmc1en(&self) -> bool {
let val = (self.0 >> 11usize) & 0x01;
val != 0
}
#[doc = "SDMMC1 clock enable"]
#[inline(always)]
pub fn set_sdmmc1en(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 11usize)) | (((val as u32) & 0x01) << 11usize);
}
#[doc = "SPI1 clock enable"]
#[inline(always)]
pub const fn spi1en(&self) -> bool {
let val = (self.0 >> 12usize) & 0x01;
val != 0
}
#[doc = "SPI1 clock enable"]
#[inline(always)]
pub fn set_spi1en(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 12usize)) | (((val as u32) & 0x01) << 12usize);
}
#[doc = "SPI4 clock enable"]
#[inline(always)]
pub const fn spi4en(&self) -> bool {
let val = (self.0 >> 13usize) & 0x01;
val != 0
}
#[doc = "SPI4 clock enable"]
#[inline(always)]
pub fn set_spi4en(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 13usize)) | (((val as u32) & 0x01) << 13usize);
}
#[doc = "System configuration controller clock enable"]
#[inline(always)]
pub const fn syscfgen(&self) -> bool {
let val = (self.0 >> 14usize) & 0x01;
val != 0
}
#[doc = "System configuration controller clock enable"]
#[inline(always)]
pub fn set_syscfgen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 14usize)) | (((val as u32) & 0x01) << 14usize);
}
#[doc = "TIM9 clock enable"]
#[inline(always)]
pub const fn tim9en(&self) -> bool {
let val = (self.0 >> 16usize) & 0x01;
val != 0
}
#[doc = "TIM9 clock enable"]
#[inline(always)]
pub fn set_tim9en(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 16usize)) | (((val as u32) & 0x01) << 16usize);
}
#[doc = "TIM10 clock enable"]
#[inline(always)]
pub const fn tim10en(&self) -> bool {
let val = (self.0 >> 17usize) & 0x01;
val != 0
}
#[doc = "TIM10 clock enable"]
#[inline(always)]
pub fn set_tim10en(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 17usize)) | (((val as u32) & 0x01) << 17usize);
}
#[doc = "TIM11 clock enable"]
#[inline(always)]
pub const fn tim11en(&self) -> bool {
let val = (self.0 >> 18usize) & 0x01;
val != 0
}
#[doc = "TIM11 clock enable"]
#[inline(always)]
pub fn set_tim11en(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 18usize)) | (((val as u32) & 0x01) << 18usize);
}
#[doc = "SPI5 clock enable"]
#[inline(always)]
pub const fn spi5en(&self) -> bool {
let val = (self.0 >> 20usize) & 0x01;
val != 0
}
#[doc = "SPI5 clock enable"]
#[inline(always)]
pub fn set_spi5en(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 20usize)) | (((val as u32) & 0x01) << 20usize);
}
#[doc = "SPI6 clock enable"]
#[inline(always)]
pub const fn spi6en(&self) -> bool {
let val = (self.0 >> 21usize) & 0x01;
val != 0
}
#[doc = "SPI6 clock enable"]
#[inline(always)]
pub fn set_spi6en(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 21usize)) | (((val as u32) & 0x01) << 21usize);
}
#[doc = "SAI1 clock enable"]
#[inline(always)]
pub const fn sai1en(&self) -> bool {
let val = (self.0 >> 22usize) & 0x01;
val != 0
}
#[doc = "SAI1 clock enable"]
#[inline(always)]
pub fn set_sai1en(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 22usize)) | (((val as u32) & 0x01) << 22usize);
}
#[doc = "SAI2 clock enable"]
#[inline(always)]
pub const fn sai2en(&self) -> bool {
let val = (self.0 >> 23usize) & 0x01;
val != 0
}
#[doc = "SAI2 clock enable"]
#[inline(always)]
pub fn set_sai2en(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 23usize)) | (((val as u32) & 0x01) << 23usize);
}
#[doc = "LTDC clock enable"]
#[inline(always)]
pub const fn ltdcen(&self) -> bool {
let val = (self.0 >> 26usize) & 0x01;
val != 0
}
#[doc = "LTDC clock enable"]
#[inline(always)]
pub fn set_ltdcen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 26usize)) | (((val as u32) & 0x01) << 26usize);
}
#[doc = "DSI clock enable"]
#[inline(always)]
pub const fn dsien(&self) -> bool {
let val = (self.0 >> 27usize) & 0x01;
val != 0
}
#[doc = "DSI clock enable"]
#[inline(always)]
pub fn set_dsien(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 27usize)) | (((val as u32) & 0x01) << 27usize);
}
#[doc = "DFSDM1 clock enable"]
#[inline(always)]
pub const fn dfsdm1en(&self) -> bool {
let val = (self.0 >> 29usize) & 0x01;
val != 0
}
#[doc = "DFSDM1 clock enable"]
#[inline(always)]
pub fn set_dfsdm1en(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 29usize)) | (((val as u32) & 0x01) << 29usize);
}
#[doc = "MDIO clock enable"]
#[inline(always)]
pub const fn mdiosen(&self) -> bool {
let val = (self.0 >> 30usize) & 0x01;
val != 0
}
#[doc = "MDIO clock enable"]
#[inline(always)]
pub fn set_mdiosen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 30usize)) | (((val as u32) & 0x01) << 30usize);
}
#[doc = "USB OTG HS PHY controller clock enable"]
#[inline(always)]
pub const fn usbphycen(&self) -> bool {
let val = (self.0 >> 31usize) & 0x01;
val != 0
}
#[doc = "USB OTG HS PHY controller clock enable"]
#[inline(always)]
pub fn set_usbphycen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 31usize)) | (((val as u32) & 0x01) << 31usize);
}
}
impl Default for Apb2enr {
#[inline(always)]
fn default() -> Apb2enr {
Apb2enr(0)
}
}
impl core::fmt::Debug for Apb2enr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Apb2enr")
.field("tim1en", &self.tim1en())
.field("tim8en", &self.tim8en())
.field("usart1en", &self.usart1en())
.field("usart6en", &self.usart6en())
.field("sdmmc2en", &self.sdmmc2en())
.field("adc1en", &self.adc1en())
.field("adc2en", &self.adc2en())
.field("adc3en", &self.adc3en())
.field("sdmmc1en", &self.sdmmc1en())
.field("spi1en", &self.spi1en())
.field("spi4en", &self.spi4en())
.field("syscfgen", &self.syscfgen())
.field("tim9en", &self.tim9en())
.field("tim10en", &self.tim10en())
.field("tim11en", &self.tim11en())
.field("spi5en", &self.spi5en())
.field("spi6en", &self.spi6en())
.field("sai1en", &self.sai1en())
.field("sai2en", &self.sai2en())
.field("ltdcen", &self.ltdcen())
.field("dsien", &self.dsien())
.field("dfsdm1en", &self.dfsdm1en())
.field("mdiosen", &self.mdiosen())
.field("usbphycen", &self.usbphycen())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Apb2enr {
fn format(&self, f: defmt::Formatter) {
defmt :: write ! (f , "Apb2enr {{ tim1en: {=bool:?}, tim8en: {=bool:?}, usart1en: {=bool:?}, usart6en: {=bool:?}, sdmmc2en: {=bool:?}, adc1en: {=bool:?}, adc2en: {=bool:?}, adc3en: {=bool:?}, sdmmc1en: {=bool:?}, spi1en: {=bool:?}, spi4en: {=bool:?}, syscfgen: {=bool:?}, tim9en: {=bool:?}, tim10en: {=bool:?}, tim11en: {=bool:?}, spi5en: {=bool:?}, spi6en: {=bool:?}, sai1en: {=bool:?}, sai2en: {=bool:?}, ltdcen: {=bool:?}, dsien: {=bool:?}, dfsdm1en: {=bool:?}, mdiosen: {=bool:?}, usbphycen: {=bool:?} }}" , self . tim1en () , self . tim8en () , self . usart1en () , self . usart6en () , self . sdmmc2en () , self . adc1en () , self . adc2en () , self . adc3en () , self . sdmmc1en () , self . spi1en () , self . spi4en () , self . syscfgen () , self . tim9en () , self . tim10en () , self . tim11en () , self . spi5en () , self . spi6en () , self . sai1en () , self . sai2en () , self . ltdcen () , self . dsien () , self . dfsdm1en () , self . mdiosen () , self . usbphycen ())
}
}
#[doc = "APB2 peripheral clock enabled in low power mode register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Apb2lpenr(pub u32);
impl Apb2lpenr {
#[doc = "TIM1 clock enable during Sleep mode"]
#[inline(always)]
pub const fn tim1lpen(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "TIM1 clock enable during Sleep mode"]
#[inline(always)]
pub fn set_tim1lpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "TIM8 clock enable during Sleep mode"]
#[inline(always)]
pub const fn tim8lpen(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "TIM8 clock enable during Sleep mode"]
#[inline(always)]
pub fn set_tim8lpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "USART1 clock enable during Sleep mode"]
#[inline(always)]
pub const fn usart1lpen(&self) -> bool {
let val = (self.0 >> 4usize) & 0x01;
val != 0
}
#[doc = "USART1 clock enable during Sleep mode"]
#[inline(always)]
pub fn set_usart1lpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
}
#[doc = "USART6 clock enable during Sleep mode"]
#[inline(always)]
pub const fn usart6lpen(&self) -> bool {
let val = (self.0 >> 5usize) & 0x01;
val != 0
}
#[doc = "USART6 clock enable during Sleep mode"]
#[inline(always)]
pub fn set_usart6lpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
}
#[doc = "SDMMC2 clock enable during Sleep mode"]
#[inline(always)]
pub const fn sdmmc2lpen(&self) -> bool {
let val = (self.0 >> 7usize) & 0x01;
val != 0
}
#[doc = "SDMMC2 clock enable during Sleep mode"]
#[inline(always)]
pub fn set_sdmmc2lpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 7usize)) | (((val as u32) & 0x01) << 7usize);
}
#[doc = "ADC1 clock enable during Sleep mode"]
#[inline(always)]
pub const fn adc1lpen(&self) -> bool {
let val = (self.0 >> 8usize) & 0x01;
val != 0
}
#[doc = "ADC1 clock enable during Sleep mode"]
#[inline(always)]
pub fn set_adc1lpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 8usize)) | (((val as u32) & 0x01) << 8usize);
}
#[doc = "ADC2 clock enable during Sleep mode"]
#[inline(always)]
pub const fn adc2lpen(&self) -> bool {
let val = (self.0 >> 9usize) & 0x01;
val != 0
}
#[doc = "ADC2 clock enable during Sleep mode"]
#[inline(always)]
pub fn set_adc2lpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 9usize)) | (((val as u32) & 0x01) << 9usize);
}
#[doc = "ADC 3 clock enable during Sleep mode"]
#[inline(always)]
pub const fn adc3lpen(&self) -> bool {
let val = (self.0 >> 10usize) & 0x01;
val != 0
}
#[doc = "ADC 3 clock enable during Sleep mode"]
#[inline(always)]
pub fn set_adc3lpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 10usize)) | (((val as u32) & 0x01) << 10usize);
}
#[doc = "SDMMC1 clock enable during Sleep mode"]
#[inline(always)]
pub const fn sdmmc1lpen(&self) -> bool {
let val = (self.0 >> 11usize) & 0x01;
val != 0
}
#[doc = "SDMMC1 clock enable during Sleep mode"]
#[inline(always)]
pub fn set_sdmmc1lpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 11usize)) | (((val as u32) & 0x01) << 11usize);
}
#[doc = "SPI 1 clock enable during Sleep mode"]
#[inline(always)]
pub const fn spi1lpen(&self) -> bool {
let val = (self.0 >> 12usize) & 0x01;
val != 0
}
#[doc = "SPI 1 clock enable during Sleep mode"]
#[inline(always)]
pub fn set_spi1lpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 12usize)) | (((val as u32) & 0x01) << 12usize);
}
#[doc = "SPI 4 clock enable during Sleep mode"]
#[inline(always)]
pub const fn spi4lpen(&self) -> bool {
let val = (self.0 >> 13usize) & 0x01;
val != 0
}
#[doc = "SPI 4 clock enable during Sleep mode"]
#[inline(always)]
pub fn set_spi4lpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 13usize)) | (((val as u32) & 0x01) << 13usize);
}
#[doc = "System configuration controller clock enable during Sleep mode"]
#[inline(always)]
pub const fn syscfglpen(&self) -> bool {
let val = (self.0 >> 14usize) & 0x01;
val != 0
}
#[doc = "System configuration controller clock enable during Sleep mode"]
#[inline(always)]
pub fn set_syscfglpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 14usize)) | (((val as u32) & 0x01) << 14usize);
}
#[doc = "TIM9 clock enable during sleep mode"]
#[inline(always)]
pub const fn tim9lpen(&self) -> bool {
let val = (self.0 >> 16usize) & 0x01;
val != 0
}
#[doc = "TIM9 clock enable during sleep mode"]
#[inline(always)]
pub fn set_tim9lpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 16usize)) | (((val as u32) & 0x01) << 16usize);
}
#[doc = "TIM10 clock enable during Sleep mode"]
#[inline(always)]
pub const fn tim10lpen(&self) -> bool {
let val = (self.0 >> 17usize) & 0x01;
val != 0
}
#[doc = "TIM10 clock enable during Sleep mode"]
#[inline(always)]
pub fn set_tim10lpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 17usize)) | (((val as u32) & 0x01) << 17usize);
}
#[doc = "TIM11 clock enable during Sleep mode"]
#[inline(always)]
pub const fn tim11lpen(&self) -> bool {
let val = (self.0 >> 18usize) & 0x01;
val != 0
}
#[doc = "TIM11 clock enable during Sleep mode"]
#[inline(always)]
pub fn set_tim11lpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 18usize)) | (((val as u32) & 0x01) << 18usize);
}
#[doc = "SPI 5 clock enable during Sleep mode"]
#[inline(always)]
pub const fn spi5lpen(&self) -> bool {
let val = (self.0 >> 20usize) & 0x01;
val != 0
}
#[doc = "SPI 5 clock enable during Sleep mode"]
#[inline(always)]
pub fn set_spi5lpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 20usize)) | (((val as u32) & 0x01) << 20usize);
}
#[doc = "SPI 6 clock enable during Sleep mode"]
#[inline(always)]
pub const fn spi6lpen(&self) -> bool {
let val = (self.0 >> 21usize) & 0x01;
val != 0
}
#[doc = "SPI 6 clock enable during Sleep mode"]
#[inline(always)]
pub fn set_spi6lpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 21usize)) | (((val as u32) & 0x01) << 21usize);
}
#[doc = "SAI1 clock enable during sleep mode"]
#[inline(always)]
pub const fn sai1lpen(&self) -> bool {
let val = (self.0 >> 22usize) & 0x01;
val != 0
}
#[doc = "SAI1 clock enable during sleep mode"]
#[inline(always)]
pub fn set_sai1lpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 22usize)) | (((val as u32) & 0x01) << 22usize);
}
#[doc = "SAI2 clock enable during sleep mode"]
#[inline(always)]
pub const fn sai2lpen(&self) -> bool {
let val = (self.0 >> 23usize) & 0x01;
val != 0
}
#[doc = "SAI2 clock enable during sleep mode"]
#[inline(always)]
pub fn set_sai2lpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 23usize)) | (((val as u32) & 0x01) << 23usize);
}
#[doc = "LTDC clock enable during sleep mode"]
#[inline(always)]
pub const fn ltdclpen(&self) -> bool {
let val = (self.0 >> 26usize) & 0x01;
val != 0
}
#[doc = "LTDC clock enable during sleep mode"]
#[inline(always)]
pub fn set_ltdclpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 26usize)) | (((val as u32) & 0x01) << 26usize);
}
#[doc = "DSI clock enable during Sleep mode"]
#[inline(always)]
pub const fn dsilpen(&self) -> bool {
let val = (self.0 >> 27usize) & 0x01;
val != 0
}
#[doc = "DSI clock enable during Sleep mode"]
#[inline(always)]
pub fn set_dsilpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 27usize)) | (((val as u32) & 0x01) << 27usize);
}
#[doc = "DFSDM1 clock enable during Sleep mode"]
#[inline(always)]
pub const fn dfsdm1lpen(&self) -> bool {
let val = (self.0 >> 29usize) & 0x01;
val != 0
}
#[doc = "DFSDM1 clock enable during Sleep mode"]
#[inline(always)]
pub fn set_dfsdm1lpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 29usize)) | (((val as u32) & 0x01) << 29usize);
}
#[doc = "MDIO clock enable during Sleep mode"]
#[inline(always)]
pub const fn mdioslpen(&self) -> bool {
let val = (self.0 >> 30usize) & 0x01;
val != 0
}
#[doc = "MDIO clock enable during Sleep mode"]
#[inline(always)]
pub fn set_mdioslpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 30usize)) | (((val as u32) & 0x01) << 30usize);
}
}
impl Default for Apb2lpenr {
#[inline(always)]
fn default() -> Apb2lpenr {
Apb2lpenr(0)
}
}
impl core::fmt::Debug for Apb2lpenr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Apb2lpenr")
.field("tim1lpen", &self.tim1lpen())
.field("tim8lpen", &self.tim8lpen())
.field("usart1lpen", &self.usart1lpen())
.field("usart6lpen", &self.usart6lpen())
.field("sdmmc2lpen", &self.sdmmc2lpen())
.field("adc1lpen", &self.adc1lpen())
.field("adc2lpen", &self.adc2lpen())
.field("adc3lpen", &self.adc3lpen())
.field("sdmmc1lpen", &self.sdmmc1lpen())
.field("spi1lpen", &self.spi1lpen())
.field("spi4lpen", &self.spi4lpen())
.field("syscfglpen", &self.syscfglpen())
.field("tim9lpen", &self.tim9lpen())
.field("tim10lpen", &self.tim10lpen())
.field("tim11lpen", &self.tim11lpen())
.field("spi5lpen", &self.spi5lpen())
.field("spi6lpen", &self.spi6lpen())
.field("sai1lpen", &self.sai1lpen())
.field("sai2lpen", &self.sai2lpen())
.field("ltdclpen", &self.ltdclpen())
.field("dsilpen", &self.dsilpen())
.field("dfsdm1lpen", &self.dfsdm1lpen())
.field("mdioslpen", &self.mdioslpen())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Apb2lpenr {
fn format(&self, f: defmt::Formatter) {
defmt :: write ! (f , "Apb2lpenr {{ tim1lpen: {=bool:?}, tim8lpen: {=bool:?}, usart1lpen: {=bool:?}, usart6lpen: {=bool:?}, sdmmc2lpen: {=bool:?}, adc1lpen: {=bool:?}, adc2lpen: {=bool:?}, adc3lpen: {=bool:?}, sdmmc1lpen: {=bool:?}, spi1lpen: {=bool:?}, spi4lpen: {=bool:?}, syscfglpen: {=bool:?}, tim9lpen: {=bool:?}, tim10lpen: {=bool:?}, tim11lpen: {=bool:?}, spi5lpen: {=bool:?}, spi6lpen: {=bool:?}, sai1lpen: {=bool:?}, sai2lpen: {=bool:?}, ltdclpen: {=bool:?}, dsilpen: {=bool:?}, dfsdm1lpen: {=bool:?}, mdioslpen: {=bool:?} }}" , self . tim1lpen () , self . tim8lpen () , self . usart1lpen () , self . usart6lpen () , self . sdmmc2lpen () , self . adc1lpen () , self . adc2lpen () , self . adc3lpen () , self . sdmmc1lpen () , self . spi1lpen () , self . spi4lpen () , self . syscfglpen () , self . tim9lpen () , self . tim10lpen () , self . tim11lpen () , self . spi5lpen () , self . spi6lpen () , self . sai1lpen () , self . sai2lpen () , self . ltdclpen () , self . dsilpen () , self . dfsdm1lpen () , self . mdioslpen ())
}
}
#[doc = "APB2 peripheral reset register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Apb2rstr(pub u32);
impl Apb2rstr {
#[doc = "TIM1 reset"]
#[inline(always)]
pub const fn tim1rst(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "TIM1 reset"]
#[inline(always)]
pub fn set_tim1rst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "TIM8 reset"]
#[inline(always)]
pub const fn tim8rst(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "TIM8 reset"]
#[inline(always)]
pub fn set_tim8rst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "USART1 reset"]
#[inline(always)]
pub const fn usart1rst(&self) -> bool {
let val = (self.0 >> 4usize) & 0x01;
val != 0
}
#[doc = "USART1 reset"]
#[inline(always)]
pub fn set_usart1rst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
}
#[doc = "USART6 reset"]
#[inline(always)]
pub const fn usart6rst(&self) -> bool {
let val = (self.0 >> 5usize) & 0x01;
val != 0
}
#[doc = "USART6 reset"]
#[inline(always)]
pub fn set_usart6rst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
}
#[doc = "SDMMC2 reset"]
#[inline(always)]
pub const fn sdmmc2rst(&self) -> bool {
let val = (self.0 >> 7usize) & 0x01;
val != 0
}
#[doc = "SDMMC2 reset"]
#[inline(always)]
pub fn set_sdmmc2rst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 7usize)) | (((val as u32) & 0x01) << 7usize);
}
#[doc = "ADC interface reset (common to all ADCs)"]
#[inline(always)]
pub const fn adcrst(&self) -> bool {
let val = (self.0 >> 8usize) & 0x01;
val != 0
}
#[doc = "ADC interface reset (common to all ADCs)"]
#[inline(always)]
pub fn set_adcrst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 8usize)) | (((val as u32) & 0x01) << 8usize);
}
#[doc = "SDMMC1 reset"]
#[inline(always)]
pub const fn sdmmc1rst(&self) -> bool {
let val = (self.0 >> 11usize) & 0x01;
val != 0
}
#[doc = "SDMMC1 reset"]
#[inline(always)]
pub fn set_sdmmc1rst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 11usize)) | (((val as u32) & 0x01) << 11usize);
}
#[doc = "SPI 1 reset"]
#[inline(always)]
pub const fn spi1rst(&self) -> bool {
let val = (self.0 >> 12usize) & 0x01;
val != 0
}
#[doc = "SPI 1 reset"]
#[inline(always)]
pub fn set_spi1rst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 12usize)) | (((val as u32) & 0x01) << 12usize);
}
#[doc = "SPI4 reset"]
#[inline(always)]
pub const fn spi4rst(&self) -> bool {
let val = (self.0 >> 13usize) & 0x01;
val != 0
}
#[doc = "SPI4 reset"]
#[inline(always)]
pub fn set_spi4rst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 13usize)) | (((val as u32) & 0x01) << 13usize);
}
#[doc = "System configuration controller reset"]
#[inline(always)]
pub const fn syscfgrst(&self) -> bool {
let val = (self.0 >> 14usize) & 0x01;
val != 0
}
#[doc = "System configuration controller reset"]
#[inline(always)]
pub fn set_syscfgrst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 14usize)) | (((val as u32) & 0x01) << 14usize);
}
#[doc = "TIM9 reset"]
#[inline(always)]
pub const fn tim9rst(&self) -> bool {
let val = (self.0 >> 16usize) & 0x01;
val != 0
}
#[doc = "TIM9 reset"]
#[inline(always)]
pub fn set_tim9rst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 16usize)) | (((val as u32) & 0x01) << 16usize);
}
#[doc = "TIM10 reset"]
#[inline(always)]
pub const fn tim10rst(&self) -> bool {
let val = (self.0 >> 17usize) & 0x01;
val != 0
}
#[doc = "TIM10 reset"]
#[inline(always)]
pub fn set_tim10rst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 17usize)) | (((val as u32) & 0x01) << 17usize);
}
#[doc = "TIM11 reset"]
#[inline(always)]
pub const fn tim11rst(&self) -> bool {
let val = (self.0 >> 18usize) & 0x01;
val != 0
}
#[doc = "TIM11 reset"]
#[inline(always)]
pub fn set_tim11rst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 18usize)) | (((val as u32) & 0x01) << 18usize);
}
#[doc = "SPI5 reset"]
#[inline(always)]
pub const fn spi5rst(&self) -> bool {
let val = (self.0 >> 20usize) & 0x01;
val != 0
}
#[doc = "SPI5 reset"]
#[inline(always)]
pub fn set_spi5rst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 20usize)) | (((val as u32) & 0x01) << 20usize);
}
#[doc = "SPI6 reset"]
#[inline(always)]
pub const fn spi6rst(&self) -> bool {
let val = (self.0 >> 21usize) & 0x01;
val != 0
}
#[doc = "SPI6 reset"]
#[inline(always)]
pub fn set_spi6rst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 21usize)) | (((val as u32) & 0x01) << 21usize);
}
#[doc = "SAI1 reset"]
#[inline(always)]
pub const fn sai1rst(&self) -> bool {
let val = (self.0 >> 22usize) & 0x01;
val != 0
}
#[doc = "SAI1 reset"]
#[inline(always)]
pub fn set_sai1rst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 22usize)) | (((val as u32) & 0x01) << 22usize);
}
#[doc = "SAI2 reset"]
#[inline(always)]
pub const fn sai2rst(&self) -> bool {
let val = (self.0 >> 23usize) & 0x01;
val != 0
}
#[doc = "SAI2 reset"]
#[inline(always)]
pub fn set_sai2rst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 23usize)) | (((val as u32) & 0x01) << 23usize);
}
#[doc = "LTDC reset"]
#[inline(always)]
pub const fn ltdcrst(&self) -> bool {
let val = (self.0 >> 26usize) & 0x01;
val != 0
}
#[doc = "LTDC reset"]
#[inline(always)]
pub fn set_ltdcrst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 26usize)) | (((val as u32) & 0x01) << 26usize);
}
#[doc = "DSI reset"]
#[inline(always)]
pub const fn dsirst(&self) -> bool {
let val = (self.0 >> 27usize) & 0x01;
val != 0
}
#[doc = "DSI reset"]
#[inline(always)]
pub fn set_dsirst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 27usize)) | (((val as u32) & 0x01) << 27usize);
}
#[doc = "DFSDM 1 reset"]
#[inline(always)]
pub const fn dfsdm1rst(&self) -> bool {
let val = (self.0 >> 29usize) & 0x01;
val != 0
}
#[doc = "DFSDM 1 reset"]
#[inline(always)]
pub fn set_dfsdm1rst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 29usize)) | (((val as u32) & 0x01) << 29usize);
}
#[doc = "MDIOS reset"]
#[inline(always)]
pub const fn mdiosrst(&self) -> bool {
let val = (self.0 >> 30usize) & 0x01;
val != 0
}
#[doc = "MDIOS reset"]
#[inline(always)]
pub fn set_mdiosrst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 30usize)) | (((val as u32) & 0x01) << 30usize);
}
#[doc = "USB OTG HS PHY controller reset"]
#[inline(always)]
pub const fn usbphycrst(&self) -> bool {
let val = (self.0 >> 31usize) & 0x01;
val != 0
}
#[doc = "USB OTG HS PHY controller reset"]
#[inline(always)]
pub fn set_usbphycrst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 31usize)) | (((val as u32) & 0x01) << 31usize);
}
}
impl Default for Apb2rstr {
#[inline(always)]
fn default() -> Apb2rstr {
Apb2rstr(0)
}
}
impl core::fmt::Debug for Apb2rstr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Apb2rstr")
.field("tim1rst", &self.tim1rst())
.field("tim8rst", &self.tim8rst())
.field("usart1rst", &self.usart1rst())
.field("usart6rst", &self.usart6rst())
.field("sdmmc2rst", &self.sdmmc2rst())
.field("adcrst", &self.adcrst())
.field("sdmmc1rst", &self.sdmmc1rst())
.field("spi1rst", &self.spi1rst())
.field("spi4rst", &self.spi4rst())
.field("syscfgrst", &self.syscfgrst())
.field("tim9rst", &self.tim9rst())
.field("tim10rst", &self.tim10rst())
.field("tim11rst", &self.tim11rst())
.field("spi5rst", &self.spi5rst())
.field("spi6rst", &self.spi6rst())
.field("sai1rst", &self.sai1rst())
.field("sai2rst", &self.sai2rst())
.field("ltdcrst", &self.ltdcrst())
.field("dsirst", &self.dsirst())
.field("dfsdm1rst", &self.dfsdm1rst())
.field("mdiosrst", &self.mdiosrst())
.field("usbphycrst", &self.usbphycrst())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Apb2rstr {
fn format(&self, f: defmt::Formatter) {
defmt :: write ! (f , "Apb2rstr {{ tim1rst: {=bool:?}, tim8rst: {=bool:?}, usart1rst: {=bool:?}, usart6rst: {=bool:?}, sdmmc2rst: {=bool:?}, adcrst: {=bool:?}, sdmmc1rst: {=bool:?}, spi1rst: {=bool:?}, spi4rst: {=bool:?}, syscfgrst: {=bool:?}, tim9rst: {=bool:?}, tim10rst: {=bool:?}, tim11rst: {=bool:?}, spi5rst: {=bool:?}, spi6rst: {=bool:?}, sai1rst: {=bool:?}, sai2rst: {=bool:?}, ltdcrst: {=bool:?}, dsirst: {=bool:?}, dfsdm1rst: {=bool:?}, mdiosrst: {=bool:?}, usbphycrst: {=bool:?} }}" , self . tim1rst () , self . tim8rst () , self . usart1rst () , self . usart6rst () , self . sdmmc2rst () , self . adcrst () , self . sdmmc1rst () , self . spi1rst () , self . spi4rst () , self . syscfgrst () , self . tim9rst () , self . tim10rst () , self . tim11rst () , self . spi5rst () , self . spi6rst () , self . sai1rst () , self . sai2rst () , self . ltdcrst () , self . dsirst () , self . dfsdm1rst () , self . mdiosrst () , self . usbphycrst ())
}
}
#[doc = "Backup domain control register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Bdcr(pub u32);
impl Bdcr {
#[doc = "External low-speed oscillator enable"]
#[inline(always)]
pub const fn lseon(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "External low-speed oscillator enable"]
#[inline(always)]
pub fn set_lseon(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "External low-speed oscillator ready"]
#[inline(always)]
pub const fn lserdy(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "External low-speed oscillator ready"]
#[inline(always)]
pub fn set_lserdy(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "External low-speed oscillator bypass"]
#[inline(always)]
pub const fn lsebyp(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[doc = "External low-speed oscillator bypass"]
#[inline(always)]
pub fn set_lsebyp(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
#[doc = "LSE oscillator drive capability"]
#[inline(always)]
pub const fn lsedrv(&self) -> super::vals::Lsedrv {
let val = (self.0 >> 3usize) & 0x03;
super::vals::Lsedrv::from_bits(val as u8)
}
#[doc = "LSE oscillator drive capability"]
#[inline(always)]
pub fn set_lsedrv(&mut self, val: super::vals::Lsedrv) {
self.0 = (self.0 & !(0x03 << 3usize)) | (((val.to_bits() as u32) & 0x03) << 3usize);
}
#[doc = "RTC clock source selection"]
#[inline(always)]
pub const fn rtcsel(&self) -> super::vals::Rtcsel {
let val = (self.0 >> 8usize) & 0x03;
super::vals::Rtcsel::from_bits(val as u8)
}
#[doc = "RTC clock source selection"]
#[inline(always)]
pub fn set_rtcsel(&mut self, val: super::vals::Rtcsel) {
self.0 = (self.0 & !(0x03 << 8usize)) | (((val.to_bits() as u32) & 0x03) << 8usize);
}
#[doc = "RTC clock enable"]
#[inline(always)]
pub const fn rtcen(&self) -> bool {
let val = (self.0 >> 15usize) & 0x01;
val != 0
}
#[doc = "RTC clock enable"]
#[inline(always)]
pub fn set_rtcen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 15usize)) | (((val as u32) & 0x01) << 15usize);
}
#[doc = "Backup domain software reset"]
#[inline(always)]
pub const fn bdrst(&self) -> bool {
let val = (self.0 >> 16usize) & 0x01;
val != 0
}
#[doc = "Backup domain software reset"]
#[inline(always)]
pub fn set_bdrst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 16usize)) | (((val as u32) & 0x01) << 16usize);
}
}
impl Default for Bdcr {
#[inline(always)]
fn default() -> Bdcr {
Bdcr(0)
}
}
impl core::fmt::Debug for Bdcr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Bdcr")
.field("lseon", &self.lseon())
.field("lserdy", &self.lserdy())
.field("lsebyp", &self.lsebyp())
.field("lsedrv", &self.lsedrv())
.field("rtcsel", &self.rtcsel())
.field("rtcen", &self.rtcen())
.field("bdrst", &self.bdrst())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Bdcr {
fn format(&self, f: defmt::Formatter) {
defmt :: write ! (f , "Bdcr {{ lseon: {=bool:?}, lserdy: {=bool:?}, lsebyp: {=bool:?}, lsedrv: {:?}, rtcsel: {:?}, rtcen: {=bool:?}, bdrst: {=bool:?} }}" , self . lseon () , self . lserdy () , self . lsebyp () , self . lsedrv () , self . rtcsel () , self . rtcen () , self . bdrst ())
}
}
#[doc = "clock configuration register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Cfgr(pub u32);
impl Cfgr {
#[doc = "System clock switch"]
#[inline(always)]
pub const fn sw(&self) -> super::vals::Sw {
let val = (self.0 >> 0usize) & 0x03;
super::vals::Sw::from_bits(val as u8)
}
#[doc = "System clock switch"]
#[inline(always)]
pub fn set_sw(&mut self, val: super::vals::Sw) {
self.0 = (self.0 & !(0x03 << 0usize)) | (((val.to_bits() as u32) & 0x03) << 0usize);
}
#[doc = "System clock switch status"]
#[inline(always)]
pub const fn sws(&self) -> super::vals::Sw {
let val = (self.0 >> 2usize) & 0x03;
super::vals::Sw::from_bits(val as u8)
}
#[doc = "System clock switch status"]
#[inline(always)]
pub fn set_sws(&mut self, val: super::vals::Sw) {
self.0 = (self.0 & !(0x03 << 2usize)) | (((val.to_bits() as u32) & 0x03) << 2usize);
}
#[doc = "AHB prescaler"]
#[inline(always)]
pub const fn hpre(&self) -> super::vals::Hpre {
let val = (self.0 >> 4usize) & 0x0f;
super::vals::Hpre::from_bits(val as u8)
}
#[doc = "AHB prescaler"]
#[inline(always)]
pub fn set_hpre(&mut self, val: super::vals::Hpre) {
self.0 = (self.0 & !(0x0f << 4usize)) | (((val.to_bits() as u32) & 0x0f) << 4usize);
}
#[doc = "APB Low speed prescaler (APB1)"]
#[inline(always)]
pub const fn ppre1(&self) -> super::vals::Ppre {
let val = (self.0 >> 10usize) & 0x07;
super::vals::Ppre::from_bits(val as u8)
}
#[doc = "APB Low speed prescaler (APB1)"]
#[inline(always)]
pub fn set_ppre1(&mut self, val: super::vals::Ppre) {
self.0 = (self.0 & !(0x07 << 10usize)) | (((val.to_bits() as u32) & 0x07) << 10usize);
}
#[doc = "APB high-speed prescaler (APB2)"]
#[inline(always)]
pub const fn ppre2(&self) -> super::vals::Ppre {
let val = (self.0 >> 13usize) & 0x07;
super::vals::Ppre::from_bits(val as u8)
}
#[doc = "APB high-speed prescaler (APB2)"]
#[inline(always)]
pub fn set_ppre2(&mut self, val: super::vals::Ppre) {
self.0 = (self.0 & !(0x07 << 13usize)) | (((val.to_bits() as u32) & 0x07) << 13usize);
}
#[doc = "HSE division factor for RTC clock"]
#[inline(always)]
pub const fn rtcpre(&self) -> u8 {
let val = (self.0 >> 16usize) & 0x1f;
val as u8
}
#[doc = "HSE division factor for RTC clock"]
#[inline(always)]
pub fn set_rtcpre(&mut self, val: u8) {
self.0 = (self.0 & !(0x1f << 16usize)) | (((val as u32) & 0x1f) << 16usize);
}
#[doc = "Microcontroller clock output 1"]
#[inline(always)]
pub const fn mco1sel(&self) -> super::vals::Mco1sel {
let val = (self.0 >> 21usize) & 0x03;
super::vals::Mco1sel::from_bits(val as u8)
}
#[doc = "Microcontroller clock output 1"]
#[inline(always)]
pub fn set_mco1sel(&mut self, val: super::vals::Mco1sel) {
self.0 = (self.0 & !(0x03 << 21usize)) | (((val.to_bits() as u32) & 0x03) << 21usize);
}
#[doc = "I2S clock selection"]
#[inline(always)]
pub const fn i2ssrc(&self) -> super::vals::Issrc {
let val = (self.0 >> 23usize) & 0x01;
super::vals::Issrc::from_bits(val as u8)
}
#[doc = "I2S clock selection"]
#[inline(always)]
pub fn set_i2ssrc(&mut self, val: super::vals::Issrc) {
self.0 = (self.0 & !(0x01 << 23usize)) | (((val.to_bits() as u32) & 0x01) << 23usize);
}
#[doc = "MCO1 prescaler"]
#[inline(always)]
pub const fn mco1pre(&self) -> super::vals::Mcopre {
let val = (self.0 >> 24usize) & 0x07;
super::vals::Mcopre::from_bits(val as u8)
}
#[doc = "MCO1 prescaler"]
#[inline(always)]
pub fn set_mco1pre(&mut self, val: super::vals::Mcopre) {
self.0 = (self.0 & !(0x07 << 24usize)) | (((val.to_bits() as u32) & 0x07) << 24usize);
}
#[doc = "MCO2 prescaler"]
#[inline(always)]
pub const fn mco2pre(&self) -> super::vals::Mcopre {
let val = (self.0 >> 27usize) & 0x07;
super::vals::Mcopre::from_bits(val as u8)
}
#[doc = "MCO2 prescaler"]
#[inline(always)]
pub fn set_mco2pre(&mut self, val: super::vals::Mcopre) {
self.0 = (self.0 & !(0x07 << 27usize)) | (((val.to_bits() as u32) & 0x07) << 27usize);
}
#[doc = "Microcontroller clock output 2"]
#[inline(always)]
pub const fn mco2sel(&self) -> super::vals::Mco2sel {
let val = (self.0 >> 30usize) & 0x03;
super::vals::Mco2sel::from_bits(val as u8)
}
#[doc = "Microcontroller clock output 2"]
#[inline(always)]
pub fn set_mco2sel(&mut self, val: super::vals::Mco2sel) {
self.0 = (self.0 & !(0x03 << 30usize)) | (((val.to_bits() as u32) & 0x03) << 30usize);
}
}
impl Default for Cfgr {
#[inline(always)]
fn default() -> Cfgr {
Cfgr(0)
}
}
impl core::fmt::Debug for Cfgr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Cfgr")
.field("sw", &self.sw())
.field("sws", &self.sws())
.field("hpre", &self.hpre())
.field("ppre1", &self.ppre1())
.field("ppre2", &self.ppre2())
.field("rtcpre", &self.rtcpre())
.field("mco1sel", &self.mco1sel())
.field("i2ssrc", &self.i2ssrc())
.field("mco1pre", &self.mco1pre())
.field("mco2pre", &self.mco2pre())
.field("mco2sel", &self.mco2sel())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Cfgr {
fn format(&self, f: defmt::Formatter) {
defmt :: write ! (f , "Cfgr {{ sw: {:?}, sws: {:?}, hpre: {:?}, ppre1: {:?}, ppre2: {:?}, rtcpre: {=u8:?}, mco1sel: {:?}, i2ssrc: {:?}, mco1pre: {:?}, mco2pre: {:?}, mco2sel: {:?} }}" , self . sw () , self . sws () , self . hpre () , self . ppre1 () , self . ppre2 () , self . rtcpre () , self . mco1sel () , self . i2ssrc () , self . mco1pre () , self . mco2pre () , self . mco2sel ())
}
}
#[doc = "clock interrupt register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Cir(pub u32);
impl Cir {
#[doc = "LSI ready interrupt flag"]
#[inline(always)]
pub const fn lsirdyf(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "LSI ready interrupt flag"]
#[inline(always)]
pub fn set_lsirdyf(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "LSE ready interrupt flag"]
#[inline(always)]
pub const fn lserdyf(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "LSE ready interrupt flag"]
#[inline(always)]
pub fn set_lserdyf(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "HSI ready interrupt flag"]
#[inline(always)]
pub const fn hsirdyf(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[doc = "HSI ready interrupt flag"]
#[inline(always)]
pub fn set_hsirdyf(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
#[doc = "HSE ready interrupt flag"]
#[inline(always)]
pub const fn hserdyf(&self) -> bool {
let val = (self.0 >> 3usize) & 0x01;
val != 0
}
#[doc = "HSE ready interrupt flag"]
#[inline(always)]
pub fn set_hserdyf(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
}
#[doc = "PLL ready interrupt flag"]
#[inline(always)]
pub const fn pllrdyf(&self) -> bool {
let val = (self.0 >> 4usize) & 0x01;
val != 0
}
#[doc = "PLL ready interrupt flag"]
#[inline(always)]
pub fn set_pllrdyf(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
}
#[doc = "PLLI2S ready interrupt flag"]
#[inline(always)]
pub const fn plli2srdyf(&self) -> bool {
let val = (self.0 >> 5usize) & 0x01;
val != 0
}
#[doc = "PLLI2S ready interrupt flag"]
#[inline(always)]
pub fn set_plli2srdyf(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
}
#[doc = "PLLSAI ready interrupt flag"]
#[inline(always)]
pub const fn pllsairdyf(&self) -> bool {
let val = (self.0 >> 6usize) & 0x01;
val != 0
}
#[doc = "PLLSAI ready interrupt flag"]
#[inline(always)]
pub fn set_pllsairdyf(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 6usize)) | (((val as u32) & 0x01) << 6usize);
}
#[doc = "Clock security system interrupt flag"]
#[inline(always)]
pub const fn cssf(&self) -> bool {
let val = (self.0 >> 7usize) & 0x01;
val != 0
}
#[doc = "Clock security system interrupt flag"]
#[inline(always)]
pub fn set_cssf(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 7usize)) | (((val as u32) & 0x01) << 7usize);
}
#[doc = "LSI ready interrupt enable"]
#[inline(always)]
pub const fn lsirdyie(&self) -> bool {
let val = (self.0 >> 8usize) & 0x01;
val != 0
}
#[doc = "LSI ready interrupt enable"]
#[inline(always)]
pub fn set_lsirdyie(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 8usize)) | (((val as u32) & 0x01) << 8usize);
}
#[doc = "LSE ready interrupt enable"]
#[inline(always)]
pub const fn lserdyie(&self) -> bool {
let val = (self.0 >> 9usize) & 0x01;
val != 0
}
#[doc = "LSE ready interrupt enable"]
#[inline(always)]
pub fn set_lserdyie(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 9usize)) | (((val as u32) & 0x01) << 9usize);
}
#[doc = "HSI ready interrupt enable"]
#[inline(always)]
pub const fn hsirdyie(&self) -> bool {
let val = (self.0 >> 10usize) & 0x01;
val != 0
}
#[doc = "HSI ready interrupt enable"]
#[inline(always)]
pub fn set_hsirdyie(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 10usize)) | (((val as u32) & 0x01) << 10usize);
}
#[doc = "HSE ready interrupt enable"]
#[inline(always)]
pub const fn hserdyie(&self) -> bool {
let val = (self.0 >> 11usize) & 0x01;
val != 0
}
#[doc = "HSE ready interrupt enable"]
#[inline(always)]
pub fn set_hserdyie(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 11usize)) | (((val as u32) & 0x01) << 11usize);
}
#[doc = "PLL ready interrupt enable"]
#[inline(always)]
pub const fn pllrdyie(&self) -> bool {
let val = (self.0 >> 12usize) & 0x01;
val != 0
}
#[doc = "PLL ready interrupt enable"]
#[inline(always)]
pub fn set_pllrdyie(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 12usize)) | (((val as u32) & 0x01) << 12usize);
}
#[doc = "PLLI2S ready interrupt enable"]
#[inline(always)]
pub const fn plli2srdyie(&self) -> bool {
let val = (self.0 >> 13usize) & 0x01;
val != 0
}
#[doc = "PLLI2S ready interrupt enable"]
#[inline(always)]
pub fn set_plli2srdyie(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 13usize)) | (((val as u32) & 0x01) << 13usize);
}
#[doc = "PLLSAI Ready Interrupt Enable"]
#[inline(always)]
pub const fn pllsairdyie(&self) -> bool {
let val = (self.0 >> 14usize) & 0x01;
val != 0
}
#[doc = "PLLSAI Ready Interrupt Enable"]
#[inline(always)]
pub fn set_pllsairdyie(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 14usize)) | (((val as u32) & 0x01) << 14usize);
}
#[doc = "LSI ready interrupt clear"]
#[inline(always)]
pub const fn lsirdyc(&self) -> bool {
let val = (self.0 >> 16usize) & 0x01;
val != 0
}
#[doc = "LSI ready interrupt clear"]
#[inline(always)]
pub fn set_lsirdyc(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 16usize)) | (((val as u32) & 0x01) << 16usize);
}
#[doc = "LSE ready interrupt clear"]
#[inline(always)]
pub const fn lserdyc(&self) -> bool {
let val = (self.0 >> 17usize) & 0x01;
val != 0
}
#[doc = "LSE ready interrupt clear"]
#[inline(always)]
pub fn set_lserdyc(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 17usize)) | (((val as u32) & 0x01) << 17usize);
}
#[doc = "HSI ready interrupt clear"]
#[inline(always)]
pub const fn hsirdyc(&self) -> bool {
let val = (self.0 >> 18usize) & 0x01;
val != 0
}
#[doc = "HSI ready interrupt clear"]
#[inline(always)]
pub fn set_hsirdyc(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 18usize)) | (((val as u32) & 0x01) << 18usize);
}
#[doc = "HSE ready interrupt clear"]
#[inline(always)]
pub const fn hserdyc(&self) -> bool {
let val = (self.0 >> 19usize) & 0x01;
val != 0
}
#[doc = "HSE ready interrupt clear"]
#[inline(always)]
pub fn set_hserdyc(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 19usize)) | (((val as u32) & 0x01) << 19usize);
}
#[doc = "Main PLL(PLL) ready interrupt clear"]
#[inline(always)]
pub const fn pllrdyc(&self) -> bool {
let val = (self.0 >> 20usize) & 0x01;
val != 0
}
#[doc = "Main PLL(PLL) ready interrupt clear"]
#[inline(always)]
pub fn set_pllrdyc(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 20usize)) | (((val as u32) & 0x01) << 20usize);
}
#[doc = "PLLI2S ready interrupt clear"]
#[inline(always)]
pub const fn plli2srdyc(&self) -> bool {
let val = (self.0 >> 21usize) & 0x01;
val != 0
}
#[doc = "PLLI2S ready interrupt clear"]
#[inline(always)]
pub fn set_plli2srdyc(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 21usize)) | (((val as u32) & 0x01) << 21usize);
}
#[doc = "PLLSAI Ready Interrupt Clear"]
#[inline(always)]
pub const fn pllsairdyc(&self) -> bool {
let val = (self.0 >> 22usize) & 0x01;
val != 0
}
#[doc = "PLLSAI Ready Interrupt Clear"]
#[inline(always)]
pub fn set_pllsairdyc(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 22usize)) | (((val as u32) & 0x01) << 22usize);
}
#[doc = "Clock security system interrupt clear"]
#[inline(always)]
pub const fn cssc(&self) -> bool {
let val = (self.0 >> 23usize) & 0x01;
val != 0
}
#[doc = "Clock security system interrupt clear"]
#[inline(always)]
pub fn set_cssc(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 23usize)) | (((val as u32) & 0x01) << 23usize);
}
}
impl Default for Cir {
#[inline(always)]
fn default() -> Cir {
Cir(0)
}
}
impl core::fmt::Debug for Cir {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Cir")
.field("lsirdyf", &self.lsirdyf())
.field("lserdyf", &self.lserdyf())
.field("hsirdyf", &self.hsirdyf())
.field("hserdyf", &self.hserdyf())
.field("pllrdyf", &self.pllrdyf())
.field("plli2srdyf", &self.plli2srdyf())
.field("pllsairdyf", &self.pllsairdyf())
.field("cssf", &self.cssf())
.field("lsirdyie", &self.lsirdyie())
.field("lserdyie", &self.lserdyie())
.field("hsirdyie", &self.hsirdyie())
.field("hserdyie", &self.hserdyie())
.field("pllrdyie", &self.pllrdyie())
.field("plli2srdyie", &self.plli2srdyie())
.field("pllsairdyie", &self.pllsairdyie())
.field("lsirdyc", &self.lsirdyc())
.field("lserdyc", &self.lserdyc())
.field("hsirdyc", &self.hsirdyc())
.field("hserdyc", &self.hserdyc())
.field("pllrdyc", &self.pllrdyc())
.field("plli2srdyc", &self.plli2srdyc())
.field("pllsairdyc", &self.pllsairdyc())
.field("cssc", &self.cssc())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Cir {
fn format(&self, f: defmt::Formatter) {
defmt :: write ! (f , "Cir {{ lsirdyf: {=bool:?}, lserdyf: {=bool:?}, hsirdyf: {=bool:?}, hserdyf: {=bool:?}, pllrdyf: {=bool:?}, plli2srdyf: {=bool:?}, pllsairdyf: {=bool:?}, cssf: {=bool:?}, lsirdyie: {=bool:?}, lserdyie: {=bool:?}, hsirdyie: {=bool:?}, hserdyie: {=bool:?}, pllrdyie: {=bool:?}, plli2srdyie: {=bool:?}, pllsairdyie: {=bool:?}, lsirdyc: {=bool:?}, lserdyc: {=bool:?}, hsirdyc: {=bool:?}, hserdyc: {=bool:?}, pllrdyc: {=bool:?}, plli2srdyc: {=bool:?}, pllsairdyc: {=bool:?}, cssc: {=bool:?} }}" , self . lsirdyf () , self . lserdyf () , self . hsirdyf () , self . hserdyf () , self . pllrdyf () , self . plli2srdyf () , self . pllsairdyf () , self . cssf () , self . lsirdyie () , self . lserdyie () , self . hsirdyie () , self . hserdyie () , self . pllrdyie () , self . plli2srdyie () , self . pllsairdyie () , self . lsirdyc () , self . lserdyc () , self . hsirdyc () , self . hserdyc () , self . pllrdyc () , self . plli2srdyc () , self . pllsairdyc () , self . cssc ())
}
}
#[doc = "clock control register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Cr(pub u32);
impl Cr {
#[doc = "Internal high-speed clock enable"]
#[inline(always)]
pub const fn hsion(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Internal high-speed clock enable"]
#[inline(always)]
pub fn set_hsion(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "Internal high-speed clock ready flag"]
#[inline(always)]
pub const fn hsirdy(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "Internal high-speed clock ready flag"]
#[inline(always)]
pub fn set_hsirdy(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "Internal high-speed clock trimming"]
#[inline(always)]
pub const fn hsitrim(&self) -> u8 {
let val = (self.0 >> 3usize) & 0x1f;
val as u8
}
#[doc = "Internal high-speed clock trimming"]
#[inline(always)]
pub fn set_hsitrim(&mut self, val: u8) {
self.0 = (self.0 & !(0x1f << 3usize)) | (((val as u32) & 0x1f) << 3usize);
}
#[doc = "Internal high-speed clock calibration"]
#[inline(always)]
pub const fn hsical(&self) -> u8 {
let val = (self.0 >> 8usize) & 0xff;
val as u8
}
#[doc = "Internal high-speed clock calibration"]
#[inline(always)]
pub fn set_hsical(&mut self, val: u8) {
self.0 = (self.0 & !(0xff << 8usize)) | (((val as u32) & 0xff) << 8usize);
}
#[doc = "HSE clock enable"]
#[inline(always)]
pub const fn hseon(&self) -> bool {
let val = (self.0 >> 16usize) & 0x01;
val != 0
}
#[doc = "HSE clock enable"]
#[inline(always)]
pub fn set_hseon(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 16usize)) | (((val as u32) & 0x01) << 16usize);
}
#[doc = "HSE clock ready flag"]
#[inline(always)]
pub const fn hserdy(&self) -> bool {
let val = (self.0 >> 17usize) & 0x01;
val != 0
}
#[doc = "HSE clock ready flag"]
#[inline(always)]
pub fn set_hserdy(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 17usize)) | (((val as u32) & 0x01) << 17usize);
}
#[doc = "HSE clock bypass"]
#[inline(always)]
pub const fn hsebyp(&self) -> bool {
let val = (self.0 >> 18usize) & 0x01;
val != 0
}
#[doc = "HSE clock bypass"]
#[inline(always)]
pub fn set_hsebyp(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 18usize)) | (((val as u32) & 0x01) << 18usize);
}
#[doc = "Clock security system enable"]
#[inline(always)]
pub const fn csson(&self) -> bool {
let val = (self.0 >> 19usize) & 0x01;
val != 0
}
#[doc = "Clock security system enable"]
#[inline(always)]
pub fn set_csson(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 19usize)) | (((val as u32) & 0x01) << 19usize);
}
#[doc = "PLL enable"]
#[inline(always)]
pub const fn pllon(&self) -> bool {
let val = (self.0 >> 24usize) & 0x01;
val != 0
}
#[doc = "PLL enable"]
#[inline(always)]
pub fn set_pllon(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 24usize)) | (((val as u32) & 0x01) << 24usize);
}
#[doc = "PLL clock ready flag"]
#[inline(always)]
pub const fn pllrdy(&self) -> bool {
let val = (self.0 >> 25usize) & 0x01;
val != 0
}
#[doc = "PLL clock ready flag"]
#[inline(always)]
pub fn set_pllrdy(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 25usize)) | (((val as u32) & 0x01) << 25usize);
}
#[doc = "PLLI2S enable"]
#[inline(always)]
pub const fn plli2son(&self) -> bool {
let val = (self.0 >> 26usize) & 0x01;
val != 0
}
#[doc = "PLLI2S enable"]
#[inline(always)]
pub fn set_plli2son(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 26usize)) | (((val as u32) & 0x01) << 26usize);
}
#[doc = "PLLI2S clock ready flag"]
#[inline(always)]
pub const fn plli2srdy(&self) -> bool {
let val = (self.0 >> 27usize) & 0x01;
val != 0
}
#[doc = "PLLI2S clock ready flag"]
#[inline(always)]
pub fn set_plli2srdy(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 27usize)) | (((val as u32) & 0x01) << 27usize);
}
#[doc = "PLLSAI enable"]
#[inline(always)]
pub const fn pllsaion(&self) -> bool {
let val = (self.0 >> 28usize) & 0x01;
val != 0
}
#[doc = "PLLSAI enable"]
#[inline(always)]
pub fn set_pllsaion(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 28usize)) | (((val as u32) & 0x01) << 28usize);
}
#[doc = "PLLSAI clock ready flag"]
#[inline(always)]
pub const fn pllsairdy(&self) -> bool {
let val = (self.0 >> 29usize) & 0x01;
val != 0
}
#[doc = "PLLSAI clock ready flag"]
#[inline(always)]
pub fn set_pllsairdy(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 29usize)) | (((val as u32) & 0x01) << 29usize);
}
}
impl Default for Cr {
#[inline(always)]
fn default() -> Cr {
Cr(0)
}
}
impl core::fmt::Debug for Cr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Cr")
.field("hsion", &self.hsion())
.field("hsirdy", &self.hsirdy())
.field("hsitrim", &self.hsitrim())
.field("hsical", &self.hsical())
.field("hseon", &self.hseon())
.field("hserdy", &self.hserdy())
.field("hsebyp", &self.hsebyp())
.field("csson", &self.csson())
.field("pllon", &self.pllon())
.field("pllrdy", &self.pllrdy())
.field("plli2son", &self.plli2son())
.field("plli2srdy", &self.plli2srdy())
.field("pllsaion", &self.pllsaion())
.field("pllsairdy", &self.pllsairdy())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Cr {
fn format(&self, f: defmt::Formatter) {
defmt :: write ! (f , "Cr {{ hsion: {=bool:?}, hsirdy: {=bool:?}, hsitrim: {=u8:?}, hsical: {=u8:?}, hseon: {=bool:?}, hserdy: {=bool:?}, hsebyp: {=bool:?}, csson: {=bool:?}, pllon: {=bool:?}, pllrdy: {=bool:?}, plli2son: {=bool:?}, plli2srdy: {=bool:?}, pllsaion: {=bool:?}, pllsairdy: {=bool:?} }}" , self . hsion () , self . hsirdy () , self . hsitrim () , self . hsical () , self . hseon () , self . hserdy () , self . hsebyp () , self . csson () , self . pllon () , self . pllrdy () , self . plli2son () , self . plli2srdy () , self . pllsaion () , self . pllsairdy ())
}
}
#[doc = "clock control & status register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Csr(pub u32);
impl Csr {
#[doc = "Internal low-speed oscillator enable"]
#[inline(always)]
pub const fn lsion(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Internal low-speed oscillator enable"]
#[inline(always)]
pub fn set_lsion(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "Internal low-speed oscillator ready"]
#[inline(always)]
pub const fn lsirdy(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "Internal low-speed oscillator ready"]
#[inline(always)]
pub fn set_lsirdy(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "Remove reset flag"]
#[inline(always)]
pub const fn rmvf(&self) -> bool {
let val = (self.0 >> 24usize) & 0x01;
val != 0
}
#[doc = "Remove reset flag"]
#[inline(always)]
pub fn set_rmvf(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 24usize)) | (((val as u32) & 0x01) << 24usize);
}
#[doc = "BOR reset flag"]
#[inline(always)]
pub const fn borrstf(&self) -> bool {
let val = (self.0 >> 25usize) & 0x01;
val != 0
}
#[doc = "BOR reset flag"]
#[inline(always)]
pub fn set_borrstf(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 25usize)) | (((val as u32) & 0x01) << 25usize);
}
#[doc = "PIN reset flag"]
#[inline(always)]
pub const fn padrstf(&self) -> bool {
let val = (self.0 >> 26usize) & 0x01;
val != 0
}
#[doc = "PIN reset flag"]
#[inline(always)]
pub fn set_padrstf(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 26usize)) | (((val as u32) & 0x01) << 26usize);
}
#[doc = "POR/PDR reset flag"]
#[inline(always)]
pub const fn porrstf(&self) -> bool {
let val = (self.0 >> 27usize) & 0x01;
val != 0
}
#[doc = "POR/PDR reset flag"]
#[inline(always)]
pub fn set_porrstf(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 27usize)) | (((val as u32) & 0x01) << 27usize);
}
#[doc = "Software reset flag"]
#[inline(always)]
pub const fn sftrstf(&self) -> bool {
let val = (self.0 >> 28usize) & 0x01;
val != 0
}
#[doc = "Software reset flag"]
#[inline(always)]
pub fn set_sftrstf(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 28usize)) | (((val as u32) & 0x01) << 28usize);
}
#[doc = "Independent watchdog reset flag"]
#[inline(always)]
pub const fn wdgrstf(&self) -> bool {
let val = (self.0 >> 29usize) & 0x01;
val != 0
}
#[doc = "Independent watchdog reset flag"]
#[inline(always)]
pub fn set_wdgrstf(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 29usize)) | (((val as u32) & 0x01) << 29usize);
}
#[doc = "Window watchdog reset flag"]
#[inline(always)]
pub const fn wwdgrstf(&self) -> bool {
let val = (self.0 >> 30usize) & 0x01;
val != 0
}
#[doc = "Window watchdog reset flag"]
#[inline(always)]
pub fn set_wwdgrstf(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 30usize)) | (((val as u32) & 0x01) << 30usize);
}
#[doc = "Low-power reset flag"]
#[inline(always)]
pub const fn lpwrrstf(&self) -> bool {
let val = (self.0 >> 31usize) & 0x01;
val != 0
}
#[doc = "Low-power reset flag"]
#[inline(always)]
pub fn set_lpwrrstf(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 31usize)) | (((val as u32) & 0x01) << 31usize);
}
}
impl Default for Csr {
#[inline(always)]
fn default() -> Csr {
Csr(0)
}
}
impl core::fmt::Debug for Csr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Csr")
.field("lsion", &self.lsion())
.field("lsirdy", &self.lsirdy())
.field("rmvf", &self.rmvf())
.field("borrstf", &self.borrstf())
.field("padrstf", &self.padrstf())
.field("porrstf", &self.porrstf())
.field("sftrstf", &self.sftrstf())
.field("wdgrstf", &self.wdgrstf())
.field("wwdgrstf", &self.wwdgrstf())
.field("lpwrrstf", &self.lpwrrstf())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Csr {
fn format(&self, f: defmt::Formatter) {
defmt :: write ! (f , "Csr {{ lsion: {=bool:?}, lsirdy: {=bool:?}, rmvf: {=bool:?}, borrstf: {=bool:?}, padrstf: {=bool:?}, porrstf: {=bool:?}, sftrstf: {=bool:?}, wdgrstf: {=bool:?}, wwdgrstf: {=bool:?}, lpwrrstf: {=bool:?} }}" , self . lsion () , self . lsirdy () , self . rmvf () , self . borrstf () , self . padrstf () , self . porrstf () , self . sftrstf () , self . wdgrstf () , self . wwdgrstf () , self . lpwrrstf ())
}
}
#[doc = "dedicated clocks configuration register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Dckcfgr1(pub u32);
impl Dckcfgr1 {
#[doc = "PLLI2S division factor for SAI1 clock"]
#[inline(always)]
pub const fn plli2sdivq(&self) -> super::vals::Plli2sdivq {
let val = (self.0 >> 0usize) & 0x1f;
super::vals::Plli2sdivq::from_bits(val as u8)
}
#[doc = "PLLI2S division factor for SAI1 clock"]
#[inline(always)]
pub fn set_plli2sdivq(&mut self, val: super::vals::Plli2sdivq) {
self.0 = (self.0 & !(0x1f << 0usize)) | (((val.to_bits() as u32) & 0x1f) << 0usize);
}
#[doc = "PLLSAI division factor for SAI1 clock"]
#[inline(always)]
pub const fn pllsaidivq(&self) -> super::vals::Pllsaidivq {
let val = (self.0 >> 8usize) & 0x1f;
super::vals::Pllsaidivq::from_bits(val as u8)
}
#[doc = "PLLSAI division factor for SAI1 clock"]
#[inline(always)]
pub fn set_pllsaidivq(&mut self, val: super::vals::Pllsaidivq) {
self.0 = (self.0 & !(0x1f << 8usize)) | (((val.to_bits() as u32) & 0x1f) << 8usize);
}
#[doc = "division factor for LCD_CLK"]
#[inline(always)]
pub const fn pllsaidivr(&self) -> super::vals::Pllsaidivr {
let val = (self.0 >> 16usize) & 0x03;
super::vals::Pllsaidivr::from_bits(val as u8)
}
#[doc = "division factor for LCD_CLK"]
#[inline(always)]
pub fn set_pllsaidivr(&mut self, val: super::vals::Pllsaidivr) {
self.0 = (self.0 & !(0x03 << 16usize)) | (((val.to_bits() as u32) & 0x03) << 16usize);
}
#[doc = "SAI1 clock source selection"]
#[inline(always)]
pub const fn sai1sel(&self) -> super::vals::Saisel {
let val = (self.0 >> 20usize) & 0x03;
super::vals::Saisel::from_bits(val as u8)
}
#[doc = "SAI1 clock source selection"]
#[inline(always)]
pub fn set_sai1sel(&mut self, val: super::vals::Saisel) {
self.0 = (self.0 & !(0x03 << 20usize)) | (((val.to_bits() as u32) & 0x03) << 20usize);
}
#[doc = "SAI2 clock source selection"]
#[inline(always)]
pub const fn sai2sel(&self) -> super::vals::Saisel {
let val = (self.0 >> 22usize) & 0x03;
super::vals::Saisel::from_bits(val as u8)
}
#[doc = "SAI2 clock source selection"]
#[inline(always)]
pub fn set_sai2sel(&mut self, val: super::vals::Saisel) {
self.0 = (self.0 & !(0x03 << 22usize)) | (((val.to_bits() as u32) & 0x03) << 22usize);
}
#[doc = "Timers clocks prescalers selection"]
#[inline(always)]
pub const fn timpre(&self) -> super::vals::Timpre {
let val = (self.0 >> 24usize) & 0x01;
super::vals::Timpre::from_bits(val as u8)
}
#[doc = "Timers clocks prescalers selection"]
#[inline(always)]
pub fn set_timpre(&mut self, val: super::vals::Timpre) {
self.0 = (self.0 & !(0x01 << 24usize)) | (((val.to_bits() as u32) & 0x01) << 24usize);
}
#[doc = "DFSDM1 clock source selection"]
#[inline(always)]
pub const fn dfsdm1sel(&self) -> super::vals::Dfsdmsel {
let val = (self.0 >> 25usize) & 0x01;
super::vals::Dfsdmsel::from_bits(val as u8)
}
#[doc = "DFSDM1 clock source selection"]
#[inline(always)]
pub fn set_dfsdm1sel(&mut self, val: super::vals::Dfsdmsel) {
self.0 = (self.0 & !(0x01 << 25usize)) | (((val.to_bits() as u32) & 0x01) << 25usize);
}
#[doc = "DFSDM1 AUDIO clock source selection"]
#[inline(always)]
pub const fn adfsdm1sel(&self) -> super::vals::Adfsdmsel {
let val = (self.0 >> 26usize) & 0x01;
super::vals::Adfsdmsel::from_bits(val as u8)
}
#[doc = "DFSDM1 AUDIO clock source selection"]
#[inline(always)]
pub fn set_adfsdm1sel(&mut self, val: super::vals::Adfsdmsel) {
self.0 = (self.0 & !(0x01 << 26usize)) | (((val.to_bits() as u32) & 0x01) << 26usize);
}
}
impl Default for Dckcfgr1 {
#[inline(always)]
fn default() -> Dckcfgr1 {
Dckcfgr1(0)
}
}
impl core::fmt::Debug for Dckcfgr1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Dckcfgr1")
.field("plli2sdivq", &self.plli2sdivq())
.field("pllsaidivq", &self.pllsaidivq())
.field("pllsaidivr", &self.pllsaidivr())
.field("sai1sel", &self.sai1sel())
.field("sai2sel", &self.sai2sel())
.field("timpre", &self.timpre())
.field("dfsdm1sel", &self.dfsdm1sel())
.field("adfsdm1sel", &self.adfsdm1sel())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Dckcfgr1 {
fn format(&self, f: defmt::Formatter) {
defmt :: write ! (f , "Dckcfgr1 {{ plli2sdivq: {:?}, pllsaidivq: {:?}, pllsaidivr: {:?}, sai1sel: {:?}, sai2sel: {:?}, timpre: {:?}, dfsdm1sel: {:?}, adfsdm1sel: {:?} }}" , self . plli2sdivq () , self . pllsaidivq () , self . pllsaidivr () , self . sai1sel () , self . sai2sel () , self . timpre () , self . dfsdm1sel () , self . adfsdm1sel ())
}
}
#[doc = "dedicated clocks configuration register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Dckcfgr2(pub u32);
impl Dckcfgr2 {
#[doc = "USART 1 clock source selection"]
#[inline(always)]
pub const fn usart1sel(&self) -> super::vals::Usart1sel {
let val = (self.0 >> 0usize) & 0x03;
super::vals::Usart1sel::from_bits(val as u8)
}
#[doc = "USART 1 clock source selection"]
#[inline(always)]
pub fn set_usart1sel(&mut self, val: super::vals::Usart1sel) {
self.0 = (self.0 & !(0x03 << 0usize)) | (((val.to_bits() as u32) & 0x03) << 0usize);
}
#[doc = "USART 2 clock source selection"]
#[inline(always)]
pub const fn usart2sel(&self) -> super::vals::Usart2sel {
let val = (self.0 >> 2usize) & 0x03;
super::vals::Usart2sel::from_bits(val as u8)
}
#[doc = "USART 2 clock source selection"]
#[inline(always)]
pub fn set_usart2sel(&mut self, val: super::vals::Usart2sel) {
self.0 = (self.0 & !(0x03 << 2usize)) | (((val.to_bits() as u32) & 0x03) << 2usize);
}
#[doc = "USART 3 clock source selection"]
#[inline(always)]
pub const fn usart3sel(&self) -> super::vals::Usart2sel {
let val = (self.0 >> 4usize) & 0x03;
super::vals::Usart2sel::from_bits(val as u8)
}
#[doc = "USART 3 clock source selection"]
#[inline(always)]
pub fn set_usart3sel(&mut self, val: super::vals::Usart2sel) {
self.0 = (self.0 & !(0x03 << 4usize)) | (((val.to_bits() as u32) & 0x03) << 4usize);
}
#[doc = "UART 4 clock source selection"]
#[inline(always)]
pub const fn uart4sel(&self) -> super::vals::Usart2sel {
let val = (self.0 >> 6usize) & 0x03;
super::vals::Usart2sel::from_bits(val as u8)
}
#[doc = "UART 4 clock source selection"]
#[inline(always)]
pub fn set_uart4sel(&mut self, val: super::vals::Usart2sel) {
self.0 = (self.0 & !(0x03 << 6usize)) | (((val.to_bits() as u32) & 0x03) << 6usize);
}
#[doc = "UART 5 clock source selection"]
#[inline(always)]
pub const fn uart5sel(&self) -> super::vals::Usart2sel {
let val = (self.0 >> 8usize) & 0x03;
super::vals::Usart2sel::from_bits(val as u8)
}
#[doc = "UART 5 clock source selection"]
#[inline(always)]
pub fn set_uart5sel(&mut self, val: super::vals::Usart2sel) {
self.0 = (self.0 & !(0x03 << 8usize)) | (((val.to_bits() as u32) & 0x03) << 8usize);
}
#[doc = "USART 6 clock source selection"]
#[inline(always)]
pub const fn usart6sel(&self) -> super::vals::Usart1sel {
let val = (self.0 >> 10usize) & 0x03;
super::vals::Usart1sel::from_bits(val as u8)
}
#[doc = "USART 6 clock source selection"]
#[inline(always)]
pub fn set_usart6sel(&mut self, val: super::vals::Usart1sel) {
self.0 = (self.0 & !(0x03 << 10usize)) | (((val.to_bits() as u32) & 0x03) << 10usize);
}
#[doc = "UART 7 clock source selection"]
#[inline(always)]
pub const fn uart7sel(&self) -> super::vals::Usart2sel {
let val = (self.0 >> 12usize) & 0x03;
super::vals::Usart2sel::from_bits(val as u8)
}
#[doc = "UART 7 clock source selection"]
#[inline(always)]
pub fn set_uart7sel(&mut self, val: super::vals::Usart2sel) {
self.0 = (self.0 & !(0x03 << 12usize)) | (((val.to_bits() as u32) & 0x03) << 12usize);
}
#[doc = "UART 8 clock source selection"]
#[inline(always)]
pub const fn uart8sel(&self) -> super::vals::Usart2sel {
let val = (self.0 >> 14usize) & 0x03;
super::vals::Usart2sel::from_bits(val as u8)
}
#[doc = "UART 8 clock source selection"]
#[inline(always)]
pub fn set_uart8sel(&mut self, val: super::vals::Usart2sel) {
self.0 = (self.0 & !(0x03 << 14usize)) | (((val.to_bits() as u32) & 0x03) << 14usize);
}
#[doc = "I2C1 clock source selection"]
#[inline(always)]
pub const fn i2c1sel(&self) -> super::vals::I2csel {
let val = (self.0 >> 16usize) & 0x03;
super::vals::I2csel::from_bits(val as u8)
}
#[doc = "I2C1 clock source selection"]
#[inline(always)]
pub fn set_i2c1sel(&mut self, val: super::vals::I2csel) {
self.0 = (self.0 & !(0x03 << 16usize)) | (((val.to_bits() as u32) & 0x03) << 16usize);
}
#[doc = "I2C2 clock source selection"]
#[inline(always)]
pub const fn i2c2sel(&self) -> super::vals::I2csel {
let val = (self.0 >> 18usize) & 0x03;
super::vals::I2csel::from_bits(val as u8)
}
#[doc = "I2C2 clock source selection"]
#[inline(always)]
pub fn set_i2c2sel(&mut self, val: super::vals::I2csel) {
self.0 = (self.0 & !(0x03 << 18usize)) | (((val.to_bits() as u32) & 0x03) << 18usize);
}
#[doc = "I2C3 clock source selection"]
#[inline(always)]
pub const fn i2c3sel(&self) -> super::vals::I2csel {
let val = (self.0 >> 20usize) & 0x03;
super::vals::I2csel::from_bits(val as u8)
}
#[doc = "I2C3 clock source selection"]
#[inline(always)]
pub fn set_i2c3sel(&mut self, val: super::vals::I2csel) {
self.0 = (self.0 & !(0x03 << 20usize)) | (((val.to_bits() as u32) & 0x03) << 20usize);
}
#[doc = "I2C4 clock source selection"]
#[inline(always)]
pub const fn i2c4sel(&self) -> super::vals::I2csel {
let val = (self.0 >> 22usize) & 0x03;
super::vals::I2csel::from_bits(val as u8)
}
#[doc = "I2C4 clock source selection"]
#[inline(always)]
pub fn set_i2c4sel(&mut self, val: super::vals::I2csel) {
self.0 = (self.0 & !(0x03 << 22usize)) | (((val.to_bits() as u32) & 0x03) << 22usize);
}
#[doc = "Low power timer 1 clock source selection"]
#[inline(always)]
pub const fn lptim1sel(&self) -> super::vals::Lptimsel {
let val = (self.0 >> 24usize) & 0x03;
super::vals::Lptimsel::from_bits(val as u8)
}
#[doc = "Low power timer 1 clock source selection"]
#[inline(always)]
pub fn set_lptim1sel(&mut self, val: super::vals::Lptimsel) {
self.0 = (self.0 & !(0x03 << 24usize)) | (((val.to_bits() as u32) & 0x03) << 24usize);
}
#[doc = "HDMI-CEC clock source selection"]
#[inline(always)]
pub const fn cecsel(&self) -> super::vals::Cecsel {
let val = (self.0 >> 26usize) & 0x01;
super::vals::Cecsel::from_bits(val as u8)
}
#[doc = "HDMI-CEC clock source selection"]
#[inline(always)]
pub fn set_cecsel(&mut self, val: super::vals::Cecsel) {
self.0 = (self.0 & !(0x01 << 26usize)) | (((val.to_bits() as u32) & 0x01) << 26usize);
}
#[doc = "48MHz clock source selection"]
#[inline(always)]
pub const fn clk48sel(&self) -> super::vals::Clk48sel {
let val = (self.0 >> 27usize) & 0x01;
super::vals::Clk48sel::from_bits(val as u8)
}
#[doc = "48MHz clock source selection"]
#[inline(always)]
pub fn set_clk48sel(&mut self, val: super::vals::Clk48sel) {
self.0 = (self.0 & !(0x01 << 27usize)) | (((val.to_bits() as u32) & 0x01) << 27usize);
}
#[doc = "SDMMC1 clock source selection"]
#[inline(always)]
pub const fn sdmmc1sel(&self) -> super::vals::Sdmmcsel {
let val = (self.0 >> 28usize) & 0x01;
super::vals::Sdmmcsel::from_bits(val as u8)
}
#[doc = "SDMMC1 clock source selection"]
#[inline(always)]
pub fn set_sdmmc1sel(&mut self, val: super::vals::Sdmmcsel) {
self.0 = (self.0 & !(0x01 << 28usize)) | (((val.to_bits() as u32) & 0x01) << 28usize);
}
#[doc = "SDMMC2 clock source selection"]
#[inline(always)]
pub const fn sdmmc2sel(&self) -> super::vals::Sdmmcsel {
let val = (self.0 >> 29usize) & 0x01;
super::vals::Sdmmcsel::from_bits(val as u8)
}
#[doc = "SDMMC2 clock source selection"]
#[inline(always)]
pub fn set_sdmmc2sel(&mut self, val: super::vals::Sdmmcsel) {
self.0 = (self.0 & !(0x01 << 29usize)) | (((val.to_bits() as u32) & 0x01) << 29usize);
}
#[doc = "DSI clock source selection"]
#[inline(always)]
pub const fn dsisel(&self) -> super::vals::Dsisel {
let val = (self.0 >> 30usize) & 0x01;
super::vals::Dsisel::from_bits(val as u8)
}
#[doc = "DSI clock source selection"]
#[inline(always)]
pub fn set_dsisel(&mut self, val: super::vals::Dsisel) {
self.0 = (self.0 & !(0x01 << 30usize)) | (((val.to_bits() as u32) & 0x01) << 30usize);
}
}
impl Default for Dckcfgr2 {
#[inline(always)]
fn default() -> Dckcfgr2 {
Dckcfgr2(0)
}
}
impl core::fmt::Debug for Dckcfgr2 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Dckcfgr2")
.field("usart1sel", &self.usart1sel())
.field("usart2sel", &self.usart2sel())
.field("usart3sel", &self.usart3sel())
.field("uart4sel", &self.uart4sel())
.field("uart5sel", &self.uart5sel())
.field("usart6sel", &self.usart6sel())
.field("uart7sel", &self.uart7sel())
.field("uart8sel", &self.uart8sel())
.field("i2c1sel", &self.i2c1sel())
.field("i2c2sel", &self.i2c2sel())
.field("i2c3sel", &self.i2c3sel())
.field("i2c4sel", &self.i2c4sel())
.field("lptim1sel", &self.lptim1sel())
.field("cecsel", &self.cecsel())
.field("clk48sel", &self.clk48sel())
.field("sdmmc1sel", &self.sdmmc1sel())
.field("sdmmc2sel", &self.sdmmc2sel())
.field("dsisel", &self.dsisel())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Dckcfgr2 {
fn format(&self, f: defmt::Formatter) {
defmt :: write ! (f , "Dckcfgr2 {{ usart1sel: {:?}, usart2sel: {:?}, usart3sel: {:?}, uart4sel: {:?}, uart5sel: {:?}, usart6sel: {:?}, uart7sel: {:?}, uart8sel: {:?}, i2c1sel: {:?}, i2c2sel: {:?}, i2c3sel: {:?}, i2c4sel: {:?}, lptim1sel: {:?}, cecsel: {:?}, clk48sel: {:?}, sdmmc1sel: {:?}, sdmmc2sel: {:?}, dsisel: {:?} }}" , self . usart1sel () , self . usart2sel () , self . usart3sel () , self . uart4sel () , self . uart5sel () , self . usart6sel () , self . uart7sel () , self . uart8sel () , self . i2c1sel () , self . i2c2sel () , self . i2c3sel () , self . i2c4sel () , self . lptim1sel () , self . cecsel () , self . clk48sel () , self . sdmmc1sel () , self . sdmmc2sel () , self . dsisel ())
}
}
#[doc = "PLL configuration register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Pllcfgr(pub u32);
impl Pllcfgr {
#[doc = "Division factor for the PLL and audio PLL (PLLI2S) input clock"]
#[inline(always)]
pub const fn pllm(&self) -> super::vals::Pllm {
let val = (self.0 >> 0usize) & 0x3f;
super::vals::Pllm::from_bits(val as u8)
}
#[doc = "Division factor for the PLL and audio PLL (PLLI2S) input clock"]
#[inline(always)]
pub fn set_pllm(&mut self, val: super::vals::Pllm) {
self.0 = (self.0 & !(0x3f << 0usize)) | (((val.to_bits() as u32) & 0x3f) << 0usize);
}
#[doc = "PLL multiplication factor for VCO"]
#[inline(always)]
pub const fn plln(&self) -> super::vals::Plln {
let val = (self.0 >> 6usize) & 0x01ff;
super::vals::Plln::from_bits(val as u16)
}
#[doc = "PLL multiplication factor for VCO"]
#[inline(always)]
pub fn set_plln(&mut self, val: super::vals::Plln) {
self.0 = (self.0 & !(0x01ff << 6usize)) | (((val.to_bits() as u32) & 0x01ff) << 6usize);
}
#[doc = "PLL division factor for main system clock"]
#[inline(always)]
pub const fn pllp(&self) -> super::vals::Pllp {
let val = (self.0 >> 16usize) & 0x03;
super::vals::Pllp::from_bits(val as u8)
}
#[doc = "PLL division factor for main system clock"]
#[inline(always)]
pub fn set_pllp(&mut self, val: super::vals::Pllp) {
self.0 = (self.0 & !(0x03 << 16usize)) | (((val.to_bits() as u32) & 0x03) << 16usize);
}
#[doc = "PLL and audio PLL (PLLI2S, PLLSAI) entry clock source"]
#[inline(always)]
pub const fn pllsrc(&self) -> super::vals::Pllsrc {
let val = (self.0 >> 22usize) & 0x01;
super::vals::Pllsrc::from_bits(val as u8)
}
#[doc = "PLL and audio PLL (PLLI2S, PLLSAI) entry clock source"]
#[inline(always)]
pub fn set_pllsrc(&mut self, val: super::vals::Pllsrc) {
self.0 = (self.0 & !(0x01 << 22usize)) | (((val.to_bits() as u32) & 0x01) << 22usize);
}
#[doc = "PLL division factor for USB OTG FS, SDIO and random number generator clocks"]
#[inline(always)]
pub const fn pllq(&self) -> super::vals::Pllq {
let val = (self.0 >> 24usize) & 0x0f;
super::vals::Pllq::from_bits(val as u8)
}
#[doc = "PLL division factor for USB OTG FS, SDIO and random number generator clocks"]
#[inline(always)]
pub fn set_pllq(&mut self, val: super::vals::Pllq) {
self.0 = (self.0 & !(0x0f << 24usize)) | (((val.to_bits() as u32) & 0x0f) << 24usize);
}
#[doc = "PLL division factor for DSI clock"]
#[inline(always)]
pub const fn pllr(&self) -> super::vals::Pllr {
let val = (self.0 >> 28usize) & 0x07;
super::vals::Pllr::from_bits(val as u8)
}
#[doc = "PLL division factor for DSI clock"]
#[inline(always)]
pub fn set_pllr(&mut self, val: super::vals::Pllr) {
self.0 = (self.0 & !(0x07 << 28usize)) | (((val.to_bits() as u32) & 0x07) << 28usize);
}
}
impl Default for Pllcfgr {
#[inline(always)]
fn default() -> Pllcfgr {
Pllcfgr(0)
}
}
impl core::fmt::Debug for Pllcfgr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Pllcfgr")
.field("pllm", &self.pllm())
.field("plln", &self.plln())
.field("pllp", &self.pllp())
.field("pllsrc", &self.pllsrc())
.field("pllq", &self.pllq())
.field("pllr", &self.pllr())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Pllcfgr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Pllcfgr {{ pllm: {:?}, plln: {:?}, pllp: {:?}, pllsrc: {:?}, pllq: {:?}, pllr: {:?} }}",
self.pllm(),
self.plln(),
self.pllp(),
self.pllsrc(),
self.pllq(),
self.pllr()
)
}
}
#[doc = "PLLI2S configuration register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Plli2scfgr(pub u32);
impl Plli2scfgr {
#[doc = "PLL multiplication factor for VCO"]
#[inline(always)]
pub const fn plln(&self) -> super::vals::Plln {
let val = (self.0 >> 6usize) & 0x01ff;
super::vals::Plln::from_bits(val as u16)
}
#[doc = "PLL multiplication factor for VCO"]
#[inline(always)]
pub fn set_plln(&mut self, val: super::vals::Plln) {
self.0 = (self.0 & !(0x01ff << 6usize)) | (((val.to_bits() as u32) & 0x01ff) << 6usize);
}
#[doc = "PLL division factor for main system clock"]
#[inline(always)]
pub const fn pllp(&self) -> super::vals::Pllp {
let val = (self.0 >> 16usize) & 0x03;
super::vals::Pllp::from_bits(val as u8)
}
#[doc = "PLL division factor for main system clock"]
#[inline(always)]
pub fn set_pllp(&mut self, val: super::vals::Pllp) {
self.0 = (self.0 & !(0x03 << 16usize)) | (((val.to_bits() as u32) & 0x03) << 16usize);
}
#[doc = "PLL division factor for USB OTG FS, SDIO and random number generator clocks"]
#[inline(always)]
pub const fn pllq(&self) -> super::vals::Pllq {
let val = (self.0 >> 24usize) & 0x0f;
super::vals::Pllq::from_bits(val as u8)
}
#[doc = "PLL division factor for USB OTG FS, SDIO and random number generator clocks"]
#[inline(always)]
pub fn set_pllq(&mut self, val: super::vals::Pllq) {
self.0 = (self.0 & !(0x0f << 24usize)) | (((val.to_bits() as u32) & 0x0f) << 24usize);
}
#[doc = "PLL division factor for DSI clock"]
#[inline(always)]
pub const fn pllr(&self) -> super::vals::Pllr {
let val = (self.0 >> 28usize) & 0x07;
super::vals::Pllr::from_bits(val as u8)
}
#[doc = "PLL division factor for DSI clock"]
#[inline(always)]
pub fn set_pllr(&mut self, val: super::vals::Pllr) {
self.0 = (self.0 & !(0x07 << 28usize)) | (((val.to_bits() as u32) & 0x07) << 28usize);
}
}
impl Default for Plli2scfgr {
#[inline(always)]
fn default() -> Plli2scfgr {
Plli2scfgr(0)
}
}
impl core::fmt::Debug for Plli2scfgr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Plli2scfgr")
.field("plln", &self.plln())
.field("pllp", &self.pllp())
.field("pllq", &self.pllq())
.field("pllr", &self.pllr())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Plli2scfgr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Plli2scfgr {{ plln: {:?}, pllp: {:?}, pllq: {:?}, pllr: {:?} }}",
self.plln(),
self.pllp(),
self.pllq(),
self.pllr()
)
}
}
#[doc = "PLL configuration register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Pllsaicfgr(pub u32);
impl Pllsaicfgr {
#[doc = "PLL multiplication factor for VCO"]
#[inline(always)]
pub const fn plln(&self) -> super::vals::Plln {
let val = (self.0 >> 6usize) & 0x01ff;
super::vals::Plln::from_bits(val as u16)
}
#[doc = "PLL multiplication factor for VCO"]
#[inline(always)]
pub fn set_plln(&mut self, val: super::vals::Plln) {
self.0 = (self.0 & !(0x01ff << 6usize)) | (((val.to_bits() as u32) & 0x01ff) << 6usize);
}
#[doc = "PLL division factor for main system clock"]
#[inline(always)]
pub const fn pllp(&self) -> super::vals::Pllp {
let val = (self.0 >> 16usize) & 0x03;
super::vals::Pllp::from_bits(val as u8)
}
#[doc = "PLL division factor for main system clock"]
#[inline(always)]
pub fn set_pllp(&mut self, val: super::vals::Pllp) {
self.0 = (self.0 & !(0x03 << 16usize)) | (((val.to_bits() as u32) & 0x03) << 16usize);
}
#[doc = "PLL division factor for USB OTG FS, SDIO and random number generator clocks"]
#[inline(always)]
pub const fn pllq(&self) -> super::vals::Pllq {
let val = (self.0 >> 24usize) & 0x0f;
super::vals::Pllq::from_bits(val as u8)
}
#[doc = "PLL division factor for USB OTG FS, SDIO and random number generator clocks"]
#[inline(always)]
pub fn set_pllq(&mut self, val: super::vals::Pllq) {
self.0 = (self.0 & !(0x0f << 24usize)) | (((val.to_bits() as u32) & 0x0f) << 24usize);
}
#[doc = "PLL division factor for DSI clock"]
#[inline(always)]
pub const fn pllr(&self) -> super::vals::Pllr {
let val = (self.0 >> 28usize) & 0x07;
super::vals::Pllr::from_bits(val as u8)
}
#[doc = "PLL division factor for DSI clock"]
#[inline(always)]
pub fn set_pllr(&mut self, val: super::vals::Pllr) {
self.0 = (self.0 & !(0x07 << 28usize)) | (((val.to_bits() as u32) & 0x07) << 28usize);
}
}
impl Default for Pllsaicfgr {
#[inline(always)]
fn default() -> Pllsaicfgr {
Pllsaicfgr(0)
}
}
impl core::fmt::Debug for Pllsaicfgr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Pllsaicfgr")
.field("plln", &self.plln())
.field("pllp", &self.pllp())
.field("pllq", &self.pllq())
.field("pllr", &self.pllr())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Pllsaicfgr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Pllsaicfgr {{ plln: {:?}, pllp: {:?}, pllq: {:?}, pllr: {:?} }}",
self.plln(),
self.pllp(),
self.pllq(),
self.pllr()
)
}
}
#[doc = "spread spectrum clock generation register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Sscgr(pub u32);
impl Sscgr {
#[doc = "Modulation period"]
#[inline(always)]
pub const fn modper(&self) -> u16 {
let val = (self.0 >> 0usize) & 0x1fff;
val as u16
}
#[doc = "Modulation period"]
#[inline(always)]
pub fn set_modper(&mut self, val: u16) {
self.0 = (self.0 & !(0x1fff << 0usize)) | (((val as u32) & 0x1fff) << 0usize);
}
#[doc = "Incrementation step"]
#[inline(always)]
pub const fn incstep(&self) -> u16 {
let val = (self.0 >> 13usize) & 0x7fff;
val as u16
}
#[doc = "Incrementation step"]
#[inline(always)]
pub fn set_incstep(&mut self, val: u16) {
self.0 = (self.0 & !(0x7fff << 13usize)) | (((val as u32) & 0x7fff) << 13usize);
}
#[doc = "Spread Select"]
#[inline(always)]
pub const fn spreadsel(&self) -> super::vals::Spreadsel {
let val = (self.0 >> 30usize) & 0x01;
super::vals::Spreadsel::from_bits(val as u8)
}
#[doc = "Spread Select"]
#[inline(always)]
pub fn set_spreadsel(&mut self, val: super::vals::Spreadsel) {
self.0 = (self.0 & !(0x01 << 30usize)) | (((val.to_bits() as u32) & 0x01) << 30usize);
}
#[doc = "Spread spectrum modulation enable"]
#[inline(always)]
pub const fn sscgen(&self) -> bool {
let val = (self.0 >> 31usize) & 0x01;
val != 0
}
#[doc = "Spread spectrum modulation enable"]
#[inline(always)]
pub fn set_sscgen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 31usize)) | (((val as u32) & 0x01) << 31usize);
}
}
impl Default for Sscgr {
#[inline(always)]
fn default() -> Sscgr {
Sscgr(0)
}
}
impl core::fmt::Debug for Sscgr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Sscgr")
.field("modper", &self.modper())
.field("incstep", &self.incstep())
.field("spreadsel", &self.spreadsel())
.field("sscgen", &self.sscgen())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Sscgr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Sscgr {{ modper: {=u16:?}, incstep: {=u16:?}, spreadsel: {:?}, sscgen: {=bool:?} }}",
self.modper(),
self.incstep(),
self.spreadsel(),
self.sscgen()
)
}
}
}
pub mod vals {
#[repr(u8)]
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum Adfsdmsel {
#[doc = "SAI1 clock selected as DFSDM1 Audio clock source"]
SAI1 = 0x0,
#[doc = "SAI2 clock selected as DFSDM1 Audio clock source"]
SAI2 = 0x01,
}
impl Adfsdmsel {
#[inline(always)]
pub const fn from_bits(val: u8) -> Adfsdmsel {
unsafe { core::mem::transmute(val & 0x01) }
}
#[inline(always)]
pub const fn to_bits(self) -> u8 {
unsafe { core::mem::transmute(self) }
}
}
impl From<u8> for Adfsdmsel {
#[inline(always)]
fn from(val: u8) -> Adfsdmsel {
Adfsdmsel::from_bits(val)
}
}
impl From<Adfsdmsel> for u8 {
#[inline(always)]
fn from(val: Adfsdmsel) -> u8 {
Adfsdmsel::to_bits(val)
}
}
#[repr(u8)]
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum Cecsel {
#[doc = "LSE clock is selected as HDMI-CEC clock"]
LSE = 0x0,
#[doc = "HSI divided by 488 clock is selected as HDMI-CEC clock"]
HSI_DIV_488 = 0x01,
}
impl Cecsel {
#[inline(always)]
pub const fn from_bits(val: u8) -> Cecsel {
unsafe { core::mem::transmute(val & 0x01) }
}
#[inline(always)]
pub const fn to_bits(self) -> u8 {
unsafe { core::mem::transmute(self) }
}
}
impl From<u8> for Cecsel {
#[inline(always)]
fn from(val: u8) -> Cecsel {
Cecsel::from_bits(val)
}
}
impl From<Cecsel> for u8 {
#[inline(always)]
fn from(val: Cecsel) -> u8 {
Cecsel::to_bits(val)
}
}
#[repr(u8)]
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum Clk48sel {
#[doc = "48MHz clock from PLL is selected"]
PLL1_Q = 0x0,
#[doc = "48MHz clock from PLLSAI is selected"]
PLLSAI1_P = 0x01,
}
impl Clk48sel {
#[inline(always)]
pub const fn from_bits(val: u8) -> Clk48sel {
unsafe { core::mem::transmute(val & 0x01) }
}
#[inline(always)]
pub const fn to_bits(self) -> u8 {
unsafe { core::mem::transmute(self) }
}
}
impl From<u8> for Clk48sel {
#[inline(always)]
fn from(val: u8) -> Clk48sel {
Clk48sel::from_bits(val)
}
}
impl From<Clk48sel> for u8 {
#[inline(always)]
fn from(val: Clk48sel) -> u8 {
Clk48sel::to_bits(val)
}
}
#[repr(u8)]
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum Dfsdmsel {
#[doc = "APB2 clock (PCLK2) selected as DFSDM1 Kernel clock source"]
PCLK2 = 0x0,
#[doc = "System clock (SYSCLK) clock selected as DFSDM1 Kernel clock source"]
SYS = 0x01,
}
impl Dfsdmsel {
#[inline(always)]
pub const fn from_bits(val: u8) -> Dfsdmsel {
unsafe { core::mem::transmute(val & 0x01) }
}
#[inline(always)]
pub const fn to_bits(self) -> u8 {
unsafe { core::mem::transmute(self) }
}
}
impl From<u8> for Dfsdmsel {
#[inline(always)]
fn from(val: u8) -> Dfsdmsel {
Dfsdmsel::from_bits(val)
}
}
impl From<Dfsdmsel> for u8 {
#[inline(always)]
fn from(val: Dfsdmsel) -> u8 {
Dfsdmsel::to_bits(val)
}
}
#[repr(u8)]
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum Dsisel {
#[doc = "DSI-PHY used as DSI byte lane clock source (usual case)"]
DSI_PHY = 0x0,
#[doc = "PLLR used as DSI byte lane clock source, used in case DSI PLL and DSI-PHY are off (low power mode)"]
PLL1_R = 0x01,
}
impl Dsisel {
#[inline(always)]
pub const fn from_bits(val: u8) -> Dsisel {
unsafe { core::mem::transmute(val & 0x01) }
}
#[inline(always)]
pub const fn to_bits(self) -> u8 {
unsafe { core::mem::transmute(self) }
}
}
impl From<u8> for Dsisel {
#[inline(always)]
fn from(val: u8) -> Dsisel {
Dsisel::from_bits(val)
}
}
impl From<Dsisel> for u8 {
#[inline(always)]
fn from(val: Dsisel) -> u8 {
Dsisel::to_bits(val)
}
}
#[repr(u8)]
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum Hpre {
#[doc = "SYSCLK not divided"]
DIV1 = 0x0,
_RESERVED_1 = 0x01,
_RESERVED_2 = 0x02,
_RESERVED_3 = 0x03,
_RESERVED_4 = 0x04,
_RESERVED_5 = 0x05,
_RESERVED_6 = 0x06,
_RESERVED_7 = 0x07,
#[doc = "SYSCLK divided by 2"]
DIV2 = 0x08,
#[doc = "SYSCLK divided by 4"]
DIV4 = 0x09,
#[doc = "SYSCLK divided by 8"]
DIV8 = 0x0a,
#[doc = "SYSCLK divided by 16"]
DIV16 = 0x0b,
#[doc = "SYSCLK divided by 64"]
DIV64 = 0x0c,
#[doc = "SYSCLK divided by 128"]
DIV128 = 0x0d,
#[doc = "SYSCLK divided by 256"]
DIV256 = 0x0e,
#[doc = "SYSCLK divided by 512"]
DIV512 = 0x0f,
}
impl Hpre {
#[inline(always)]
pub const fn from_bits(val: u8) -> Hpre {
unsafe { core::mem::transmute(val & 0x0f) }
}
#[inline(always)]
pub const fn to_bits(self) -> u8 {
unsafe { core::mem::transmute(self) }
}
}
impl From<u8> for Hpre {
#[inline(always)]
fn from(val: u8) -> Hpre {
Hpre::from_bits(val)
}
}
impl From<Hpre> for u8 {
#[inline(always)]
fn from(val: Hpre) -> u8 {
Hpre::to_bits(val)
}
}
#[repr(u8)]
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum I2csel {
#[doc = "APB clock selected as I2C clock"]
PCLK1 = 0x0,
#[doc = "System clock selected as I2C clock"]
SYS = 0x01,
#[doc = "HSI clock selected as I2C clock"]
HSI = 0x02,
_RESERVED_3 = 0x03,
}
impl I2csel {
#[inline(always)]
pub const fn from_bits(val: u8) -> I2csel {
unsafe { core::mem::transmute(val & 0x03) }
}
#[inline(always)]
pub const fn to_bits(self) -> u8 {
unsafe { core::mem::transmute(self) }
}
}
impl From<u8> for I2csel {
#[inline(always)]
fn from(val: u8) -> I2csel {
I2csel::from_bits(val)
}
}
impl From<I2csel> for u8 {
#[inline(always)]
fn from(val: I2csel) -> u8 {
I2csel::to_bits(val)
}
}
#[repr(u8)]
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum Issrc {
#[doc = "PLLI2S clock used as I2S clock source"]
PLLI2S = 0x0,
#[doc = "External clock mapped on the I2S_CKIN pin used as I2S clock source"]
CKIN = 0x01,
}
impl Issrc {
#[inline(always)]
pub const fn from_bits(val: u8) -> Issrc {
unsafe { core::mem::transmute(val & 0x01) }
}
#[inline(always)]
pub const fn to_bits(self) -> u8 {
unsafe { core::mem::transmute(self) }
}
}
impl From<u8> for Issrc {
#[inline(always)]
fn from(val: u8) -> Issrc {
Issrc::from_bits(val)
}
}
impl From<Issrc> for u8 {
#[inline(always)]
fn from(val: Issrc) -> u8 {
Issrc::to_bits(val)
}
}
#[repr(u8)]
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum Lptimsel {
#[doc = "APB1 clock (PCLK1) selected as LPTILM1 clock"]
PCLK1 = 0x0,
#[doc = "LSI clock is selected as LPTILM1 clock"]
LSI = 0x01,
#[doc = "HSI clock is selected as LPTILM1 clock"]
HSI = 0x02,
#[doc = "LSE clock is selected as LPTILM1 clock"]
LSE = 0x03,
}
impl Lptimsel {
#[inline(always)]
pub const fn from_bits(val: u8) -> Lptimsel {
unsafe { core::mem::transmute(val & 0x03) }
}
#[inline(always)]
pub const fn to_bits(self) -> u8 {
unsafe { core::mem::transmute(self) }
}
}
impl From<u8> for Lptimsel {
#[inline(always)]
fn from(val: u8) -> Lptimsel {
Lptimsel::from_bits(val)
}
}
impl From<Lptimsel> for u8 {
#[inline(always)]
fn from(val: Lptimsel) -> u8 {
Lptimsel::to_bits(val)
}
}
#[repr(u8)]
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum Lsedrv {
#[doc = "Low driving capability"]
LOW = 0x0,
#[doc = "Medium high driving capability"]
MEDIUM_HIGH = 0x01,
#[doc = "Medium low driving capability"]
MEDIUM_LOW = 0x02,
#[doc = "High driving capability"]
HIGH = 0x03,
}
impl Lsedrv {
#[inline(always)]
pub const fn from_bits(val: u8) -> Lsedrv {
unsafe { core::mem::transmute(val & 0x03) }
}
#[inline(always)]
pub const fn to_bits(self) -> u8 {
unsafe { core::mem::transmute(self) }
}
}
impl From<u8> for Lsedrv {
#[inline(always)]
fn from(val: u8) -> Lsedrv {
Lsedrv::from_bits(val)
}
}
impl From<Lsedrv> for u8 {
#[inline(always)]
fn from(val: Lsedrv) -> u8 {
Lsedrv::to_bits(val)
}
}
#[repr(u8)]
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum Mco1sel {
#[doc = "HSI clock selected"]
HSI = 0x0,
#[doc = "LSE oscillator selected"]
LSE = 0x01,
#[doc = "HSE oscillator clock selected"]
HSE = 0x02,
#[doc = "PLL clock selected"]
PLL = 0x03,
}
impl Mco1sel {
#[inline(always)]
pub const fn from_bits(val: u8) -> Mco1sel {
unsafe { core::mem::transmute(val & 0x03) }
}
#[inline(always)]
pub const fn to_bits(self) -> u8 {
unsafe { core::mem::transmute(self) }
}
}
impl From<u8> for Mco1sel {
#[inline(always)]
fn from(val: u8) -> Mco1sel {
Mco1sel::from_bits(val)
}
}
impl From<Mco1sel> for u8 {
#[inline(always)]
fn from(val: Mco1sel) -> u8 {
Mco1sel::to_bits(val)
}
}
#[repr(u8)]
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum Mco2sel {
#[doc = "System clock (SYSCLK) selected"]
SYS = 0x0,
#[doc = "PLLI2S clock selected"]
PLLI2S = 0x01,
#[doc = "HSE oscillator clock selected"]
HSE = 0x02,
#[doc = "PLL clock selected"]
PLL = 0x03,
}
impl Mco2sel {
#[inline(always)]
pub const fn from_bits(val: u8) -> Mco2sel {
unsafe { core::mem::transmute(val & 0x03) }
}
#[inline(always)]
pub const fn to_bits(self) -> u8 {
unsafe { core::mem::transmute(self) }
}
}
impl From<u8> for Mco2sel {
#[inline(always)]
fn from(val: u8) -> Mco2sel {
Mco2sel::from_bits(val)
}
}
impl From<Mco2sel> for u8 {
#[inline(always)]
fn from(val: Mco2sel) -> u8 {
Mco2sel::to_bits(val)
}
}
#[repr(u8)]
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum Mcopre {
#[doc = "No division"]
DIV1 = 0x0,
_RESERVED_1 = 0x01,
_RESERVED_2 = 0x02,
_RESERVED_3 = 0x03,
#[doc = "Division by 2"]
DIV2 = 0x04,
#[doc = "Division by 3"]
DIV3 = 0x05,
#[doc = "Division by 4"]
DIV4 = 0x06,
#[doc = "Division by 5"]
DIV5 = 0x07,
}
impl Mcopre {
#[inline(always)]
pub const fn from_bits(val: u8) -> Mcopre {
unsafe { core::mem::transmute(val & 0x07) }
}
#[inline(always)]
pub const fn to_bits(self) -> u8 {
unsafe { core::mem::transmute(self) }
}
}
impl From<u8> for Mcopre {
#[inline(always)]
fn from(val: u8) -> Mcopre {
Mcopre::from_bits(val)
}
}
impl From<Mcopre> for u8 {
#[inline(always)]
fn from(val: Mcopre) -> u8 {
Mcopre::to_bits(val)
}
}
#[repr(u8)]
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum Plli2sdivq {
#[doc = "PLLI2SDIVQ = /1"]
DIV1 = 0x0,
#[doc = "PLLI2SDIVQ = /2"]
DIV2 = 0x01,
#[doc = "PLLI2SDIVQ = /3"]
DIV3 = 0x02,
#[doc = "PLLI2SDIVQ = /4"]
DIV4 = 0x03,
#[doc = "PLLI2SDIVQ = /5"]
DIV5 = 0x04,
#[doc = "PLLI2SDIVQ = /6"]
DIV6 = 0x05,
#[doc = "PLLI2SDIVQ = /7"]
DIV7 = 0x06,
#[doc = "PLLI2SDIVQ = /8"]
DIV8 = 0x07,
#[doc = "PLLI2SDIVQ = /9"]
DIV9 = 0x08,
#[doc = "PLLI2SDIVQ = /10"]
DIV10 = 0x09,
#[doc = "PLLI2SDIVQ = /11"]
DIV11 = 0x0a,
#[doc = "PLLI2SDIVQ = /12"]
DIV12 = 0x0b,
#[doc = "PLLI2SDIVQ = /13"]
DIV13 = 0x0c,
#[doc = "PLLI2SDIVQ = /14"]
DIV14 = 0x0d,
#[doc = "PLLI2SDIVQ = /15"]
DIV15 = 0x0e,
#[doc = "PLLI2SDIVQ = /16"]
DIV16 = 0x0f,
#[doc = "PLLI2SDIVQ = /17"]
DIV17 = 0x10,
#[doc = "PLLI2SDIVQ = /18"]
DIV18 = 0x11,
#[doc = "PLLI2SDIVQ = /19"]
DIV19 = 0x12,
#[doc = "PLLI2SDIVQ = /20"]
DIV20 = 0x13,
#[doc = "PLLI2SDIVQ = /21"]
DIV21 = 0x14,
#[doc = "PLLI2SDIVQ = /22"]
DIV22 = 0x15,
#[doc = "PLLI2SDIVQ = /23"]
DIV23 = 0x16,
#[doc = "PLLI2SDIVQ = /24"]
DIV24 = 0x17,
#[doc = "PLLI2SDIVQ = /25"]
DIV25 = 0x18,
#[doc = "PLLI2SDIVQ = /26"]
DIV26 = 0x19,
#[doc = "PLLI2SDIVQ = /27"]
DIV27 = 0x1a,
#[doc = "PLLI2SDIVQ = /28"]
DIV28 = 0x1b,
#[doc = "PLLI2SDIVQ = /29"]
DIV29 = 0x1c,
#[doc = "PLLI2SDIVQ = /30"]
DIV30 = 0x1d,
#[doc = "PLLI2SDIVQ = /31"]
DIV31 = 0x1e,
#[doc = "PLLI2SDIVQ = /32"]
DIV32 = 0x1f,
}
impl Plli2sdivq {
#[inline(always)]
pub const fn from_bits(val: u8) -> Plli2sdivq {
unsafe { core::mem::transmute(val & 0x1f) }
}
#[inline(always)]
pub const fn to_bits(self) -> u8 {
unsafe { core::mem::transmute(self) }
}
}
impl From<u8> for Plli2sdivq {
#[inline(always)]
fn from(val: u8) -> Plli2sdivq {
Plli2sdivq::from_bits(val)
}
}
impl From<Plli2sdivq> for u8 {
#[inline(always)]
fn from(val: Plli2sdivq) -> u8 {
Plli2sdivq::to_bits(val)
}
}
#[repr(u8)]
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum Pllm {
_RESERVED_0 = 0x0,
_RESERVED_1 = 0x01,
DIV2 = 0x02,
DIV3 = 0x03,
DIV4 = 0x04,
DIV5 = 0x05,
DIV6 = 0x06,
DIV7 = 0x07,
DIV8 = 0x08,
DIV9 = 0x09,
DIV10 = 0x0a,
DIV11 = 0x0b,
DIV12 = 0x0c,
DIV13 = 0x0d,
DIV14 = 0x0e,
DIV15 = 0x0f,
DIV16 = 0x10,
DIV17 = 0x11,
DIV18 = 0x12,
DIV19 = 0x13,
DIV20 = 0x14,
DIV21 = 0x15,
DIV22 = 0x16,
DIV23 = 0x17,
DIV24 = 0x18,
DIV25 = 0x19,
DIV26 = 0x1a,
DIV27 = 0x1b,
DIV28 = 0x1c,
DIV29 = 0x1d,
DIV30 = 0x1e,
DIV31 = 0x1f,
DIV32 = 0x20,
DIV33 = 0x21,
DIV34 = 0x22,
DIV35 = 0x23,
DIV36 = 0x24,
DIV37 = 0x25,
DIV38 = 0x26,
DIV39 = 0x27,
DIV40 = 0x28,
DIV41 = 0x29,
DIV42 = 0x2a,
DIV43 = 0x2b,
DIV44 = 0x2c,
DIV45 = 0x2d,
DIV46 = 0x2e,
DIV47 = 0x2f,
DIV48 = 0x30,
DIV49 = 0x31,
DIV50 = 0x32,
DIV51 = 0x33,
DIV52 = 0x34,
DIV53 = 0x35,
DIV54 = 0x36,
DIV55 = 0x37,
DIV56 = 0x38,
DIV57 = 0x39,
DIV58 = 0x3a,
DIV59 = 0x3b,
DIV60 = 0x3c,
DIV61 = 0x3d,
DIV62 = 0x3e,
DIV63 = 0x3f,
}
impl Pllm {
#[inline(always)]
pub const fn from_bits(val: u8) -> Pllm {
unsafe { core::mem::transmute(val & 0x3f) }
}
#[inline(always)]
pub const fn to_bits(self) -> u8 {
unsafe { core::mem::transmute(self) }
}
}
impl From<u8> for Pllm {
#[inline(always)]
fn from(val: u8) -> Pllm {
Pllm::from_bits(val)
}
}
impl From<Pllm> for u8 {
#[inline(always)]
fn from(val: Pllm) -> u8 {
Pllm::to_bits(val)
}
}
#[repr(u16)]
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum Plln {
_RESERVED_0 = 0x0,
_RESERVED_1 = 0x01,
_RESERVED_2 = 0x02,
_RESERVED_3 = 0x03,
_RESERVED_4 = 0x04,
_RESERVED_5 = 0x05,
_RESERVED_6 = 0x06,
_RESERVED_7 = 0x07,
_RESERVED_8 = 0x08,
_RESERVED_9 = 0x09,
_RESERVED_a = 0x0a,
_RESERVED_b = 0x0b,
_RESERVED_c = 0x0c,
_RESERVED_d = 0x0d,
_RESERVED_e = 0x0e,
_RESERVED_f = 0x0f,
_RESERVED_10 = 0x10,
_RESERVED_11 = 0x11,
_RESERVED_12 = 0x12,
_RESERVED_13 = 0x13,
_RESERVED_14 = 0x14,
_RESERVED_15 = 0x15,
_RESERVED_16 = 0x16,
_RESERVED_17 = 0x17,
_RESERVED_18 = 0x18,
_RESERVED_19 = 0x19,
_RESERVED_1a = 0x1a,
_RESERVED_1b = 0x1b,
_RESERVED_1c = 0x1c,
_RESERVED_1d = 0x1d,
_RESERVED_1e = 0x1e,
_RESERVED_1f = 0x1f,
_RESERVED_20 = 0x20,
_RESERVED_21 = 0x21,
_RESERVED_22 = 0x22,
_RESERVED_23 = 0x23,
_RESERVED_24 = 0x24,
_RESERVED_25 = 0x25,
_RESERVED_26 = 0x26,
_RESERVED_27 = 0x27,
_RESERVED_28 = 0x28,
_RESERVED_29 = 0x29,
_RESERVED_2a = 0x2a,
_RESERVED_2b = 0x2b,
_RESERVED_2c = 0x2c,
_RESERVED_2d = 0x2d,
_RESERVED_2e = 0x2e,
_RESERVED_2f = 0x2f,
_RESERVED_30 = 0x30,
_RESERVED_31 = 0x31,
MUL50 = 0x32,
MUL51 = 0x33,
MUL52 = 0x34,
MUL53 = 0x35,
MUL54 = 0x36,
MUL55 = 0x37,
MUL56 = 0x38,
MUL57 = 0x39,
MUL58 = 0x3a,
MUL59 = 0x3b,
MUL60 = 0x3c,
MUL61 = 0x3d,
MUL62 = 0x3e,
MUL63 = 0x3f,
MUL64 = 0x40,
MUL65 = 0x41,
MUL66 = 0x42,
MUL67 = 0x43,
MUL68 = 0x44,
MUL69 = 0x45,
MUL70 = 0x46,
MUL71 = 0x47,
MUL72 = 0x48,
MUL73 = 0x49,
MUL74 = 0x4a,
MUL75 = 0x4b,
MUL76 = 0x4c,
MUL77 = 0x4d,
MUL78 = 0x4e,
MUL79 = 0x4f,
MUL80 = 0x50,
MUL81 = 0x51,
MUL82 = 0x52,
MUL83 = 0x53,
MUL84 = 0x54,
MUL85 = 0x55,
MUL86 = 0x56,
MUL87 = 0x57,
MUL88 = 0x58,
MUL89 = 0x59,
MUL90 = 0x5a,
MUL91 = 0x5b,
MUL92 = 0x5c,
MUL93 = 0x5d,
MUL94 = 0x5e,
MUL95 = 0x5f,
MUL96 = 0x60,
MUL97 = 0x61,
MUL98 = 0x62,
MUL99 = 0x63,
MUL100 = 0x64,
MUL101 = 0x65,
MUL102 = 0x66,
MUL103 = 0x67,
MUL104 = 0x68,
MUL105 = 0x69,
MUL106 = 0x6a,
MUL107 = 0x6b,
MUL108 = 0x6c,
MUL109 = 0x6d,
MUL110 = 0x6e,
MUL111 = 0x6f,
MUL112 = 0x70,
MUL113 = 0x71,
MUL114 = 0x72,
MUL115 = 0x73,
MUL116 = 0x74,
MUL117 = 0x75,
MUL118 = 0x76,
MUL119 = 0x77,
MUL120 = 0x78,
MUL121 = 0x79,
MUL122 = 0x7a,
MUL123 = 0x7b,
MUL124 = 0x7c,
MUL125 = 0x7d,
MUL126 = 0x7e,
MUL127 = 0x7f,
MUL128 = 0x80,
MUL129 = 0x81,
MUL130 = 0x82,
MUL131 = 0x83,
MUL132 = 0x84,
MUL133 = 0x85,
MUL134 = 0x86,
MUL135 = 0x87,
MUL136 = 0x88,
MUL137 = 0x89,
MUL138 = 0x8a,
MUL139 = 0x8b,
MUL140 = 0x8c,
MUL141 = 0x8d,
MUL142 = 0x8e,
MUL143 = 0x8f,
MUL144 = 0x90,
MUL145 = 0x91,
MUL146 = 0x92,
MUL147 = 0x93,
MUL148 = 0x94,
MUL149 = 0x95,
MUL150 = 0x96,
MUL151 = 0x97,
MUL152 = 0x98,
MUL153 = 0x99,
MUL154 = 0x9a,
MUL155 = 0x9b,
MUL156 = 0x9c,
MUL157 = 0x9d,
MUL158 = 0x9e,
MUL159 = 0x9f,
MUL160 = 0xa0,
MUL161 = 0xa1,
MUL162 = 0xa2,
MUL163 = 0xa3,
MUL164 = 0xa4,
MUL165 = 0xa5,
MUL166 = 0xa6,
MUL167 = 0xa7,
MUL168 = 0xa8,
MUL169 = 0xa9,
MUL170 = 0xaa,
MUL171 = 0xab,
MUL172 = 0xac,
MUL173 = 0xad,
MUL174 = 0xae,
MUL175 = 0xaf,
MUL176 = 0xb0,
MUL177 = 0xb1,
MUL178 = 0xb2,
MUL179 = 0xb3,
MUL180 = 0xb4,
MUL181 = 0xb5,
MUL182 = 0xb6,
MUL183 = 0xb7,
MUL184 = 0xb8,
MUL185 = 0xb9,
MUL186 = 0xba,
MUL187 = 0xbb,
MUL188 = 0xbc,
MUL189 = 0xbd,
MUL190 = 0xbe,
MUL191 = 0xbf,
MUL192 = 0xc0,
MUL193 = 0xc1,
MUL194 = 0xc2,
MUL195 = 0xc3,
MUL196 = 0xc4,
MUL197 = 0xc5,
MUL198 = 0xc6,
MUL199 = 0xc7,
MUL200 = 0xc8,
MUL201 = 0xc9,
MUL202 = 0xca,
MUL203 = 0xcb,
MUL204 = 0xcc,
MUL205 = 0xcd,
MUL206 = 0xce,
MUL207 = 0xcf,
MUL208 = 0xd0,
MUL209 = 0xd1,
MUL210 = 0xd2,
MUL211 = 0xd3,
MUL212 = 0xd4,
MUL213 = 0xd5,
MUL214 = 0xd6,
MUL215 = 0xd7,
MUL216 = 0xd8,
MUL217 = 0xd9,
MUL218 = 0xda,
MUL219 = 0xdb,
MUL220 = 0xdc,
MUL221 = 0xdd,
MUL222 = 0xde,
MUL223 = 0xdf,
MUL224 = 0xe0,
MUL225 = 0xe1,
MUL226 = 0xe2,
MUL227 = 0xe3,
MUL228 = 0xe4,
MUL229 = 0xe5,
MUL230 = 0xe6,
MUL231 = 0xe7,
MUL232 = 0xe8,
MUL233 = 0xe9,
MUL234 = 0xea,
MUL235 = 0xeb,
MUL236 = 0xec,
MUL237 = 0xed,
MUL238 = 0xee,
MUL239 = 0xef,
MUL240 = 0xf0,
MUL241 = 0xf1,
MUL242 = 0xf2,
MUL243 = 0xf3,
MUL244 = 0xf4,
MUL245 = 0xf5,
MUL246 = 0xf6,
MUL247 = 0xf7,
MUL248 = 0xf8,
MUL249 = 0xf9,
MUL250 = 0xfa,
MUL251 = 0xfb,
MUL252 = 0xfc,
MUL253 = 0xfd,
MUL254 = 0xfe,
MUL255 = 0xff,
MUL256 = 0x0100,
MUL257 = 0x0101,
MUL258 = 0x0102,
MUL259 = 0x0103,
MUL260 = 0x0104,
MUL261 = 0x0105,
MUL262 = 0x0106,
MUL263 = 0x0107,
MUL264 = 0x0108,
MUL265 = 0x0109,
MUL266 = 0x010a,
MUL267 = 0x010b,
MUL268 = 0x010c,
MUL269 = 0x010d,
MUL270 = 0x010e,
MUL271 = 0x010f,
MUL272 = 0x0110,
MUL273 = 0x0111,
MUL274 = 0x0112,
MUL275 = 0x0113,
MUL276 = 0x0114,
MUL277 = 0x0115,
MUL278 = 0x0116,
MUL279 = 0x0117,
MUL280 = 0x0118,
MUL281 = 0x0119,
MUL282 = 0x011a,
MUL283 = 0x011b,
MUL284 = 0x011c,
MUL285 = 0x011d,
MUL286 = 0x011e,
MUL287 = 0x011f,
MUL288 = 0x0120,
MUL289 = 0x0121,
MUL290 = 0x0122,
MUL291 = 0x0123,
MUL292 = 0x0124,
MUL293 = 0x0125,
MUL294 = 0x0126,
MUL295 = 0x0127,
MUL296 = 0x0128,
MUL297 = 0x0129,
MUL298 = 0x012a,
MUL299 = 0x012b,
MUL300 = 0x012c,
MUL301 = 0x012d,
MUL302 = 0x012e,
MUL303 = 0x012f,
MUL304 = 0x0130,
MUL305 = 0x0131,
MUL306 = 0x0132,
MUL307 = 0x0133,
MUL308 = 0x0134,
MUL309 = 0x0135,
MUL310 = 0x0136,
MUL311 = 0x0137,
MUL312 = 0x0138,
MUL313 = 0x0139,
MUL314 = 0x013a,
MUL315 = 0x013b,
MUL316 = 0x013c,
MUL317 = 0x013d,
MUL318 = 0x013e,
MUL319 = 0x013f,
MUL320 = 0x0140,
MUL321 = 0x0141,
MUL322 = 0x0142,
MUL323 = 0x0143,
MUL324 = 0x0144,
MUL325 = 0x0145,
MUL326 = 0x0146,
MUL327 = 0x0147,
MUL328 = 0x0148,
MUL329 = 0x0149,
MUL330 = 0x014a,
MUL331 = 0x014b,
MUL332 = 0x014c,
MUL333 = 0x014d,
MUL334 = 0x014e,
MUL335 = 0x014f,
MUL336 = 0x0150,
MUL337 = 0x0151,
MUL338 = 0x0152,
MUL339 = 0x0153,
MUL340 = 0x0154,
MUL341 = 0x0155,
MUL342 = 0x0156,
MUL343 = 0x0157,
MUL344 = 0x0158,
MUL345 = 0x0159,
MUL346 = 0x015a,
MUL347 = 0x015b,
MUL348 = 0x015c,
MUL349 = 0x015d,
MUL350 = 0x015e,
MUL351 = 0x015f,
MUL352 = 0x0160,
MUL353 = 0x0161,
MUL354 = 0x0162,
MUL355 = 0x0163,
MUL356 = 0x0164,
MUL357 = 0x0165,
MUL358 = 0x0166,
MUL359 = 0x0167,
MUL360 = 0x0168,
MUL361 = 0x0169,
MUL362 = 0x016a,
MUL363 = 0x016b,
MUL364 = 0x016c,
MUL365 = 0x016d,
MUL366 = 0x016e,
MUL367 = 0x016f,
MUL368 = 0x0170,
MUL369 = 0x0171,
MUL370 = 0x0172,
MUL371 = 0x0173,
MUL372 = 0x0174,
MUL373 = 0x0175,
MUL374 = 0x0176,
MUL375 = 0x0177,
MUL376 = 0x0178,
MUL377 = 0x0179,
MUL378 = 0x017a,
MUL379 = 0x017b,
MUL380 = 0x017c,
MUL381 = 0x017d,
MUL382 = 0x017e,
MUL383 = 0x017f,
MUL384 = 0x0180,
MUL385 = 0x0181,
MUL386 = 0x0182,
MUL387 = 0x0183,
MUL388 = 0x0184,
MUL389 = 0x0185,
MUL390 = 0x0186,
MUL391 = 0x0187,
MUL392 = 0x0188,
MUL393 = 0x0189,
MUL394 = 0x018a,
MUL395 = 0x018b,
MUL396 = 0x018c,
MUL397 = 0x018d,
MUL398 = 0x018e,
MUL399 = 0x018f,
MUL400 = 0x0190,
MUL401 = 0x0191,
MUL402 = 0x0192,
MUL403 = 0x0193,
MUL404 = 0x0194,
MUL405 = 0x0195,
MUL406 = 0x0196,
MUL407 = 0x0197,
MUL408 = 0x0198,
MUL409 = 0x0199,
MUL410 = 0x019a,
MUL411 = 0x019b,
MUL412 = 0x019c,
MUL413 = 0x019d,
MUL414 = 0x019e,
MUL415 = 0x019f,
MUL416 = 0x01a0,
MUL417 = 0x01a1,
MUL418 = 0x01a2,
MUL419 = 0x01a3,
MUL420 = 0x01a4,
MUL421 = 0x01a5,
MUL422 = 0x01a6,
MUL423 = 0x01a7,
MUL424 = 0x01a8,
MUL425 = 0x01a9,
MUL426 = 0x01aa,
MUL427 = 0x01ab,
MUL428 = 0x01ac,
MUL429 = 0x01ad,
MUL430 = 0x01ae,
MUL431 = 0x01af,
MUL432 = 0x01b0,
_RESERVED_1b1 = 0x01b1,
_RESERVED_1b2 = 0x01b2,
_RESERVED_1b3 = 0x01b3,
_RESERVED_1b4 = 0x01b4,
_RESERVED_1b5 = 0x01b5,
_RESERVED_1b6 = 0x01b6,
_RESERVED_1b7 = 0x01b7,
_RESERVED_1b8 = 0x01b8,
_RESERVED_1b9 = 0x01b9,
_RESERVED_1ba = 0x01ba,
_RESERVED_1bb = 0x01bb,
_RESERVED_1bc = 0x01bc,
_RESERVED_1bd = 0x01bd,
_RESERVED_1be = 0x01be,
_RESERVED_1bf = 0x01bf,
_RESERVED_1c0 = 0x01c0,
_RESERVED_1c1 = 0x01c1,
_RESERVED_1c2 = 0x01c2,
_RESERVED_1c3 = 0x01c3,
_RESERVED_1c4 = 0x01c4,
_RESERVED_1c5 = 0x01c5,
_RESERVED_1c6 = 0x01c6,
_RESERVED_1c7 = 0x01c7,
_RESERVED_1c8 = 0x01c8,
_RESERVED_1c9 = 0x01c9,
_RESERVED_1ca = 0x01ca,
_RESERVED_1cb = 0x01cb,
_RESERVED_1cc = 0x01cc,
_RESERVED_1cd = 0x01cd,
_RESERVED_1ce = 0x01ce,
_RESERVED_1cf = 0x01cf,
_RESERVED_1d0 = 0x01d0,
_RESERVED_1d1 = 0x01d1,
_RESERVED_1d2 = 0x01d2,
_RESERVED_1d3 = 0x01d3,
_RESERVED_1d4 = 0x01d4,
_RESERVED_1d5 = 0x01d5,
_RESERVED_1d6 = 0x01d6,
_RESERVED_1d7 = 0x01d7,
_RESERVED_1d8 = 0x01d8,
_RESERVED_1d9 = 0x01d9,
_RESERVED_1da = 0x01da,
_RESERVED_1db = 0x01db,
_RESERVED_1dc = 0x01dc,
_RESERVED_1dd = 0x01dd,
_RESERVED_1de = 0x01de,
_RESERVED_1df = 0x01df,
_RESERVED_1e0 = 0x01e0,
_RESERVED_1e1 = 0x01e1,
_RESERVED_1e2 = 0x01e2,
_RESERVED_1e3 = 0x01e3,
_RESERVED_1e4 = 0x01e4,
_RESERVED_1e5 = 0x01e5,
_RESERVED_1e6 = 0x01e6,
_RESERVED_1e7 = 0x01e7,
_RESERVED_1e8 = 0x01e8,
_RESERVED_1e9 = 0x01e9,
_RESERVED_1ea = 0x01ea,
_RESERVED_1eb = 0x01eb,
_RESERVED_1ec = 0x01ec,
_RESERVED_1ed = 0x01ed,
_RESERVED_1ee = 0x01ee,
_RESERVED_1ef = 0x01ef,
_RESERVED_1f0 = 0x01f0,
_RESERVED_1f1 = 0x01f1,
_RESERVED_1f2 = 0x01f2,
_RESERVED_1f3 = 0x01f3,
_RESERVED_1f4 = 0x01f4,
_RESERVED_1f5 = 0x01f5,
_RESERVED_1f6 = 0x01f6,
_RESERVED_1f7 = 0x01f7,
_RESERVED_1f8 = 0x01f8,
_RESERVED_1f9 = 0x01f9,
_RESERVED_1fa = 0x01fa,
_RESERVED_1fb = 0x01fb,
_RESERVED_1fc = 0x01fc,
_RESERVED_1fd = 0x01fd,
_RESERVED_1fe = 0x01fe,
_RESERVED_1ff = 0x01ff,
}
impl Plln {
#[inline(always)]
pub const fn from_bits(val: u16) -> Plln {
unsafe { core::mem::transmute(val & 0x01ff) }
}
#[inline(always)]
pub const fn to_bits(self) -> u16 {
unsafe { core::mem::transmute(self) }
}
}
impl From<u16> for Plln {
#[inline(always)]
fn from(val: u16) -> Plln {
Plln::from_bits(val)
}
}
impl From<Plln> for u16 {
#[inline(always)]
fn from(val: Plln) -> u16 {
Plln::to_bits(val)
}
}
#[repr(u8)]
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum Pllp {
#[doc = "PLLP=2"]
DIV2 = 0x0,
#[doc = "PLLP=4"]
DIV4 = 0x01,
#[doc = "PLLP=6"]
DIV6 = 0x02,
#[doc = "PLLP=8"]
DIV8 = 0x03,
}
impl Pllp {
#[inline(always)]
pub const fn from_bits(val: u8) -> Pllp {
unsafe { core::mem::transmute(val & 0x03) }
}
#[inline(always)]
pub const fn to_bits(self) -> u8 {
unsafe { core::mem::transmute(self) }
}
}
impl From<u8> for Pllp {
#[inline(always)]
fn from(val: u8) -> Pllp {
Pllp::from_bits(val)
}
}
impl From<Pllp> for u8 {
#[inline(always)]
fn from(val: Pllp) -> u8 {
Pllp::to_bits(val)
}
}
#[repr(u8)]
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum Pllq {
_RESERVED_0 = 0x0,
_RESERVED_1 = 0x01,
DIV2 = 0x02,
DIV3 = 0x03,
DIV4 = 0x04,
DIV5 = 0x05,
DIV6 = 0x06,
DIV7 = 0x07,
DIV8 = 0x08,
DIV9 = 0x09,
DIV10 = 0x0a,
DIV11 = 0x0b,
DIV12 = 0x0c,
DIV13 = 0x0d,
DIV14 = 0x0e,
DIV15 = 0x0f,
}
impl Pllq {
#[inline(always)]
pub const fn from_bits(val: u8) -> Pllq {
unsafe { core::mem::transmute(val & 0x0f) }
}
#[inline(always)]
pub const fn to_bits(self) -> u8 {
unsafe { core::mem::transmute(self) }
}
}
impl From<u8> for Pllq {
#[inline(always)]
fn from(val: u8) -> Pllq {
Pllq::from_bits(val)
}
}
impl From<Pllq> for u8 {
#[inline(always)]
fn from(val: Pllq) -> u8 {
Pllq::to_bits(val)
}
}
#[repr(u8)]
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum Pllr {
_RESERVED_0 = 0x0,
_RESERVED_1 = 0x01,
DIV2 = 0x02,
DIV3 = 0x03,
DIV4 = 0x04,
DIV5 = 0x05,
DIV6 = 0x06,
DIV7 = 0x07,
}
impl Pllr {
#[inline(always)]
pub const fn from_bits(val: u8) -> Pllr {
unsafe { core::mem::transmute(val & 0x07) }
}
#[inline(always)]
pub const fn to_bits(self) -> u8 {
unsafe { core::mem::transmute(self) }
}
}
impl From<u8> for Pllr {
#[inline(always)]
fn from(val: u8) -> Pllr {
Pllr::from_bits(val)
}
}
impl From<Pllr> for u8 {
#[inline(always)]
fn from(val: Pllr) -> u8 {
Pllr::to_bits(val)
}
}
#[repr(u8)]
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum Pllsaidivq {
#[doc = "PLLSAIDIVQ = /1"]
DIV1 = 0x0,
#[doc = "PLLSAIDIVQ = /2"]
DIV2 = 0x01,
#[doc = "PLLSAIDIVQ = /3"]
DIV3 = 0x02,
#[doc = "PLLSAIDIVQ = /4"]
DIV4 = 0x03,
#[doc = "PLLSAIDIVQ = /5"]
DIV5 = 0x04,
#[doc = "PLLSAIDIVQ = /6"]
DIV6 = 0x05,
#[doc = "PLLSAIDIVQ = /7"]
DIV7 = 0x06,
#[doc = "PLLSAIDIVQ = /8"]
DIV8 = 0x07,
#[doc = "PLLSAIDIVQ = /9"]
DIV9 = 0x08,
#[doc = "PLLSAIDIVQ = /10"]
DIV10 = 0x09,
#[doc = "PLLSAIDIVQ = /11"]
DIV11 = 0x0a,
#[doc = "PLLSAIDIVQ = /12"]
DIV12 = 0x0b,
#[doc = "PLLSAIDIVQ = /13"]
DIV13 = 0x0c,
#[doc = "PLLSAIDIVQ = /14"]
DIV14 = 0x0d,
#[doc = "PLLSAIDIVQ = /15"]
DIV15 = 0x0e,
#[doc = "PLLSAIDIVQ = /16"]
DIV16 = 0x0f,
#[doc = "PLLSAIDIVQ = /17"]
DIV17 = 0x10,
#[doc = "PLLSAIDIVQ = /18"]
DIV18 = 0x11,
#[doc = "PLLSAIDIVQ = /19"]
DIV19 = 0x12,
#[doc = "PLLSAIDIVQ = /20"]
DIV20 = 0x13,
#[doc = "PLLSAIDIVQ = /21"]
DIV21 = 0x14,
#[doc = "PLLSAIDIVQ = /22"]
DIV22 = 0x15,
#[doc = "PLLSAIDIVQ = /23"]
DIV23 = 0x16,
#[doc = "PLLSAIDIVQ = /24"]
DIV24 = 0x17,
#[doc = "PLLSAIDIVQ = /25"]
DIV25 = 0x18,
#[doc = "PLLSAIDIVQ = /26"]
DIV26 = 0x19,
#[doc = "PLLSAIDIVQ = /27"]
DIV27 = 0x1a,
#[doc = "PLLSAIDIVQ = /28"]
DIV28 = 0x1b,
#[doc = "PLLSAIDIVQ = /29"]
DIV29 = 0x1c,
#[doc = "PLLSAIDIVQ = /30"]
DIV30 = 0x1d,
#[doc = "PLLSAIDIVQ = /31"]
DIV31 = 0x1e,
#[doc = "PLLSAIDIVQ = /32"]
DIV32 = 0x1f,
}
impl Pllsaidivq {
#[inline(always)]
pub const fn from_bits(val: u8) -> Pllsaidivq {
unsafe { core::mem::transmute(val & 0x1f) }
}
#[inline(always)]
pub const fn to_bits(self) -> u8 {
unsafe { core::mem::transmute(self) }
}
}
impl From<u8> for Pllsaidivq {
#[inline(always)]
fn from(val: u8) -> Pllsaidivq {
Pllsaidivq::from_bits(val)
}
}
impl From<Pllsaidivq> for u8 {
#[inline(always)]
fn from(val: Pllsaidivq) -> u8 {
Pllsaidivq::to_bits(val)
}
}
#[repr(u8)]
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum Pllsaidivr {
#[doc = "PLLSAIDIVR = /2"]
DIV2 = 0x0,
#[doc = "PLLSAIDIVR = /4"]
DIV4 = 0x01,
#[doc = "PLLSAIDIVR = /8"]
DIV8 = 0x02,
#[doc = "PLLSAIDIVR = /16"]
DIV16 = 0x03,
}
impl Pllsaidivr {
#[inline(always)]
pub const fn from_bits(val: u8) -> Pllsaidivr {
unsafe { core::mem::transmute(val & 0x03) }
}
#[inline(always)]
pub const fn to_bits(self) -> u8 {
unsafe { core::mem::transmute(self) }
}
}
impl From<u8> for Pllsaidivr {
#[inline(always)]
fn from(val: u8) -> Pllsaidivr {
Pllsaidivr::from_bits(val)
}
}
impl From<Pllsaidivr> for u8 {
#[inline(always)]
fn from(val: Pllsaidivr) -> u8 {
Pllsaidivr::to_bits(val)
}
}
#[repr(u8)]
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum Pllsrc {
#[doc = "HSI clock selected as PLL and PLLI2S clock entry"]
HSI = 0x0,
#[doc = "HSE oscillator clock selected as PLL and PLLI2S clock entry"]
HSE = 0x01,
}
impl Pllsrc {
#[inline(always)]
pub const fn from_bits(val: u8) -> Pllsrc {
unsafe { core::mem::transmute(val & 0x01) }
}
#[inline(always)]
pub const fn to_bits(self) -> u8 {
unsafe { core::mem::transmute(self) }
}
}
impl From<u8> for Pllsrc {
#[inline(always)]
fn from(val: u8) -> Pllsrc {
Pllsrc::from_bits(val)
}
}
impl From<Pllsrc> for u8 {
#[inline(always)]
fn from(val: Pllsrc) -> u8 {
Pllsrc::to_bits(val)
}
}
#[repr(u8)]
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum Ppre {
#[doc = "HCLK not divided"]
DIV1 = 0x0,
_RESERVED_1 = 0x01,
_RESERVED_2 = 0x02,
_RESERVED_3 = 0x03,
#[doc = "HCLK divided by 2"]
DIV2 = 0x04,
#[doc = "HCLK divided by 4"]
DIV4 = 0x05,
#[doc = "HCLK divided by 8"]
DIV8 = 0x06,
#[doc = "HCLK divided by 16"]
DIV16 = 0x07,
}
impl Ppre {
#[inline(always)]
pub const fn from_bits(val: u8) -> Ppre {
unsafe { core::mem::transmute(val & 0x07) }
}
#[inline(always)]
pub const fn to_bits(self) -> u8 {
unsafe { core::mem::transmute(self) }
}
}
impl From<u8> for Ppre {
#[inline(always)]
fn from(val: u8) -> Ppre {
Ppre::from_bits(val)
}
}
impl From<Ppre> for u8 {
#[inline(always)]
fn from(val: Ppre) -> u8 {
Ppre::to_bits(val)
}
}
#[repr(u8)]
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum Rtcsel {
#[doc = "No clock"]
DISABLE = 0x0,
#[doc = "LSE oscillator clock used as RTC clock"]
LSE = 0x01,
#[doc = "LSI oscillator clock used as RTC clock"]
LSI = 0x02,
#[doc = "HSE oscillator clock divided by a prescaler used as RTC clock"]
HSE = 0x03,
}
impl Rtcsel {
#[inline(always)]
pub const fn from_bits(val: u8) -> Rtcsel {
unsafe { core::mem::transmute(val & 0x03) }
}
#[inline(always)]
pub const fn to_bits(self) -> u8 {
unsafe { core::mem::transmute(self) }
}
}
impl From<u8> for Rtcsel {
#[inline(always)]
fn from(val: u8) -> Rtcsel {
Rtcsel::from_bits(val)
}
}
impl From<Rtcsel> for u8 {
#[inline(always)]
fn from(val: Rtcsel) -> u8 {
Rtcsel::to_bits(val)
}
}
#[repr(u8)]
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum Saisel {
#[doc = "SAI2 clock frequency = f(PLLSAI_Q) / PLLSAIDIVQ"]
PLLSAI1_Q = 0x0,
#[doc = "SAI2 clock frequency = f(PLLI2S_Q) / PLLI2SDIVQ"]
PLLI2S1_Q = 0x01,
#[doc = "SAI2 clock frequency = Alternate function input frequency"]
AFIF = 0x02,
#[doc = "SAI2 clock frequency = HSI or HSE"]
HSI_HSE = 0x03,
}
impl Saisel {
#[inline(always)]
pub const fn from_bits(val: u8) -> Saisel {
unsafe { core::mem::transmute(val & 0x03) }
}
#[inline(always)]
pub const fn to_bits(self) -> u8 {
unsafe { core::mem::transmute(self) }
}
}
impl From<u8> for Saisel {
#[inline(always)]
fn from(val: u8) -> Saisel {
Saisel::from_bits(val)
}
}
impl From<Saisel> for u8 {
#[inline(always)]
fn from(val: Saisel) -> u8 {
Saisel::to_bits(val)
}
}
#[repr(u8)]
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum Sdmmcsel {
#[doc = "48 MHz clock is selected as SD clock"]
CLK48 = 0x0,
#[doc = "System clock is selected as SD clock"]
SYS = 0x01,
}
impl Sdmmcsel {
#[inline(always)]
pub const fn from_bits(val: u8) -> Sdmmcsel {
unsafe { core::mem::transmute(val & 0x01) }
}
#[inline(always)]
pub const fn to_bits(self) -> u8 {
unsafe { core::mem::transmute(self) }
}
}
impl From<u8> for Sdmmcsel {
#[inline(always)]
fn from(val: u8) -> Sdmmcsel {
Sdmmcsel::from_bits(val)
}
}
impl From<Sdmmcsel> for u8 {
#[inline(always)]
fn from(val: Sdmmcsel) -> u8 {
Sdmmcsel::to_bits(val)
}
}
#[repr(u8)]
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum Spreadsel {
#[doc = "Center spread"]
CENTER = 0x0,
#[doc = "Down spread"]
DOWN = 0x01,
}
impl Spreadsel {
#[inline(always)]
pub const fn from_bits(val: u8) -> Spreadsel {
unsafe { core::mem::transmute(val & 0x01) }
}
#[inline(always)]
pub const fn to_bits(self) -> u8 {
unsafe { core::mem::transmute(self) }
}
}
impl From<u8> for Spreadsel {
#[inline(always)]
fn from(val: u8) -> Spreadsel {
Spreadsel::from_bits(val)
}
}
impl From<Spreadsel> for u8 {
#[inline(always)]
fn from(val: Spreadsel) -> u8 {
Spreadsel::to_bits(val)
}
}
#[repr(u8)]
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum Sw {
#[doc = "HSI oscillator used as system clock"]
HSI = 0x0,
#[doc = "HSE oscillator used as system clock"]
HSE = 0x01,
#[doc = "PLL used as system clock"]
PLL1_P = 0x02,
_RESERVED_3 = 0x03,
}
impl Sw {
#[inline(always)]
pub const fn from_bits(val: u8) -> Sw {
unsafe { core::mem::transmute(val & 0x03) }
}
#[inline(always)]
pub const fn to_bits(self) -> u8 {
unsafe { core::mem::transmute(self) }
}
}
impl From<u8> for Sw {
#[inline(always)]
fn from(val: u8) -> Sw {
Sw::from_bits(val)
}
}
impl From<Sw> for u8 {
#[inline(always)]
fn from(val: Sw) -> u8 {
Sw::to_bits(val)
}
}
#[repr(u8)]
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum Timpre {
#[doc = "If the APB prescaler is configured 1, TIMxCLK = PCLKx. Otherwise, TIMxCLK = 2xPCLKx"]
MUL2 = 0x0,
#[doc = "If the APB prescaler is configured 1, 2 or 4, TIMxCLK = HCLK. Otherwise, TIMxCLK = 4xPCLKx"]
MUL4 = 0x01,
}
impl Timpre {
#[inline(always)]
pub const fn from_bits(val: u8) -> Timpre {
unsafe { core::mem::transmute(val & 0x01) }
}
#[inline(always)]
pub const fn to_bits(self) -> u8 {
unsafe { core::mem::transmute(self) }
}
}
impl From<u8> for Timpre {
#[inline(always)]
fn from(val: u8) -> Timpre {
Timpre::from_bits(val)
}
}
impl From<Timpre> for u8 {
#[inline(always)]
fn from(val: Timpre) -> u8 {
Timpre::to_bits(val)
}
}
#[repr(u8)]
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum Usart1sel {
#[doc = "APB2 clock (PCLK2) is selected as USART clock"]
PCLK2 = 0x0,
#[doc = "System clock is selected as USART clock"]
SYS = 0x01,
#[doc = "HSI clock is selected as USART clock"]
HSI = 0x02,
#[doc = "LSE clock is selected as USART clock"]
LSE = 0x03,
}
impl Usart1sel {
#[inline(always)]
pub const fn from_bits(val: u8) -> Usart1sel {
unsafe { core::mem::transmute(val & 0x03) }
}
#[inline(always)]
pub const fn to_bits(self) -> u8 {
unsafe { core::mem::transmute(self) }
}
}
impl From<u8> for Usart1sel {
#[inline(always)]
fn from(val: u8) -> Usart1sel {
Usart1sel::from_bits(val)
}
}
impl From<Usart1sel> for u8 {
#[inline(always)]
fn from(val: Usart1sel) -> u8 {
Usart1sel::to_bits(val)
}
}
#[repr(u8)]
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum Usart2sel {
#[doc = "APB1 clock (PCLK1) is selected as USART clock"]
PCLK1 = 0x0,
#[doc = "System clock is selected as USART clock"]
SYS = 0x01,
#[doc = "HSI clock is selected as USART clock"]
HSI = 0x02,
#[doc = "LSE clock is selected as USART clock"]
LSE = 0x03,
}
impl Usart2sel {
#[inline(always)]
pub const fn from_bits(val: u8) -> Usart2sel {
unsafe { core::mem::transmute(val & 0x03) }
}
#[inline(always)]
pub const fn to_bits(self) -> u8 {
unsafe { core::mem::transmute(self) }
}
}
impl From<u8> for Usart2sel {
#[inline(always)]
fn from(val: u8) -> Usart2sel {
Usart2sel::from_bits(val)
}
}
impl From<Usart2sel> for u8 {
#[inline(always)]
fn from(val: Usart2sel) -> u8 {
Usart2sel::to_bits(val)
}
}
}